Logo ROOT  
Reference Guide
Go to the documentation of this file.
1// $Id: TGHtml.h,v 1.1 2007/05/04 17:07:01 brun Exp $
2// Author: Valeriy Onuchin 03/05/2007
5 * Copyright (C) 1995-2021, Rene Brun, Fons Rademakers and Reiner Rohlfs *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
14 HTML widget for xclass. Based on tkhtml 1.28
15 Copyright (C) 1997-2000 D. Richard Hipp <drh@acm.org>
16 Copyright (C) 2002-2003 Hector Peraza.
18 This library is free software; you can redistribute it and/or
19 modify it under the terms of the GNU Library General Public
20 License as published by the Free Software Foundation; either
21 version 2 of the License, or (at your option) any later version.
23 This library is distributed in the hope that it will be useful,
24 but WITHOUT ANY WARRANTY; without even the implied warranty of
26 Library General Public License for more details.
28 You should have received a copy of the GNU Library General Public
29 License along with this library; if not, write to the Free
30 Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
34#ifndef ROOT_TGHtml
35#define ROOT_TGHtml
37#include "TGView.h"
39#include "TGHtmlTokens.h"
41class TGClient;
42class TImage;
43class TGFont;
44class TGIdleHandler;
45class THashTable;
46class TTimer;
47class TGPopupMenu;
51#define HTML_RELIEF_FLAT 0
55//#define TABLE_TRIM_BLANK 1
57// Debug must be turned on for testing to work.
58//#define DEBUG
60#define CANT_HAPPEN \
61 fprintf(stderr, \
62 "Unplanned behavior in the HTML Widget in file %s line %d\n", \
63 __FILE__, __LINE__)
65#define UNTESTED \
66 fprintf(stderr, \
67 "Untested code executed in the HTML Widget in file %s line %d\n", \
68 __FILE__, __LINE__)
70// Sanity checking macros.
72#ifdef DEBUG
73#define HtmlAssert(X) \
74 if(!(X)){ \
75 fprintf(stderr,"Assertion failed on line %d of %s\n",__LINE__,__FILE__); \
76 }
77#define HtmlCantHappen \
78 fprintf(stderr,"Can't happen on line %d of %s\n",__LINE__,__FILE__);
80#define HtmlAssert(X)
81#define HtmlCantHappen
84// Bitmasks for the HtmlTraceMask global variable
86#define HtmlTrace_Table1 0x00000001
87#define HtmlTrace_Table2 0x00000002
88#define HtmlTrace_Table3 0x00000004
89#define HtmlTrace_Table4 0x00000008
90#define HtmlTrace_Table5 0x00000010
91#define HtmlTrace_Table6 0x00000020
92#define HtmlTrace_GetLine 0x00000100
93#define HtmlTrace_GetLine2 0x00000200
94#define HtmlTrace_FixLine 0x00000400
95#define HtmlTrace_BreakMarkup 0x00001000
96#define HtmlTrace_Style 0x00002000
97#define HtmlTrace_Input1 0x00004000
99// The TRACE macro is used to print internal information about the
100// HTML layout engine during testing and debugging. The amount of
101// information printed is governed by a global variable named
102// HtmlTraceMask. If bits in the first argument to the TRACE macro
103// match any bits in HtmlTraceMask variable, then the trace message
104// is printed.
106// All of this is completely disabled, of course, if the DEBUG macro
107// is not defined.
109#ifdef DEBUG
110extern int HtmlTraceMask;
111extern int HtmlDepth;
112# define TRACE_INDENT printf("%*s",HtmlDepth-3,"")
113# define TRACE(Flag, Args) \
114 if( (Flag)&HtmlTraceMask ){ \
115 TRACE_INDENT; printf Args; fflush(stdout); \
116 }
117# define TRACE_PUSH(Flag) if( (Flag)&HtmlTraceMask ){ HtmlDepth+=3; }
118# define TRACE_POP(Flag) if( (Flag)&HtmlTraceMask ){ HtmlDepth-=3; }
120# define TRACE_INDENT
121# define TRACE(Flag, Args)
122# define TRACE_PUSH(Flag)
123# define TRACE_POP(Flag)
129// Various data types. This code is designed to run on a modern cached
130// architecture where the CPU runs a lot faster than the memory bus. Hence
131// we try to pack as much data into as small a space as possible so that it
132// is more likely to fit in cache. The extra CPU instruction or two needed
133// to unpack the data is not normally an issue since we expect the speed of
134// the memory bus to be the limiting factor.
136typedef unsigned char Html_u8_t; // 8-bit unsigned integer
137typedef short Html_16_t; // 16-bit signed integer
138typedef unsigned short Html_u16_t; // 16-bit unsigned integer
139typedef int Html_32_t; // 32-bit signed integer
141// An instance of the following structure is used to record style
142// information on each Html element.
145 unsigned int fFont : 6; // Font to use for display
146 unsigned int fColor : 6; // Foreground color
147 signed int fSubscript : 4; // Positive for <sup>, negative for <sub>
148 unsigned int fAlign : 2; // Horizontal alignment
149 unsigned int fBgcolor : 6; // Background color
150 unsigned int fExpbg : 1; // Set to 1 if bgcolor explicitly set
151 unsigned int fFlags : 7; // the STY_ flags below
155// We allow 8 different font families: Normal, Bold, Italic and Bold-Italic
156// in either variable or constant width. Within each family there can be up
157// to 7 font sizes from 1 (the smallest) up to 7 (the largest). Hence, the
158// widget can use a maximum of 56 fonts. The ".font" field of the style is
159// an integer between 0 and 55 which indicates which font to use.
161// HP: we further subdivide the .font field into two 3-bit subfields (size
162// and family). That makes easier to manipulate the family field.
164#define N_FONT_FAMILY 8
165#define N_FONT_SIZE 7
166#define N_FONT 71
167#define NormalFont(X) (X)
168#define BoldFont(X) ((X) | 8)
169#define ItalicFont(X) ((X) | 16)
170#define CWFont(X) ((X) | 32)
171#define FontSize(X) ((X) & 007)
172#define FontFamily(X) ((X) & 070)
173#define FONT_Any -1
174#define FONT_Default 3
175#define FontSwitch(Size, Bold, Italic, Cw) \
176 ((Size) | ((Bold+(Italic)*2+(Cw)*4) << 3))
178// Macros for manipulating the fontValid bitmap of an TGHtml object.
180#define FontIsValid(I) ((fFontValid[(I)>>3] & (1<<((I)&3)))!=0)
181#define FontSetValid(I) (fFontValid[(I)>>3] |= (1<<((I)&3)))
182#define FontClearValid(I) (fFontValid[(I)>>3] &= ~(1<<((I)&3)))
185// Information about available colors.
187// The widget will use at most N_COLOR colors. 4 of these colors are
188// predefined. The rest are user selectable by options to various markups.
189// (Ex: <font color=red>)
191// All colors are stored in the apColor[] array of the main widget object.
192// The ".color" field of the SHtmlStyle_t is an integer between 0 and
193// N_COLOR-1 which indicates which of these colors to use.
195#define N_COLOR 32 // Total number of colors
197#define COLOR_Normal 0 // Index for normal color (black)
198#define COLOR_Unvisited 1 // Index for unvisited hyperlinks
199#define COLOR_Visited 2 // Color for visited hyperlinks
200#define COLOR_Selection 3 // Background color for the selection
201#define COLOR_Background 4 // Default background color
202#define N_PREDEFINED_COLOR 5 // Number of predefined colors
205// The "align" field of the style determines how text is justified
206// horizontally. ALIGN_None means that the alignment is not specified.
207// (It should probably default to ALIGN_Left in this case.)
209#define ALIGN_Left 1
210#define ALIGN_Right 2
211#define ALIGN_Center 3
212#define ALIGN_None 0
215// Possible value of the "flags" field of SHtmlStyle_t are shown below.
217// STY_Preformatted If set, the current text occurred within
218// <pre>..</pre>
220// STY_StrikeThru Draw a solid line thru the middle of this text.
222// STY_Underline This text should drawn with an underline.
224// STY_NoBreak This text occurs within <nobr>..</nobr>
226// STY_Anchor This text occurs within <a href=X>..</a>.
228// STY_DT This text occurs within <dt>..</dt>.
230// STY_Invisible This text should not appear in the main HTML
231// window. (For example, it might be within
232// <title>..</title> or <marquee>..</marquee>.)
234#define STY_Preformatted 0x001
235#define STY_StrikeThru 0x002
236#define STY_Underline 0x004
237#define STY_NoBreak 0x008
238#define STY_Anchor 0x010
239#define STY_DT 0x020
240#define STY_Invisible 0x040
241#define STY_FontMask (STY_StrikeThru|STY_Underline)
245// The first thing done with input HTML text is to parse it into
246// TGHtmlElements. All sizing and layout is done using these elements.
248// Every element contains at least this much information:
250class TGHtmlElement : public TObject {
252 TGHtmlElement(int etype = 0);
254 virtual int IsMarkup() const { return (fType > Html_Block); }
255 virtual const char *MarkupArg(const char * /*tag*/, const char * /*zDefault*/) { return 0; }
256 virtual int GetAlignment(int dflt) { return dflt; }
257 virtual int GetOrderedListType(int dflt) { return dflt; }
258 virtual int GetUnorderedListType(int dflt) { return dflt; }
259 virtual int GetVerticalAlignment(int dflt) { return dflt; }
262 TGHtmlElement *fPNext; // Next input token in a list of them all
263 TGHtmlElement *fPPrev; // Previous token in a list of them all
264 SHtmlStyle_t fStyle; // The rendering style for this token
265 Html_u8_t fType; // The token type.
266 Html_u8_t fFlags; // The HTML_ flags below
267 Html_16_t fCount; // Various uses, depending on "type"
268 int fElId; // Unique identifier
269 int fOffs; // Offset within zText
273// Bitmasks for the "flags" field of the TGHtmlElement
275#define HTML_Visible 0x01 // This element produces "ink"
276#define HTML_NewLine 0x02 // type == Html_Space and ends with newline
277#define HTML_Selected 0x04 // Some or all of this Html_Block is selected
278 // Used by Html_Block elements only.
281// Each text element holds additional information as shown here. Notice that
282// extra space is allocated so that zText[] will be large enough to hold the
283// complete text of the element. X and y coordinates are relative to the
284// virtual canvas. The y coordinate refers to the baseline.
293 virtual ~TGHtmlTextElement();
295 Html_32_t fY; // y coordinate where text should be rendered
296 Html_16_t fX; // x coordinate where text should be rendered
297 Html_16_t fW; // width of this token in pixels
298 Html_u8_t fAscent; // height above the baseline
299 Html_u8_t fDescent; // depth below the baseline
300 Html_u8_t fSpaceWidth; // Width of one space in the current font
301 char *fZText; // Text for this element. Null terminated
305// Each space element is represented like this:
309 Html_16_t fW; // Width of a single space in current font
310 Html_u8_t fAscent; // height above the baseline
311 Html_u8_t fDescent; // depth below the baseline
317// Most markup uses this class. Some markup extends this class with
318// additional information, but most use it as is, at the very least.
320// If the markup doesn't have arguments (the "count" field of
321// TGHtmlElement is 0) then the extra "argv" field of this class
322// is not allocated and should not be used.
326 TGHtmlMarkupElement(int type, int argc, int arglen[], char *argv[]);
327 virtual ~TGHtmlMarkupElement();
329 virtual const char *MarkupArg(const char *tag, const char *zDefault);
330 virtual int GetAlignment(int dflt);
331 virtual int GetOrderedListType(int dflt);
332 virtual int GetUnorderedListType(int dflt);
333 virtual int GetVerticalAlignment(int dflt);
336 char **fArgv;
340// The maximum number of columns allowed in a table. Any columns beyond
341// this number are ignored.
343#define HTML_MAX_COLUMNS 40
346// This class is used for each <table> element.
348// In the minW[] and maxW[] arrays, the [0] element is the overall
349// minimum and maximum width, including cell padding, spacing and
350// the "hspace". All other elements are the minimum and maximum
351// width for the contents of individual cells without any spacing or
352// padding.
356 TGHtmlTable(int type, int argc, int arglen[], char *argv[]);
357 ~TGHtmlTable();
360 Html_u8_t fBorderWidth; // Width of the border
361 Html_u8_t fNCol; // Number of columns
362 Html_u16_t fNRow; // Number of rows
363 Html_32_t fY; // top edge of table border
364 Html_32_t fH; // height of the table border
365 Html_16_t fX; // left edge of table border
366 Html_16_t fW; // width of the table border
367 int fMinW[HTML_MAX_COLUMNS+1]; // minimum width of each column
368 int fMaxW[HTML_MAX_COLUMNS+1]; // maximum width of each column
369 TGHtmlElement *fPEnd; // Pointer to the end tag element
370 TImage *fBgImage; // A background for the entire table
371 int fHasbg; // 1 if a table above has bgImage
375// Each <td> or <th> markup is represented by an instance of the
376// following class.
378// Drawing for a cell is a sunken 3D border with the border width given
379// by the borderWidth field in the associated <table> object.
383 TGHtmlCell(int type, int argc, int arglen[], char *argv[]);
384 ~TGHtmlCell();
387 Html_16_t fRowspan; // Number of rows spanned by this cell
388 Html_16_t fColspan; // Number of columns spanned by this cell
389 Html_16_t fX; // X coordinate of left edge of border
390 Html_16_t fW; // Width of the border
391 Html_32_t fY; // Y coordinate of top of border indentation
392 Html_32_t fH; // Height of the border
393 TGHtmlTable *fPTable; // Pointer back to the <table>
394 TGHtmlElement *fPRow; // Pointer back to the <tr>
395 TGHtmlElement *fPEnd; // Element that ends this cell
396 TImage *fBgImage; // Background for the cell
400// This class is used for </table>, </td>, <tr>, </tr> and </th> elements.
401// It points back to the <table> element that began the table. It is also
402// used by </a> to point back to the original <a>. I'll probably think of
403// other uses before all is said and done...
407 TGHtmlRef(int type, int argc, int arglen[], char *argv[]);
408 ~TGHtmlRef();
411 TGHtmlElement *fPOther; // Pointer to some other Html element
412 TImage *fBgImage; // A background for the entire row
416// An instance of the following class is used to represent
417// each <LI> markup.
421 TGHtmlLi(int type, int argc, int arglen[], char *argv[]);
424 Html_u8_t fLtype; // What type of list is this?
425 Html_u8_t fAscent; // height above the baseline
426 Html_u8_t fDescent; // depth below the baseline
427 Html_16_t fCnt; // Value for this element (if inside <OL>)
428 Html_16_t fX; // X coordinate of the bullet
429 Html_32_t fY; // Y coordinate of the bullet
433// The ltype field of an TGHtmlLi or TGHtmlListStart object can take on
434// any of the following values to indicate what type of bullet to draw.
435// The value in TGHtmlLi will take precedence over the value in
436// TGHtmlListStart if the two values differ.
438#define LI_TYPE_Undefined 0 // If in TGHtmlLi, use the TGHtmlListStart value
439#define LI_TYPE_Bullet1 1 // A solid circle
440#define LI_TYPE_Bullet2 2 // A hollow circle
441#define LI_TYPE_Bullet3 3 // A hollow square
442#define LI_TYPE_Enum_1 4 // Arabic numbers
443#define LI_TYPE_Enum_A 5 // A, B, C, ...
444#define LI_TYPE_Enum_a 6 // a, b, c, ...
445#define LI_TYPE_Enum_I 7 // Capitalized roman numerals
446#define LI_TYPE_Enum_i 8 // Lower-case roman numerals
449// An instance of this class is used for <UL> or <OL> markup.
453 TGHtmlListStart(int type, int argc, int arglen[], char *argv[]);
456 Html_u8_t fLtype; // One of the LI_TYPE_ defines above
457 Html_u8_t fCompact; // True if the COMPACT flag is present
458 Html_u16_t fCnt; // Next value for <OL>
459 Html_u16_t fWidth; // How much space to allow for indentation
460 TGHtmlListStart *fLPrev; // Next higher level list, or NULL
464#define HTML_MAP_RECT 1
465#define HTML_MAP_CIRCLE 2
466#define HTML_MAP_POLY 3
470 TGHtmlMapArea(int type, int argc, int arglen[], char *argv[]);
475 int fNum;
481// Structure to chain extension data onto.
484 void *fExts;
485 int fTyp;
493// Information about each image on the HTML widget is held in an instance
494// of the following class. All images are held on a list attached to the
495// main widget object.
497// This class is NOT an element. The <IMG> element is represented by an
498// TGHtmlImageMarkup object below. There is one TGHtmlImageMarkup for each
499// <IMG> in the source HTML. There is one of these objects for each unique
500// image loaded. (If two <IMG> specify the same image, there are still two
501// TGHtmlImageMarkup objects but only one TGHtmlImage object that is shared
502// between them.)
504class TGHtml;
507class TGHtmlImage : public TObject {
509 TGHtmlImage(const TGHtmlImage&) = delete;
513 TGHtmlImage(TGHtml *htm, const char *url, const char *width,
514 const char *height);
515 virtual ~TGHtmlImage();
518 TGHtml *fHtml; // The owner of this image
519 TImage *fImage; // The image token
520 Html_32_t fW; // Requested width of this image (0 if none)
521 Html_32_t fH; // Requested height of this image (0 if none)
522 char *fZUrl; // The URL for this image.
523 char *fZWidth, *fZHeight; // Width and height in the <img> markup.
524 TGHtmlImage *fPNext; // Next image on the list
525 TGHtmlImageMarkup *fPList; // List of all <IMG> markups that use this
526 // same image
527 TTimer *fTimer; // for animations
530// Each <img> markup is represented by an instance of the following
531// class.
533// If pImage == 0, then we use the alternative text in zAlt.
537 TGHtmlImageMarkup(int type, int argc, int arglen[], char *argv[]);
540 Html_u8_t fAlign; // Alignment. See IMAGE_ALIGN_ defines below
541 Html_u8_t fTextAscent; // Ascent of text font in force at the <IMG>
542 Html_u8_t fTextDescent; // Descent of text font in force at the <IMG>
543 Html_u8_t fRedrawNeeded; // Need to redraw this image because the image
544 // content changed.
545 Html_16_t fH; // Actual height of the image
546 Html_16_t fW; // Actual width of the image
547 Html_16_t fAscent; // How far image extends above "y"
548 Html_16_t fDescent; // How far image extends below "y"
549 Html_16_t fX; // X coordinate of left edge of the image
550 Html_32_t fY; // Y coordinate of image baseline
551 const char *fZAlt; // Alternative text
552 TGHtmlImage *fPImage; // Corresponding TGHtmlImage object
554 TGHtmlImageMarkup *fINext; // Next markup using the same TGHtmlImage object
558// Allowed alignments for images. These represent the allowed arguments
559// to the "align=" field of the <IMG> markup.
561#define IMAGE_ALIGN_Bottom 0
562#define IMAGE_ALIGN_Middle 1
563#define IMAGE_ALIGN_Top 2
564#define IMAGE_ALIGN_TextTop 3
565#define IMAGE_ALIGN_AbsMiddle 4
566#define IMAGE_ALIGN_AbsBottom 5
567#define IMAGE_ALIGN_Left 6
568#define IMAGE_ALIGN_Right 7
571// All kinds of form markup, including <INPUT>, <TEXTAREA> and <SELECT>
572// are represented by instances of the following class.
574// (later...) We also use this for the <APPLET> markup. That way,
575// the window we create for an <APPLET> responds to the TGHtml::MapControls()
576// and TGHtml::UnmapControls() function calls. For an <APPLET>, the
577// pForm field is NULL. (Later still...) <EMBED> works just like
578// <APPLET> so it uses this class too.
580class TGHtmlForm;
584 TGHtmlInput(int type, int argc, int arglen[], char *argv[]);
586 void Empty();
589 TGHtmlForm *fPForm; // The <FORM> to which this belongs
590 TGHtmlInput *fINext; // Next element in a list of all input elements
591 TGFrame *fFrame; // The xclass window that implements this control
592 TGHtml *fHtml; // The HTML widget this control is attached to
593 TGHtmlElement *fPEnd; // End tag for <TEXTAREA>, etc.
594 Html_u16_t fInpId; // Unique id for this element
595 Html_u16_t fSubId; // For radio - an id, for select - option count
596 Html_32_t fY; // Baseline for this input element
597 Html_u16_t fX; // Left edge
598 Html_u16_t fW, fH; // Width and height of this control
599 Html_u8_t fPadLeft; // Extra padding on left side of the control
600 Html_u8_t fAlign; // One of the IMAGE_ALIGN_xxx types
601 Html_u8_t fTextAscent; // Ascent for the current font
602 Html_u8_t fTextDescent; // descent for the current font
603 Html_u8_t fItype; // What type of input is this?
604 Html_u8_t fSized; // True if this input has been sized already
605 Html_u16_t fCnt; // Used to derive widget name. 0 if no widget
609// An input control can be one of the following types. See the
610// comment about <APPLET> on the TGHtmlInput class insight into
611// INPUT_TYPE_Applet.
613#define INPUT_TYPE_Unknown 0
614#define INPUT_TYPE_Checkbox 1
615#define INPUT_TYPE_File 2
616#define INPUT_TYPE_Hidden 3
617#define INPUT_TYPE_Image 4
618#define INPUT_TYPE_Password 5
619#define INPUT_TYPE_Radio 6
620#define INPUT_TYPE_Reset 7
621#define INPUT_TYPE_Select 8
622#define INPUT_TYPE_Submit 9
623#define INPUT_TYPE_Text 10
624#define INPUT_TYPE_TextArea 11
625#define INPUT_TYPE_Applet 12
626#define INPUT_TYPE_Button 13
629// There can be multiple <FORM> entries on a single HTML page.
630// Each one must be given a unique number for identification purposes,
631// and so we can generate unique state variable names for radiobuttons,
632// checkbuttons, and entry boxes.
636 TGHtmlForm(int type, int argc, int arglen[], char *argv[]);
639 Html_u16_t fFormId; // Unique number assigned to this form
640 unsigned int fElements; // Number of elements
641 unsigned int fHasctl; // Has controls
642 TGHtmlElement *fPFirst; // First form element
643 TGHtmlElement *fPEnd; // Pointer to end tag element
647// Information used by a <HR> markup
651 TGHtmlHr(int type, int argc, int arglen[], char *argv[]);
654 Html_32_t fY; // Baseline for this input element
655 Html_u16_t fX; // Left edge
656 Html_u16_t fW, fH; // Width and height of this control
657 Html_u8_t fIs3D; // Is it drawn 3D?
661// Information used by a <A> markup
665 TGHtmlAnchor(int type, int argc, int arglen[], char *argv[]);
668 Html_32_t fY; // Top edge for this element
672// Information about the <SCRIPT> markup. The parser treats <SCRIPT>
673// specially. All text between <SCRIPT> and </SCRIPT> is captured and
674// is indexed to by the nStart field of this class.
676// The nStart field indexs to a spot in the zText field of the TGHtml object.
677// The nScript field determines how long the script is.
681 TGHtmlScript(int type, int argc, int arglen[], char *argv[]);
684 int fNStart; // Start of the script (index into TGHtml::zText)
685 int fNScript; // Number of characters of text in zText holding
686 // the complete text of this script
690// A block is a single unit of display information. This can be one or more
691// text elements, or the border of table, or an image, etc.
693// Blocks are used to improve display speed and to improve the speed of
694// linear searchs through the token list. A single block will typically
695// contain enough information to display a dozen or more Text and Space
696// elements all with a single call to OXFont::DrawChars(). The blocks are
697// linked together on their own list, so we can search them much faster than
698// elements (since there are fewer of them.)
700// Of course, you can construct pathological HTML that has as many Blocks as
701// it has normal tokens. But you haven't lost anything. Using blocks just
702// speeds things up in the common case.
704// Much of the information needed for display is held in the original
705// TGHtmlElement objects. "fPNext" points to the first object in the list
706// which can be used to find the "style" "x" and "y".
708// If n is zero, then "fPNext" might point to a special TGHtmlElement
709// that defines some other kind of drawing, like <LI> or <IMG> or <INPUT>.
713 TGHtmlBlock();
714 virtual ~TGHtmlBlock();
717 char *fZ; // Space to hold text when n > 0
718 int fTop, fBottom; // Extremes of y coordinates
719 Html_u16_t fLeft, fRight; // Left and right boundry of this object
720 Html_u16_t fN; // Number of characters in z[]
721 TGHtmlBlock *fBPrev, *fBNext; // Linked list of all Blocks
725// A stack of these structures is used to keep track of nested font and
726// style changes. This allows us to easily revert to the previous style
727// when we encounter and end-tag like </em> or </h3>.
729// This stack is used to keep track of the current style while walking
730// the list of elements. After all elements have been assigned a style,
731// the information in this stack is no longer used.
734 SHtmlStyleStack_t *fPNext; // Next style on the stack
735 int fType; // A markup that ends this style. Ex: Html_EndEM
736 SHtmlStyle_t fStyle; // The currently active style.
740// A stack of the following structures is used to remember the
741// left and right margins within a layout context.
744 int fIndent; // Size of the current margin
745 int fBottom; // Y value at which this margin expires
746 int fTag; // Markup that will cancel this margin
747 SHtmlMargin_t *fPNext; // Previous margin
751// How much space (in pixels) used for a single level of indentation due
752// to a <UL> or <DL> or <BLOCKQUOTE>, etc.
754#define HTML_INDENT 36
759// A layout context holds all state information used by the layout engine.
765 void LayoutBlock();
766 void Reset();
768 void PopIndent();
769 void PushIndent();
772 void PushMargin(SHtmlMargin_t **ppMargin, int indent, int bottom, int tag);
773 void PopOneMargin(SHtmlMargin_t **ppMargin);
774 void PopMargin(SHtmlMargin_t **ppMargin, int tag);
775 void PopExpiredMargins(SHtmlMargin_t **ppMarginStack, int y);
776 void ClearMarginStack(SHtmlMargin_t **ppMargin);
779 int width, int minX, int *actualWidth);
781 void FixAnchors(TGHtmlElement *p, TGHtmlElement *pEnd, int y);
782 int FixLine(TGHtmlElement *pStart, TGHtmlElement *pEnd,
783 int bottom, int width, int actualWidth, int leftMargin,
784 int *maxX);
786 void ComputeMargins(int *pX, int *pY, int *pW);
787 void ClearObstacle(int mode);
789 int InWrapAround();
790 void WidenLine(int reqWidth, int *pX, int *pY, int *pW);
795 TGHtml *fHtml; // The html widget undergoing layout
796 TGHtmlElement *fPStart; // Start of elements to layout
797 TGHtmlElement *fPEnd; // Stop when reaching this element
798 int fHeadRoom; // Extra space wanted above this line
799 int fTop; // Absolute top of drawing area
800 int fBottom; // Bottom of previous line
801 int fLeft, fRight; // Left and right extremes of drawing area
802 int fPageWidth; // Width of the layout field, including
803 // the margins
804 int fMaxX, fMaxY; // Maximum X and Y values of paint
805 SHtmlMargin_t *fLeftMargin; // Stack of left margins
806 SHtmlMargin_t *fRightMargin; // Stack of right margins
810// With 28 different fonts and 16 colors, we could in principle have
811// as many as 448 different GCs. But in practice, a single page of
812// HTML will typically have much less than this. So we won't try to
813// keep all GCs on hand. Instead, we'll keep around the most recently
814// used GCs and allocate new ones as necessary.
816// The following structure is used to build a cache of GCs in the
817// main widget object.
819#define N_CACHE_GC 32
821struct GcCache_t {
822 GContext_t fGc; // The graphics context
823 Html_u8_t fFont; // Font used for this context
824 Html_u8_t fColor; // Color used for this context
825 Html_u8_t fIndex; // Index used for LRU replacement
829// An SHtmlIndex_t is a reference to a particular character within a
830// particular Text or Space token.
833 TGHtmlElement *fP; // The token containing the character
834 int fI; // Index of the character
838// Used by the tokenizer
841 const char *fZName; // Name of a markup
842 Html_16_t fType; // Markup type code
843 Html_16_t fObjType; // Which kind of TGHtml... object to alocate
844 SHtmlTokenMap_t *fPCollide; // Hash table collision chain
848// Markup element types to be allocated by the tokenizer.
849// Do not confuse with .type field in TGHtmlElement
851#define O_HtmlMarkupElement 0
852#define O_HtmlCell 1
853#define O_HtmlTable 2
854#define O_HtmlRef 3
855#define O_HtmlLi 4
856#define O_HtmlListStart 5
857#define O_HtmlImageMarkup 6
858#define O_HtmlInput 7
859#define O_HtmlForm 8
860#define O_HtmlHr 9
861#define O_HtmlAnchor 10
862#define O_HtmlScript 11
863#define O_HtmlMapArea 12
868// The HTML widget. A derivate of TGView.
870class TGListBox;
871class THashTable;
873class TGHtml : public TGView {
875 TGHtml(const TGWindow *p, int w, int h, int id = -1);
876 virtual ~TGHtml();
883 virtual Bool_t HandleTimer(TTimer *timer);
887 virtual void DrawRegion(Int_t x, Int_t y, UInt_t w, UInt_t h);
888 virtual Bool_t ItemLayout();
893public: // user commands
895 int ParseText(char *text, const char *index = 0);
897 void SetTableRelief(int relief);
898 int GetTableRelief() const { return fTableRelief; }
900 void SetRuleRelief(int relief);
901 int GetRuleRelief() const { return fRuleRelief; }
902 int GetRulePadding() const { return fRulePadding; }
904 void UnderlineLinks(int onoff);
906 void SetBaseUri(const char *uri);
907 const char *GetBaseUri() const { return fZBase; }
909 int GotoAnchor(const char *name);
911public: // reloadable methods
913 // called when the widget is cleared
914 virtual void Clear(Option_t * = "");
916 // User function to resolve URIs
917 virtual char *ResolveUri(const char *uri);
919 // User function to get an image from a URL
920 virtual TImage *LoadImage(const char *uri, int w = 0, int h = 0) ;//
921 // { return 0; }
923 // User function to tell if a hyperlink has already been visited
924 virtual int IsVisited(const char * /*url*/)
925 { return kFALSE; }
927 // User function to process tokens of the given type
928 virtual int ProcessToken(TGHtmlElement * /*pElem*/, const char * /*name*/, int /*type*/)
929 { return kFALSE; }
931 virtual TGFont *GetFont(int iFont);
933 // The HTML parser will invoke the following methods from time
934 // to time to find out information it needs to complete formatting of
935 // the document.
937 // Method for handling <frameset> markup
938 virtual int ProcessFrame()
939 { return kFALSE; }
941 // Method to process applets
942 virtual TGFrame *ProcessApplet(TGHtmlInput * /*input*/)
943 { return 0; }
945 // Called when parsing forms
946 virtual int FormCreate(TGHtmlForm * /*form*/, const char * /*zUrl*/, const char * /*args*/)
947 { return kFALSE; }
949 // Called when user presses Submit
950 virtual int FormAction(TGHtmlForm * /*form*/, int /*id*/)
951 { return kFALSE; }
953 // Invoked to find font names
954 virtual char *GetFontName()
955 { return 0; }
957 // Invoked for each <SCRIPT> markup
958 virtual char *ProcessScript(TGHtmlScript * /*script*/)
959 { return 0; }
962 const char *GetText() const { return fZText; }
964 void HandleMenu(Int_t);
965 void SaveFileAs();
970 TGHtmlInput *GetInputElement(int x, int y);
971 const char *GetHref(int x, int y, const char **target = 0);
975 int InArea(TGHtmlMapArea *p, int left, int top, int x, int y);
976 TGHtmlElement *GetMap(const char *name);
979 int ElementCoords(TGHtmlElement *p, int i, int pct, int *coords);
981 TGHtmlElement *TableDimensions(TGHtmlTable *pStart, int lineWidth);
982 int CellSpacing(TGHtmlElement *pTable);
983 void MoveVertically(TGHtmlElement *p, TGHtmlElement *pLast, int dy);
988 char *DumpToken(TGHtmlElement *p);
990 void EncodeText(TGString *str, const char *z);
993 void HClear();
994 void ClearGcCache();
995 void ResetLayoutContext();
996 void Redraw();
997 void ComputeVirtualSize();
999 void ScheduleRedraw();
1001 void RedrawArea(int left, int top, int right, int bottom);
1002 void RedrawBlock(TGHtmlBlock *p);
1003 void RedrawEverything();
1004 void RedrawText(int y);
1009 int GetColorByName(const char *zColor);
1010 int GetDarkShadowColor(int iBgColor);
1011 int GetLightShadowColor(int iBgColor);
1012 int GetColorByValue(ColorStruct_t *pRef);
1014 void FlashCursor();
1016 GContext_t GetGC(int color, int font);
1019 void AnimateImage(TGHtmlImage *image);
1020 void ImageChanged(TGHtmlImage *image, int newWidth, int newHeight);
1022 int GetImageAt(int x, int y);
1023 const char *GetPctWidth(TGHtmlElement *p, char *opt, char *ret);
1027 void UnlinkAndFreeBlock(TGHtmlBlock *pBlock);
1028 void AppendBlock(TGHtmlElement *pToken, TGHtmlBlock *pBlock);
1030 void StringHW(const char *str, int *h, int *w);
1031 TGHtmlElement *MinMax(TGHtmlElement *p, int *pMin, int *pMax,
1032 int lineWidth, int hasbg);
1035 int x, int y);
1036 void DrawRect(Drawable_t drawable, TGHtmlElement *src,
1037 int x, int y, int w, int h, int depth, int relief);
1038 void BlockDraw(TGHtmlBlock *pBlock, Drawable_t wid,
1039 int left, int top,
1040 int width, int height, Pixmap_t pixmap);
1042 int left, int top,
1043 int right, int bottom);
1044 void DrawTableBgnd(int x, int y, int w, int h, Drawable_t d, TImage *image);
1047 void FormBlocks();
1049 void AppendElement(TGHtmlElement *pElem);
1050 int Tokenize();
1051 void AppToken(TGHtmlElement *pNew, TGHtmlElement *p, int offs);
1052 TGHtmlMarkupElement *MakeMarkupEntry(int objType, int type, int argc,
1053 int arglen[], char *argv[]);
1054 void TokenizerAppend(const char *text);
1056 char *zType, char *zArgs, int offs);
1057 SHtmlTokenMap_t *NameToPmap(char *zType);
1058 int NameToType(char *zType);
1059 const char *TypeToName(int type);
1060 int TextInsertCmd(int argc, char **argv);
1063 TGHtmlElement *TokenByIndex(int N, int flag);
1066 void MaxIndex(TGHtmlElement *p, int *pIndex, int isLast);
1067 int IndexMod(TGHtmlElement **pp, int *ip, char *cp);
1068 void FindIndexInBlock(TGHtmlBlock *pBlock, int x,
1069 TGHtmlElement **ppToken, int *pIndex);
1070 void IndexToBlockIndex(SHtmlIndex_t sIndex,
1071 TGHtmlBlock **ppBlock, int *piIndex);
1072 int DecodeBaseIndex(const char *zBase,
1073 TGHtmlElement **ppToken, int *pIndex);
1074 int GetIndex(const char *zIndex, TGHtmlElement **ppToken, int *pIndex);
1076 void LayoutDoc();
1078 int MapControls();
1079 void UnmapControls();
1080 void DeleteControls();
1082 void SizeAndLink(TGFrame *frame, TGHtmlInput *pElem);
1083 int FormCount(TGHtmlInput *p, int radio);
1086 void AppendText(TGString *str, TGHtmlElement *pFirst, TGHtmlElement *pEnd);
1088 void UpdateSelection(int forceUpdate);
1090 void LostSelection();
1091 int SelectionSet(const char *startIx, const char *endIx);
1092 void UpdateInsert();
1093 int SetInsert(const char *insIx);
1095 const char *GetUid(const char *string);
1096 ColorStruct_t *AllocColor(const char *name);
1098 void FreeColor(ColorStruct_t *color);
1101 void PushStyleStack(int tag, SHtmlStyle_t style);
1102 SHtmlStyle_t PopStyleStack(int tag);
1104 void MakeInvisible(TGHtmlElement *p_first, TGHtmlElement *p_last);
1105 int GetLinkColor(const char *zURL);
1106 void AddStyle(TGHtmlElement *p);
1107 void Sizer();
1111 TGHtmlElement *AttrElem(const char *name, char *value);
1114 void AppendArglist(TGString *str, TGHtmlMarkupElement *pElem);
1117 TGString *TableText(TGHtmlTable *pTable, int flags);
1119 virtual void MouseOver(const char *uri) { Emit("MouseOver(const char *)",uri); } // *SIGNAL*
1120 virtual void MouseDown(const char *uri) { Emit("MouseDown(const char *)",uri); } // *SIGNAL*
1121 virtual void ButtonClicked(const char *name, const char *val); // *SIGNAL*
1122 virtual void SubmitClicked(const char *val); // *SIGNAL*
1123 virtual void CheckToggled(const char *name, Bool_t on, const char *val); // *SIGNAL*
1124 virtual void RadioChanged(const char *name, const char *val); // *SIGNAL*
1125 virtual void InputSelected(const char *name, const char *val); //*SIGNAL*
1126 virtual void SavePrimitive(std::ostream &out, Option_t * = "");
1129 virtual void UpdateBackgroundStart();
1132 enum {
1136 TGHtmlElement *fPFirst; // First HTML token on a list of them all
1137 TGHtmlElement *fPLast; // Last HTML token on the list
1138 int fNToken; // Number of HTML tokens on the list.
1139 // Html_Block tokens don't count.
1140 TGHtmlElement *fLastSized; // Last HTML element that has been sized
1141 TGHtmlElement *fNextPlaced; // Next HTML element that needs to be
1142 // positioned on canvas.
1143 TGHtmlBlock *fFirstBlock; // List of all TGHtmlBlock tokens
1144 TGHtmlBlock *fLastBlock; // Last TGHtmlBlock in the list
1145 TGHtmlInput *fFirstInput; // First <INPUT> element
1146 TGHtmlInput *fLastInput; // Last <INPUT> element
1147 int fNInput; // The number of <INPUT> elements
1148 int fNForm; // The number of <FORM> elements
1149 int fVarId; // Used to construct a unique name for a
1150 // global array used by <INPUT> elements
1151 int fInputIdx; // Unique input index
1152 int fRadioIdx; // Unique radio index
1154 // Information about the selected region of text
1156 SHtmlIndex_t fSelBegin; // Start of the selection
1157 SHtmlIndex_t fSelEnd; // End of the selection
1158 TGHtmlBlock *fPSelStartBlock; // Block in which selection starts
1159 Html_16_t fSelStartIndex; // Index in pSelStartBlock of first selected
1160 // character
1161 Html_16_t fSelEndIndex; // Index of last selecte char in pSelEndBlock
1162 TGHtmlBlock *fPSelEndBlock; // Block in which selection ends
1164 // Information about the insertion cursor
1166 int fInsOnTime; // How long the cursor states one (millisec)
1167 int fInsOffTime; // How long it is off (milliseconds)
1168 int fInsStatus; // Is it visible?
1169 TTimer *fInsTimer; // Timer used to flash the insertion cursor
1170 SHtmlIndex_t fIns; // The insertion cursor position
1171 TGHtmlBlock *fPInsBlock; // The TGHtmlBlock containing the cursor
1172 int fInsIndex; // Index in pInsBlock of the cursor
1174 // The following fields hold state information used by the tokenizer.
1176 char *fZText; // Complete text of the unparsed HTML
1177 int fNText; // Number of characters in zText
1178 int fNAlloc; // Space allocated for zText
1179 int fNComplete; // How much of zText has actually been
1180 // converted into tokens
1181 int fICol; // The column in which zText[nComplete]
1182 // occurs. Used to resolve tabs in input
1183 int fIPlaintext; // If not zero, this is the token type that
1184 // caused us to go into plaintext mode. One
1185 // of Html_PLAINTEXT, Html_LISTING or
1186 // Html_XMP
1187 TGHtmlScript *fPScript; // <SCRIPT> currently being parsed
1190 TGPopupMenu *fMenu; // popup menu with user actions
1192 // These fields hold state information used by the HtmlAddStyle routine.
1193 // We have to store this state information here since HtmlAddStyle
1194 // operates incrementally. This information must be carried from
1195 // one incremental execution to the next.
1197 SHtmlStyleStack_t *fStyleStack; // The style stack
1198 int fParaAlignment; // Justification associated with <p>
1199 int fRowAlignment; // Justification associated with <tr>
1200 int fAnchorFlags; // Style flags associated with <A>...</A>
1201 int fInDt; // Style flags associated with <DT>...</DT>
1202 int fInTr; // True if within <tr>..</tr>
1203 int fInTd; // True if within <td>..</td> or <th>..</th>
1204 TGHtmlAnchor *fAnchorStart; // Most recent <a href=...>
1205 TGHtmlForm *fFormStart; // Most recent <form>
1206 TGHtmlInput *fFormElemStart; // Most recent <textarea> or <select>
1207 TGHtmlInput *fFormElemLast; // Most recent <input>, <textarea> or <select>
1208 TGHtmlListStart *fInnerList; // The inner most <OL> or <UL>
1209 TGHtmlElement *fLoEndPtr; // How far AddStyle has gone to
1210 TGHtmlForm *fLoFormStart; // For AddStyle
1212 // These fields are used to hold the state of the layout engine.
1213 // Because the layout is incremental, this state must be held for
1214 // the life of the widget.
1218 // Information used when displaying the widget:
1220 int fHighlightWidth; // Width in pixels of highlight to draw
1221 // around widget when it has the focus.
1222 // <= 0 means don't draw a highlight.
1223 TGInsets fMargins; // document margins (separation between the
1224 // edge of the clip window and rendered HTML).
1225 ColorStruct_t *fHighlightBgColorPtr; // Color for drawing traversal highlight
1226 // area when highlight is off.
1227 ColorStruct_t *fHighlightColorPtr; // Color for drawing traversal highlight.
1228 TGFont *fAFont[N_FONT]; // Information about all screen fonts
1229 char fFontValid[(N_FONT+7)/8]; // If bit N%8 of work N/8 of this field is 0
1230 // if aFont[N] needs to be reallocated before
1231 // being used.
1232 ColorStruct_t *fApColor[N_COLOR]; // Information about all colors
1233 Long_t fColorUsed; // bit N is 1 if color N is in use. Only
1234 // applies to colors that aren't predefined
1235 int fIDark[N_COLOR]; // Dark 3D shadow of color K is iDark[K]
1236 int fILight[N_COLOR]; // Light 3D shadow of color K is iLight[K]
1237 ColorStruct_t *fBgColor; // Background color of the HTML document
1238 ColorStruct_t *fFgColor; // Color of normal text. apColor[0]
1239 ColorStruct_t *fNewLinkColor; // Color of unvisitied links. apColor[1]
1240 ColorStruct_t *fOldLinkColor; // Color of visitied links. apColor[2]
1241 ColorStruct_t *fSelectionColor; // Background color for selections
1242 GcCache_t fAGcCache[N_CACHE_GC]; // A cache of GCs for general use
1244 int fLastGC; // Index of recently used GC
1245 TGHtmlImage *fImageList; // A list of all images
1246 TImage *fBgImage; // Background image
1248 int fFormPadding; // Amount to pad form elements by
1249 int fOverrideFonts; // TRUE if we should override fonts
1250 int fOverrideColors; // TRUE if we should override colors
1251 int fUnderlineLinks; // TRUE if we should underline hyperlinks
1252 int fHasScript; // TRUE if we can do scripts for this page
1253 int fHasFrames; // TRUE if we can do frames for this page
1254 int fAddEndTags; // TRUE if we add /LI etc.
1255 int fTableBorderMin; // Force tables to have min border size
1256 int fVarind; // Index suffix for unique global var name
1258 // Information about the selection
1260 int fExportSelection; // True if the selection is automatically
1261 // exported to the clipboard
1263 // Miscellaneous information:
1265 int fTableRelief; // 3d effects on <TABLE>
1266 int fRuleRelief; // 3d effects on <HR>
1267 int fRulePadding; // extra pixels above and below <HR>
1268 const char *fZBase; // The base URI
1269 char *fZBaseHref; // zBase as modified by <BASE HREF=..> markup
1270 Cursor_t fCursor; // Current cursor for window, or None.
1271 int fMaxX, fMaxY; // Maximum extent of any "paint" that appears
1272 // on the virtual canvas. Used to compute
1273 // scrollbar positions.
1274 int fDirtyLeft, fDirtyTop; // Top left corner of region to redraw. These
1275 // are physical screen coordinates relative to
1276 // the clip win, not main window.
1277 int fDirtyRight, fDirtyBottom; // Bottom right corner of region to redraw
1278 int fFlags; // Various flags; see below for definitions.
1280 int fInParse; // Prevent update if parsing
1281 char *fZGoto; // Label to goto right after layout
1283 SHtmlExtensions_t *fExts; // Pointer to user extension data
1285 THashTable *fUidTable; // Hash table for some used string values
1286 // like color names, etc.
1287 const char *fLastUri; // Used in HandleMotion
1288 int fExiting; // True if the widget is being destroyed
1290 ClassDef(TGHtml, 0); // HTML widget
1294// Flag bits "flags" field of the Html widget:
1296// REDRAW_PENDING An idle handler has already been queued to
1297// call the TGHtml::Redraw() method.
1299// GOT_FOCUS This widget currently has input focus.
1301// HSCROLL Horizontal scrollbar position needs to be
1302// recomputed.
1304// VSCROLL Vertical scrollbar position needs to be
1305// recomputed.
1307// RELAYOUT We need to reposition every element on the
1308// virtual canvas. (This happens, for example,
1309// when the size of the widget changes and we
1310// need to recompute the line breaks.)
1312// RESIZE_ELEMENTS We need to recompute the size of every element.
1313// This happens, for example, when the fonts
1314// change.
1316// REDRAW_FOCUS We need to repaint the focus highlight border.
1318// REDRAW_TEXT Everything in the clipping window needs to be redrawn.
1320// STYLER_RUNNING There is a call to HtmlAddStyle() in process.
1321// Used to prevent a recursive call to HtmlAddStyle().
1323// INSERT_FLASHING True if there is a timer scheduled that will toggle
1324// the state of the insertion cursor.
1326// REDRAW_IMAGES One or more TGHtmlImageMarkup objects have their
1327// redrawNeeded flag set.
1329#define REDRAW_PENDING 0x000001
1330#define GOT_FOCUS 0x000002
1331#define HSCROLL 0x000004
1332#define VSCROLL 0x000008
1333#define RELAYOUT 0x000010
1334#define RESIZE_ELEMENTS 0x000020
1335#define REDRAW_FOCUS 0x000040
1336#define REDRAW_TEXT 0x000080
1337#define EXTEND_LAYOUT 0x000100
1338#define STYLER_RUNNING 0x000200
1339#define INSERT_FLASHING 0x000400
1340#define REDRAW_IMAGES 0x000800
1341#define ANIMATE_IMAGES 0x001000
1344// Macros to set, clear or test bits of the "flags" field.
1346#define HtmlHasFlag(A,F) (((A)->flags&(F))==(F))
1347#define HtmlHasAnyFlag(A,F) (((A)->flags&(F))!=0)
1348#define HtmlSetFlag(A,F) ((A)->flags|=(F))
1349#define HtmlClearFlag(A,F) ((A)->flags&=~(F))
1352// No coordinate is ever as big as this number
1354#define LARGE_NUMBER 100000000
1357// Default values for configuration options
1361#define DEF_HTML_EXPORT_SEL 1
1366#define DEF_HTML_INSERT_OFF_TIME 300
1367#define DEF_HTML_INSERT_ON_TIME 600
1368#define DEF_HTML_PADX (HTML_INDENT / 4)
1369#define DEF_HTML_PADY (HTML_INDENT / 4)
1370#define DEF_HTML_RELIEF "raised"
1371#define DEF_HTML_SELECTION_COLOR "skyblue"
1372#define DEF_HTML_TAKE_FOCUS "0"
1373#define DEF_HTML_UNVISITED "blue2"
1374#define DEF_HTML_VISITED "purple4"
1378#define DEF_HTML_TABLE_BORDER "0"
1384#endif // NAVIGATOR_TABLES
1389// Messages generated by the HTML widget
1391class TGHtmlMessage : public OWidgetMessage {
1393 TGHtmlMessage(int t, int a, int i, const char *u, int rx, int ry) :
1394 OWidgetMessage(t, a, i) {
1395 uri = u;
1396 x_root = rx;
1397 y_root = ry;
1398 }
1401 const char *uri;
1402 //ORectangle bbox;
1403 int x_root, y_root;
1407#endif // ROOT_TGHtml
Handle_t Pixmap_t
Pixmap handle.
Definition: GuiTypes.h:30
Handle_t GContext_t
Graphics context handle.
Definition: GuiTypes.h:38
Handle_t Drawable_t
Drawable handle.
Definition: GuiTypes.h:31
Handle_t Cursor_t
Cursor handle.
Definition: GuiTypes.h:34
#define d(i)
Definition: RSha256.hxx:102
#define h(i)
Definition: RSha256.hxx:106
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
bool Bool_t
Definition: RtypesCore.h:63
int Int_t
Definition: RtypesCore.h:45
long Longptr_t
Definition: RtypesCore.h:82
const Bool_t kFALSE
Definition: RtypesCore.h:101
long Long_t
Definition: RtypesCore.h:54
const char Option_t
Definition: RtypesCore.h:66
static void indent(ostringstream &buf, int indent_level)
#define N
@ Html_Block
Definition: TGHtmlTokens.h:45
@ Html_Space
Definition: TGHtmlTokens.h:43
int HtmlDepth
Definition: TGHtml.cxx:67
int HtmlTraceMask
Definition: TGHtml.cxx:66
unsigned char Html_u8_t
Definition: TGHtml.h:136
Definition: TGHtml.h:343
int Html_32_t
Definition: TGHtml.h:139
short Html_16_t
Definition: TGHtml.h:137
#define N_CACHE_GC
Definition: TGHtml.h:819
#define N_COLOR
Definition: TGHtml.h:195
unsigned short Html_u16_t
Definition: TGHtml.h:138
#define N_FONT
Definition: TGHtml.h:166
winID h TVirtualViewer3D TVirtualGLPainter p
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize wid
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t target
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t index
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void on
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Option_t Option_t TPoint TPoint const char mode
Option_t Option_t width
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t src
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
Option_t Option_t style
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t height
Option_t Option_t TPoint TPoint const char text
char name[80]
Definition: TGX11.cxx:110
Window client.
Definition: TGClient.h:37
Encapsulate fonts used in the GUI system.
Definition: TGFont.h:140
A subclasses of TGWindow, and is used as base class for some simple widgets (buttons,...
Definition: TGFrame.h:80
Html_32_t fY
Definition: TGHtml.h:668
TGHtmlAnchor(int type, int argc, int arglen[], char *argv[])
HTML anchor element constructor.
TGHtmlBlock * fBNext
Definition: TGHtml.h:721
Html_u16_t fN
Definition: TGHtml.h:720
Html_u16_t fRight
Definition: TGHtml.h:719
char * fZ
Definition: TGHtml.h:717
Html_u16_t fLeft
Definition: TGHtml.h:719
int fTop
Definition: TGHtml.h:718
TGHtmlBlock * fBPrev
Definition: TGHtml.h:721
virtual ~TGHtmlBlock()
Definition: TGHtmlDraw.cxx:60
Definition: TGHtmlDraw.cxx:47
int fBottom
Definition: TGHtml.h:718
Html_32_t fH
Definition: TGHtml.h:392
TImage * fBgImage
Definition: TGHtml.h:396
Html_16_t fColspan
Definition: TGHtml.h:388
Html_16_t fX
Definition: TGHtml.h:389
Html_16_t fW
Definition: TGHtml.h:390
Html_16_t fRowspan
Definition: TGHtml.h:387
TGHtmlCell(int type, int argc, int arglen[], char *argv[])
HTML cell element constructor.
TGHtmlTable * fPTable
Definition: TGHtml.h:393
TGHtmlElement * fPEnd
Definition: TGHtml.h:395
Html_32_t fY
Definition: TGHtml.h:391
HTML cell element destructor.
TGHtmlElement * fPRow
Definition: TGHtml.h:394
Html_u8_t fFlags
Definition: TGHtml.h:266
Html_u8_t fType
Definition: TGHtml.h:265
virtual int GetVerticalAlignment(int dflt)
Definition: TGHtml.h:259
virtual int GetUnorderedListType(int dflt)
Definition: TGHtml.h:258
SHtmlStyle_t fStyle
Definition: TGHtml.h:264
virtual const char * MarkupArg(const char *, const char *)
Definition: TGHtml.h:255
TGHtmlElement(int etype=0)
HTML element constructor.
TGHtmlElement * fPPrev
Definition: TGHtml.h:263
Html_16_t fCount
Definition: TGHtml.h:267
virtual int GetAlignment(int dflt)
Definition: TGHtml.h:256
virtual int GetOrderedListType(int dflt)
Definition: TGHtml.h:257
virtual int IsMarkup() const
Definition: TGHtml.h:254
TGHtmlElement * fPNext
Definition: TGHtml.h:262
unsigned int fHasctl
Definition: TGHtml.h:641
TGHtmlElement * fPEnd
Definition: TGHtml.h:643
Html_u16_t fFormId
Definition: TGHtml.h:639
TGHtmlForm(int type, int argc, int arglen[], char *argv[])
HTML form element constructor.
unsigned int fElements
Definition: TGHtml.h:640
TGHtmlElement * fPFirst
Definition: TGHtml.h:642
Html_32_t fY
Definition: TGHtml.h:654
Html_u16_t fW
Definition: TGHtml.h:656
Html_u16_t fX
Definition: TGHtml.h:655
Html_u8_t fIs3D
Definition: TGHtml.h:657
TGHtmlHr(int type, int argc, int arglen[], char *argv[])
HTML hr element constructor.
Html_u16_t fH
Definition: TGHtml.h:656
TGHtmlImage * fPImage
Definition: TGHtml.h:552
TGHtmlImageMarkup * fINext
Definition: TGHtml.h:554
Html_16_t fAscent
Definition: TGHtml.h:547
Html_u8_t fRedrawNeeded
Definition: TGHtml.h:543
Html_32_t fY
Definition: TGHtml.h:550
Html_16_t fW
Definition: TGHtml.h:546
Html_u8_t fTextAscent
Definition: TGHtml.h:541
TGHtmlImageMarkup(int type, int argc, int arglen[], char *argv[])
HTML image element constructor.
TGHtmlElement * fPMap
Definition: TGHtml.h:553
Html_16_t fDescent
Definition: TGHtml.h:548
Html_16_t fH
Definition: TGHtml.h:545
Html_u8_t fAlign
Definition: TGHtml.h:540
Html_16_t fX
Definition: TGHtml.h:549
Html_u8_t fTextDescent
Definition: TGHtml.h:542
const char * fZAlt
Definition: TGHtml.h:551
char * fZUrl
Definition: TGHtml.h:522
Html_32_t fW
Definition: TGHtml.h:520
TImage * fImage
Definition: TGHtml.h:519
char * fZHeight
Definition: TGHtml.h:523
char * fZWidth
Definition: TGHtml.h:523
virtual ~TGHtmlImage()
Definition: TGHtmlImage.cxx:71
TTimer * fTimer
Definition: TGHtml.h:527
TGHtmlImageMarkup * fPList
Definition: TGHtml.h:525
TGHtmlImage * fPNext
Definition: TGHtml.h:524
TGHtmlImage & operator=(const TGHtmlImage &)=delete
TGHtmlImage(const TGHtmlImage &)=delete
TGHtml * fHtml
Definition: TGHtml.h:518
Html_32_t fH
Definition: TGHtml.h:521
void Empty()
Mark this element as being empty.
Html_u8_t fTextAscent
Definition: TGHtml.h:601
Html_u16_t fW
Definition: TGHtml.h:598
Html_u8_t fTextDescent
Definition: TGHtml.h:602
Html_u8_t fItype
Definition: TGHtml.h:603
Html_u8_t fSized
Definition: TGHtml.h:604
Html_u16_t fH
Definition: TGHtml.h:598
TGFrame * fFrame
Definition: TGHtml.h:591
Html_u16_t fX
Definition: TGHtml.h:597
TGHtml * fHtml
Definition: TGHtml.h:592
Html_u8_t fAlign
Definition: TGHtml.h:600
TGHtmlElement * fPEnd
Definition: TGHtml.h:593
Html_u16_t fInpId
Definition: TGHtml.h:594
Html_u16_t fCnt
Definition: TGHtml.h:605
Html_u8_t fPadLeft
Definition: TGHtml.h:599
TGHtmlForm * fPForm
Definition: TGHtml.h:589
Html_u16_t fSubId
Definition: TGHtml.h:595
TGHtmlInput * fINext
Definition: TGHtml.h:590
Html_32_t fY
Definition: TGHtml.h:596
TGHtmlInput(int type, int argc, int arglen[], char *argv[])
HTML input element constructor.
TGHtmlElement * fPStart
Definition: TGHtml.h:796
int InWrapAround()
Return TRUE (non-zero) if we are currently wrapping text around one or more images.
TGHtmlElement * GetLine(TGHtmlElement *pStart, TGHtmlElement *pEnd, int width, int minX, int *actualWidth)
This routine gathers as many tokens as will fit on one line.
Html Layout Context constructor.
void ComputeMargins(int *pX, int *pY, int *pW)
Compute the current margins for layout.
TGHtmlElement * TableLayout(TGHtmlTable *p)
Do all layout for a single table.
void PopOneMargin(SHtmlMargin_t **ppMargin)
Pop one margin off of the given margin stack.
void PopMargin(SHtmlMargin_t **ppMargin, int tag)
Pop as many margins as necessary until the margin that was created with "tag" is popped off.
void LayoutBlock()
Do as much layout as possible on the block of text defined by the HtmlLayoutContext.
SHtmlMargin_t * fRightMargin
Definition: TGHtml.h:806
void PushMargin(SHtmlMargin_t **ppMargin, int indent, int bottom, int tag)
Push a new margin onto the given margin stack.
void ClearMarginStack(SHtmlMargin_t **ppMargin)
Clear a margin stack to reclaim memory.
TGHtmlElement * DoBreakMarkup(TGHtmlElement *p)
Break markup is any kind of markup that might force a line-break.
void Paragraph(TGHtmlElement *p)
Increase the headroom to create a paragraph break at the current token.
int FixLine(TGHtmlElement *pStart, TGHtmlElement *pEnd, int bottom, int width, int actualWidth, int leftMargin, int *maxX)
This routine computes the X and Y coordinates for all elements of a line that has been gathered using...
void PopIndent()
Adjust (pop) ident.
TGHtml * fHtml
Definition: TGHtml.h:795
void ClearObstacle(int mode)
Clear a wrap-around obstacle.
void WidenLine(int reqWidth, int *pX, int *pY, int *pW)
Move past obstacles until a linewidth of reqWidth is obtained, or until all obstacles are cleared.
void PopExpiredMargins(SHtmlMargin_t **ppMarginStack, int y)
Pop all expired margins from the stack.
void FixAnchors(TGHtmlElement *p, TGHtmlElement *pEnd, int y)
Set the y coordinate for every anchor in the given list.
TGHtmlElement * fPEnd
Definition: TGHtml.h:797
SHtmlMargin_t * fLeftMargin
Definition: TGHtml.h:805
void Reset()
Reset the layout context.
void PushIndent()
Adjust (push) ident.
Html_u8_t fDescent
Definition: TGHtml.h:426
Html_u8_t fAscent
Definition: TGHtml.h:425
Html_32_t fY
Definition: TGHtml.h:429
TGHtmlLi(int type, int argc, int arglen[], char *argv[])
HTML li element constructor.
Html_16_t fX
Definition: TGHtml.h:428
Html_16_t fCnt
Definition: TGHtml.h:427
Html_u8_t fLtype
Definition: TGHtml.h:424
TGHtmlListStart * fLPrev
Definition: TGHtml.h:460
Html_u8_t fLtype
Definition: TGHtml.h:456
TGHtmlListStart(int type, int argc, int arglen[], char *argv[])
HTML list start element constructor.
Html_u16_t fWidth
Definition: TGHtml.h:459
Html_u16_t fCnt
Definition: TGHtml.h:458
Html_u8_t fCompact
Definition: TGHtml.h:457
int fMType
Definition: TGHtml.h:473
TGHtmlMapArea(int type, int argc, int arglen[], char *argv[])
HTML map area constructor.
int * fCoords
Definition: TGHtml.h:474
virtual int GetAlignment(int dflt)
Return an alignment or justification flag associated with the given markup.
virtual int GetVerticalAlignment(int dflt)
Return the vertical alignment specified by the given element.
TGHtmlMarkupElement(int type, int argc, int arglen[], char *argv[])
HTML mrkup element constructor.
virtual ~TGHtmlMarkupElement()
HTML markup element destructor.
virtual const char * MarkupArg(const char *tag, const char *zDefault)
Lookup an argument in the given markup with the name given.
virtual int GetOrderedListType(int dflt)
The "type" argument to the given element might describe the type for an ordered list.
virtual int GetUnorderedListType(int dflt)
The "type" argument to the given element might describe a type for an unordered list.
TImage * fBgImage
Definition: TGHtml.h:412
TGHtmlRef(int type, int argc, int arglen[], char *argv[])
HTML ref element constructor.
HTML ref element destructor.
TGHtmlElement * fPOther
Definition: TGHtml.h:411
int fNStart
Definition: TGHtml.h:684
TGHtmlScript(int type, int argc, int arglen[], char *argv[])
HTML script element constructor.
int fNScript
Definition: TGHtml.h:685
Html_u8_t fDescent
Definition: TGHtml.h:311
Html_u8_t fAscent
Definition: TGHtml.h:310
Html_16_t fW
Definition: TGHtml.h:309
Html_u8_t fBorderWidth
Definition: TGHtml.h:360
TGHtmlTable(int type, int argc, int arglen[], char *argv[])
HTML table element constructor.
int fHasbg
Definition: TGHtml.h:371
int fMaxW[40+1]
Definition: TGHtml.h:368
TGHtmlElement * fPEnd
Definition: TGHtml.h:369
Html_32_t fY
Definition: TGHtml.h:363
int fMinW[40+1]
Definition: TGHtml.h:367
Html_16_t fX
Definition: TGHtml.h:365
HTML table element destructor.
Html_16_t fW
Definition: TGHtml.h:366
Html_u8_t fNCol
Definition: TGHtml.h:361
Html_u16_t fNRow
Definition: TGHtml.h:362
Html_32_t fH
Definition: TGHtml.h:364
TImage * fBgImage
Definition: TGHtml.h:370
TGHtmlTextElement & operator=(const TGHtmlTextElement &)=delete
Html_16_t fW
Definition: TGHtml.h:297
TGHtmlTextElement(const TGHtmlTextElement &)=delete
Html_u8_t fDescent
Definition: TGHtml.h:299
Html_u8_t fSpaceWidth
Definition: TGHtml.h:300
virtual ~TGHtmlTextElement()
HTML element destructor.
Html_32_t fY
Definition: TGHtml.h:295
Html_16_t fX
Definition: TGHtml.h:296
char * fZText
Definition: TGHtml.h:301
Html_u8_t fAscent
Definition: TGHtml.h:298
The ROOT HTML widget.
Definition: TGHtml.h:873
int GetLightShadowColor(int iBgColor)
Given that the background color is iBgColor, figure out an appropriate color for the bright part of t...
Definition: TGHtml.cxx:1734
virtual void SavePrimitive(std::ostream &out, Option_t *="")
Save a html widget as a C++ statement(s) on output stream out.
Definition: TGHtml.cxx:2122
TGHtmlElement * GetMap(const char *name)
Returns html map element.
Definition: TGHtml.cxx:1593
int IsDarkColor(ColorStruct_t *p)
Check to see if the given color is too dark to be easily distinguished from black.
Definition: TGHtml.cxx:1678
void MoveVertically(TGHtmlElement *p, TGHtmlElement *pLast, int dy)
Move all elements in the given list vertically by the amount dy.
int fAddEndTags
Definition: TGHtml.h:1254
TGString * ListTokens(TGHtmlElement *p, TGHtmlElement *pEnd)
Return all tokens between the two elements as a string list.
ColorStruct_t * fFgColor
Definition: TGHtml.h:1238
void RedrawArea(int left, int top, int right, int bottom)
If any part of the screen needs to be redrawn, then call this routine with the values of a box (in wi...
Definition: TGHtml.cxx:789
int fICol
Definition: TGHtml.h:1181
const char * GetPctWidth(TGHtmlElement *p, char *opt, char *ret)
Return the height and width, converting to percent if required ret must be at least 16 characters lon...
int GotoAnchor(const char *name)
Go to anchor position.
Definition: TGHtml.cxx:461
TGHtmlBlock * fLastBlock
Definition: TGHtml.h:1144
void AppToken(TGHtmlElement *pNew, TGHtmlElement *p, int offs)
Insert token pNew before token p.
int SetInsert(const char *insIx)
Set the position of the insertion cursor.
Definition: TGHtml.cxx:2097
virtual ~TGHtml()
HTML widget destructor.
Definition: TGHtml.cxx:231
virtual void RadioChanged(const char *name, const char *val)
Emit RadioChanged() signal.
Definition: TGHtml.cxx:1313
TGHtmlElement * fLoEndPtr
Definition: TGHtml.h:1209
SHtmlIndex_t fSelBegin
Definition: TGHtml.h:1156
char * fZGoto
Definition: TGHtml.h:1281
int fParaAlignment
Definition: TGHtml.h:1198
virtual int FormCreate(TGHtmlForm *, const char *, const char *)
Definition: TGHtml.h:946
TGHtmlBlock * fPSelStartBlock
Definition: TGHtml.h:1158
int fIdind
Definition: TGHtml.h:1279
int fRadioIdx
Definition: TGHtml.h:1152
int fInputIdx
Definition: TGHtml.h:1151
const char * fZBase
Definition: TGHtml.h:1268
int fUnderlineLinks
Definition: TGHtml.h:1251
int TextInsertCmd(int argc, char **argv)
Insert text into text token, or break token into two text tokens.
int IsLightColor(ColorStruct_t *p)
Check to see if the given color is too light to be easily distinguished from white.
Definition: TGHtml.cxx:1725
void TokenizerAppend(const char *text)
Append text to the tokenizer engine.
TGHtmlImage * fImageList
Definition: TGHtml.h:1245
TGHtmlElement * fPFirst
Definition: TGHtml.h:1136
void AddStyle(TGHtmlElement *p)
This routine adds information to the input texts that doesn't change when the display is resized or w...
int fNForm
Definition: TGHtml.h:1148
virtual void MouseDown(const char *uri)
Definition: TGHtml.h:1120
TGHtmlElement * MinMax(TGHtmlElement *p, int *pMin, int *pMax, int lineWidth, int hasbg)
Given a list of elements, compute the minimum and maximum width needed to render the list.
void ScheduleRedraw()
Make sure that a call to the Redraw() routine has been queued.
Definition: TGHtml.cxx:762
TGPopupMenu * fMenu
Definition: TGHtml.h:1190
virtual char * ProcessScript(TGHtmlScript *)
Definition: TGHtml.h:958
void LostSelection()
Clear selection.
Definition: TGHtml.cxx:2027
const char * fLastUri
Definition: TGHtml.h:1287
int fNToken
Definition: TGHtml.h:1138
const char * GetHref(int x, int y, const char **target=0)
This routine searches for a hyperlink beneath the coordinates x,y and returns a pointer to the HREF f...
Definition: TGHtml.cxx:1831
virtual TGFont * GetFont(int iFont)
The rendering and layout routines should call this routine in order to get a font structure.
Definition: TGHtml.cxx:1465
ColorStruct_t * fApColor[32]
Definition: TGHtml.h:1232
SHtmlIndex_t fIns
Definition: TGHtml.h:1170
void UpdateInsert()
Recompute the position of the insertion cursor based on the position in fIns.
Definition: TGHtml.cxx:2084
int fAnchorFlags
Definition: TGHtml.h:1200
int fExiting
Definition: TGHtml.h:1288
TGHtmlElement * InsertToken(TGHtmlElement *pToken, char *zType, char *zArgs, int offs)
This routine takes a text representation of a token, converts it into an TGHtmlElement object and ins...
TGHtmlElement * fLastSized
Definition: TGHtml.h:1140
void LayoutDoc()
Advance the layout as far as possible.
void BlockDraw(TGHtmlBlock *pBlock, Drawable_t wid, int left, int top, int width, int height, Pixmap_t pixmap)
Display a single HtmlBlock. This is where all the drawing happens.
Definition: TGHtmlDraw.cxx:317
void AppendBlock(TGHtmlElement *pToken, TGHtmlBlock *pBlock)
Append a block to the block list and insert the block into the element list immediately prior to the ...
Definition: TGHtmlDraw.cxx:93
void IndexToBlockIndex(SHtmlIndex_t sIndex, TGHtmlBlock **ppBlock, int *piIndex)
Convert an Element-based index into a Block-based index.
int fLastGC
Definition: TGHtml.h:1244
int GetColorByName(const char *zColor)
This routine returns an index between 0 and N_COLOR-1 which indicates which ColorStruct_t structure i...
Definition: TGHtml.cxx:1629
void DrawImage(TGHtmlImageMarkup *image, Drawable_t wid, int left, int top, int right, int bottom)
Draw all or part of an image.
Definition: TGHtmlDraw.cxx:539
TGHtmlInput * fFormElemLast
Definition: TGHtml.h:1207
void AnimateImage(TGHtmlImage *image)
TGImage *img = image->image;.
Definition: TGHtmlDraw.cxx:591
TGHtmlBlock * fPInsBlock
Definition: TGHtml.h:1171
virtual void InputSelected(const char *name, const char *val)
Emit Selected() signal.
Definition: TGHtml.cxx:1326
const char * TypeToName(int type)
Convert a type into a symbolic name.
virtual void CheckToggled(const char *name, Bool_t on, const char *val)
Emit CheckToggled() signal.
Definition: TGHtml.cxx:1299
void EncodeText(TGString *str, const char *z)
Append to the given TString an encoded version of the given text.
Definition: TGHtmlForm.cxx:642
int SelectionSet(const char *startIx, const char *endIx)
Set selection.
Definition: TGHtml.cxx:2042
virtual void Clear(Option_t *="")
Erase all HTML from this widget and clear the screen.
Definition: TGHtml.cxx:310
void UpdateSelectionDisplay()
The fPSelStartBlock and fPSelEndBlock values have been changed.
Definition: TGHtml.cxx:1981
TGHtmlBlock * fPSelEndBlock
Definition: TGHtml.h:1162
ColorStruct_t * fSelectionColor
Definition: TGHtml.h:1241
int Tokenize()
Process as much of the input HTML as possible.
void SaveFileAs()
Save file.
Definition: TGHtml.cxx:1348
virtual Bool_t HandleFocusChange(Event_t *event)
Handle focus change event.
Definition: TGHtml.cxx:1132
virtual Bool_t ProcessMessage(Longptr_t, Longptr_t, Longptr_t)
Process messages (GUI events) in the html widget.
Definition: TGHtmlForm.cxx:670
int fInsOffTime
Definition: TGHtml.h:1167
void FormBlocks()
Add additional blocks to the block list in order to cover all elements on the element list.
Definition: TGHtmlDraw.cxx:831
TGInsets fMargins
Definition: TGHtml.h:1223
int NextMarkupType(TGHtmlElement *p)
Return the next markup type [TGHtmlElement::NextMarkupType].
void MaxIndex(TGHtmlElement *p, int *pIndex, int isLast)
Find the maximum index for the given token.
Definition: TGHtmlIndex.cxx:97
void StringHW(const char *str, int *h, int *w)
Return the height and width of string.
Definition: TGHtmlTable.cxx:77
int fVarind
Definition: TGHtml.h:1256
TGFont * fAFont[71]
Definition: TGHtml.h:1228
int fFlags
Definition: TGHtml.h:1278
virtual void ButtonClicked(const char *name, const char *val)
Emit ButtonClicked() signal.
Definition: TGHtml.cxx:1286
ColorStruct_t * fHighlightBgColorPtr
Definition: TGHtml.h:1225
int NameToType(char *zType)
Convert a markup name into a type integer.
void SetRuleRelief(int relief)
Sets relief mode of html rule.
Definition: TGHtml.cxx:396
virtual void UpdateBackgroundStart()
Start background update.
Definition: TGHtml.cxx:250
int CellSpacing(TGHtmlElement *pTable)
Return the appropriate cell spacing for the given table.
Definition: TGHtmlTable.cxx:53
int fInsOnTime
Definition: TGHtml.h:1166
int fVarId
Definition: TGHtml.h:1149
TGHtmlElement * FillOutBlock(TGHtmlBlock *p)
Recompute the following fields of the given block structure:
Definition: TGHtmlDraw.cxx:617
int fDirtyBottom
Definition: TGHtml.h:1277
SHtmlStyleStack_t * fStyleStack
Definition: TGHtml.h:1197
int ParseText(char *text, const char *index=0)
Appends (or insert at the specified position) the given HTML text to the end of any HTML text that ma...
Definition: TGHtml.cxx:325
virtual Bool_t HandleTimer(TTimer *timer)
Handle timer event.
Definition: TGHtml.cxx:1004
ColorStruct_t * fNewLinkColor
Definition: TGHtml.h:1239
TGHtmlListStart * fInnerList
Definition: TGHtml.h:1208
int fIPlaintext
Definition: TGHtml.h:1183
void RedrawText(int y)
Call this routine to cause all of the rendered HTML at the virtual canvas coordinate of Y and beyond ...
Definition: TGHtml.cxx:887
int IndexMod(TGHtmlElement **pp, int *ip, char *cp)
Modify an index for both pointer and char +/-/=N.
virtual Bool_t HandleButton(Event_t *event)
Handle mouse button event.
Definition: TGHtml.cxx:1389
int fOverrideColors
Definition: TGHtml.h:1250
virtual void MouseOver(const char *uri)
Definition: TGHtml.h:1119
Bool_t HandleRadioButton(TGHtmlInput *p)
Handle radio button event.
Definition: TGHtml.cxx:1267
int fMaxY
Definition: TGHtml.h:1271
Cursor_t fCursor
Definition: TGHtml.h:1270
void AppendArglist(TGString *str, TGHtmlMarkupElement *pElem)
Append all the arguments of the given markup to the given TGString.
virtual int FormAction(TGHtmlForm *, int)
Definition: TGHtml.h:950
virtual Bool_t HandleMotion(Event_t *event)
handle mouse motion events
Definition: TGHtml.cxx:1438
TGHtmlInput * GetInputElement(int x, int y)
This routine searches for a hyperlink beneath the coordinates x,y and returns a pointer to the HREF f...
Definition: TGHtml.cxx:1151
char * fZText
Definition: TGHtml.h:1176
ClassDef(TGHtml, 0)
int fInsIndex
Definition: TGHtml.h:1172
void FindIndexInBlock(TGHtmlBlock *pBlock, int x, TGHtmlElement **ppToken, int *pIndex)
Given a Block and an x coordinate, find the Index of the character that is closest to the given x coo...
int fNInput
Definition: TGHtml.h:1147
void TableBgndImage(TGHtmlElement *p)
Set background picture of a html table.
void UpdateSelection(int forceUpdate)
Given the selection end-points in fSelBegin and fSelEnd, recompute pSelBeginBlock and fPSelEndBlock,...
Definition: TGHtml.cxx:1928
int fNAlloc
Definition: TGHtml.h:1178
TGHtmlElement * TokenByIndex(int N, int flag)
Return a pointer to the Nth TGHtmlElement in the list.
Definition: TGHtmlIndex.cxx:48
void SetBaseUri(const char *uri)
Sets base URI.
Definition: TGHtml.cxx:451
void AppendElement(TGHtmlElement *pElem)
Append the given TGHtmlElement to the tokenizers list of elements.
int fDirtyRight
Definition: TGHtml.h:1277
int GetMarginHeight()
Definition: TGHtml.h:968
void DeleteControls()
Delete all input controls.
Definition: TGHtmlForm.cxx:103
void ImageChanged(TGHtmlImage *image, int newWidth, int newHeight)
This routine is called when an image changes.
virtual TImage * LoadImage(const char *uri, int w=0, int h=0)
This is the default LoadImage() procedure.
ColorStruct_t * AllocColorByValue(ColorStruct_t *color)
Allocate system color by value.
Definition: TGHtml.cxx:291
void MakeInvisible(TGHtmlElement *p_first, TGHtmlElement *p_last)
Add the STY_Invisible style to every token between p_first and p_last.
virtual Bool_t HandleIdleEvent(TGIdleHandler *i)
Handles idle event.
Definition: TGHtml.cxx:773
TGHtmlInput * fFirstInput
Definition: TGHtml.h:1145
int GetImageAt(int x, int y)
This routine searchs for an image beneath the coordinates x,y and returns the token number of the the...
void SetTableRelief(int relief)
Sets relief mode of html table.
Definition: TGHtml.cxx:384
void AppendText(TGString *str, TGHtmlElement *pFirst, TGHtmlElement *pEnd)
Append all text and space tokens between pStart and pEnd to the given TString.
Definition: TGHtmlForm.cxx:246
void UnmapControls()
Unmap any input control that is currently mapped.
Definition: TGHtmlForm.cxx:51
ColorStruct_t * AllocColor(const char *name)
Allocate system color by name.
Definition: TGHtml.cxx:272
TGString * TableText(TGHtmlTable *pTable, int flags)
Return text and images from a table as lists.
void DrawRect(Drawable_t drawable, TGHtmlElement *src, int x, int y, int w, int h, int depth, int relief)
Draw a rectangle.
Definition: TGHtmlDraw.cxx:266
int GetImageAlignment(TGHtmlElement *p)
Find the alignment for an image.
Definition: TGHtmlImage.cxx:84
virtual int ProcessToken(TGHtmlElement *, const char *, int)
Definition: TGHtml.h:928
void HClear()
Erase all data from the HTML widget. Bring it back to an empty screen.
Definition: TGHtml.cxx:901
int fRowAlignment
Definition: TGHtml.h:1199
THashTable * fUidTable
Definition: TGHtml.h:1285
ColorStruct_t * fHighlightColorPtr
Definition: TGHtml.h:1227
int fFormPadding
Definition: TGHtml.h:1248
void AddSelectOptions(TGListBox *lb, TGHtmlElement *p, TGHtmlElement *pEnd)
The "p" argument points to a <select>.
Definition: TGHtmlForm.cxx:303
GContext_t GetAnyGC()
Retrieve any valid GC.
Definition: TGHtml.cxx:1117
TGHtmlElement * FindStartOfNextBlock(TGHtmlElement *p, int *pCnt)
Scan ahead looking for a place to put a block.
Definition: TGHtmlDraw.cxx:806
Html_16_t fSelStartIndex
Definition: TGHtml.h:1159
virtual Bool_t ItemLayout()
Layout html widget.
Definition: TGHtml.cxx:834
TGHtmlScript * fPScript
Definition: TGHtml.h:1187
virtual int ProcessFrame()
Definition: TGHtml.h:938
TGHtmlBlock * fFirstBlock
Definition: TGHtml.h:1143
void DrawTableBgnd(int x, int y, int w, int h, Drawable_t d, TImage *image)
Draw table background.
Definition: TGHtmlDraw.cxx:857
void RedrawBlock(TGHtmlBlock *p)
Redraw the TGHtmlBlock given.
Definition: TGHtml.cxx:866
int fInTr
Definition: TGHtml.h:1202
TGIdleHandler * fIdle
Definition: TGHtml.h:1189
int fMaxX
Definition: TGHtml.h:1271
int fILight[32]
Definition: TGHtml.h:1236
const char * GetUid(const char *string)
Given a string, this procedure returns a unique identifier for the string.
Definition: TGHtml.cxx:490
void Redraw()
This routine is invoked in order to redraw all or part of the HTML widget.
Definition: TGHtml.cxx:544
int GetLinkColor(const char *zURL)
For the markup <a href=XXX>, find out if the URL has been visited before or not.
Html_16_t fSelEndIndex
Definition: TGHtml.h:1161
virtual char * GetFontName()
Definition: TGHtml.h:954
TGHtmlAnchor * fAnchorStart
Definition: TGHtml.h:1204
int GetColorByValue(ColorStruct_t *pRef)
Find a color integer for the color whose color components are given by pRef.
Definition: TGHtml.cxx:1767
char fFontValid[(71+7)/8]
Definition: TGHtml.h:1229
void Sizer()
Compute the size of all elements in the widget.
int fDirtyTop
Definition: TGHtml.h:1274
const char * GetBaseUri() const
Definition: TGHtml.h:907
int fHasFrames
Definition: TGHtml.h:1253
Long_t fColorUsed
Definition: TGHtml.h:1233
void DrawSelectionBackground(TGHtmlBlock *pBlock, Drawable_t Drawable_t, int x, int y)
Draw the selection background for the given block.
Definition: TGHtmlDraw.cxx:216
int fDirtyLeft
Definition: TGHtml.h:1274
TGHtmlMarkupElement * MakeMarkupEntry(int objType, int type, int argc, int arglen[], char *argv[])
Make one markup entry.
TTimer * fInsTimer
Definition: TGHtml.h:1169
TGHtmlElement * fPLast
Definition: TGHtml.h:1137
SHtmlStyle_t PopStyleStack(int tag)
Pop a rendering style off of the stack.
Definition: TGHtmlSizer.cxx:87
void FreeColor(ColorStruct_t *color)
Free system color.
Definition: TGHtml.cxx:263
void ComputeVirtualSize()
Computes virtual size of html area.
Definition: TGHtml.cxx:508
int FormCount(TGHtmlInput *p, int radio)
Return the number of elments of type p in a form.
Definition: TGHtmlForm.cxx:543
int TokenNumber(TGHtmlElement *p)
Return the token number for the given TGHtmlElement.
Definition: TGHtmlIndex.cxx:79
int fInTd
Definition: TGHtml.h:1203
int fRulePadding
Definition: TGHtml.h:1267
Definition: TGHtml.h:1133
Definition: TGHtml.h:1133
int fRuleRelief
Definition: TGHtml.h:1266
TGHtmlElement * AttrElem(const char *name, char *value)
Returns html element matching attribute name and value.
Definition: TGHtml.cxx:1907
int fGcNextToFree
Definition: TGHtml.h:1243
virtual int IsVisited(const char *)
Definition: TGHtml.h:924
GContext_t GetGC(int color, int font)
Return a GC from the cache.
Definition: TGHtml.cxx:1047
virtual char * ResolveUri(const char *uri)
This function resolves the specified URI and returns the result in a newly allocated string.
Definition: TGHtmlUri.cxx:284
int GetRulePadding() const
Definition: TGHtml.h:902
int InArea(TGHtmlMapArea *p, int left, int top, int x, int y)
Only support rect and circles for now.
Definition: TGHtml.cxx:1574
virtual void DrawRegion(Int_t x, Int_t y, UInt_t w, UInt_t h)
Draw region defined by [x,y] [w,h].
Definition: TGHtml.cxx:805
void PushStyleStack(int tag, SHtmlStyle_t style)
Push a new rendering style onto the stack.
Definition: TGHtmlSizer.cxx:66
TGHtmlElement * fNextPlaced
Definition: TGHtml.h:1141
int fOverrideFonts
Definition: TGHtml.h:1249
SHtmlTokenMap_t * GetMarkupMap(int n)
Returns token map at location n.
void SizeAndLink(TGFrame *frame, TGHtmlInput *pElem)
'frame' is the child widget that is used to implement an input element.
Definition: TGHtmlForm.cxx:192
TImage * fBgImage
Definition: TGHtml.h:1246
int fNComplete
Definition: TGHtml.h:1179
int ControlSize(TGHtmlInput *p)
This routine implements the Sizer() function for <INPUT>, <SELECT> and <TEXTAREA> markup.
Definition: TGHtmlForm.cxx:357
SHtmlTokenMap_t * NameToPmap(char *zType)
Returns token map matching zType name.
int fInDt
Definition: TGHtml.h:1201
TGHtmlLayoutContext fLayoutContext
Definition: TGHtml.h:1216
TGHtmlElement * FindEndNest(TGHtmlElement *sp, int en, TGHtmlElement *lp)
Find End tag en, but ignore intervening begin/end tag pairs.
int fExportSelection
Definition: TGHtml.h:1260
ColorStruct_t * fBgColor
Definition: TGHtml.h:1237
void RedrawEverything()
Call this routine to force the entire widget to be redrawn.
Definition: TGHtml.cxx:877
char * DumpToken(TGHtmlElement *p)
For debugging purposes, print information about a token.
virtual void SubmitClicked(const char *val)
Emit SubmitClicked() signal.
Definition: TGHtml.cxx:1339
void UnderlineLinks(int onoff)
Set/reset html links underline.
Definition: TGHtml.cxx:408
int fHighlightWidth
Definition: TGHtml.h:1220
SHtmlIndex_t fSelEnd
Definition: TGHtml.h:1157
SHtmlStyle_t GetCurrentStyle()
Get the current rendering style.
Definition: TGHtmlSizer.cxx:41
int GetTableRelief() const
Definition: TGHtml.h:898
int MapControls()
Map any control that should be visible according to the current scroll position.
Definition: TGHtmlForm.cxx:71
TGHtmlImage * GetImage(TGHtmlImageMarkup *p)
Given an <IMG> markup, find or create an appropriate TGHtmlImage object and return a pointer to that ...
char * GetTokenName(TGHtmlElement *p)
Returns token name of html element p.
const char * GetText() const
Definition: TGHtml.h:962
void ClearGcCache()
Clear the cache of GCs.
Definition: TGHtml.cxx:516
void ResetBlocks()
Definition: TGHtml.h:978
int GetIndex(const char *zIndex, TGHtmlElement **ppToken, int *pIndex)
This routine decodes a complete index specification.
ColorStruct_t * fOldLinkColor
Definition: TGHtml.h:1240
TGHtmlForm * fLoFormStart
Definition: TGHtml.h:1210
TGHtmlInput * fFormElemStart
Definition: TGHtml.h:1206
virtual TGFrame * ProcessApplet(TGHtmlInput *)
Definition: TGHtml.h:942
int ElementCoords(TGHtmlElement *p, int i, int pct, int *coords)
Return coordinates of item.
Definition: TGHtml.cxx:1877
int fHasScript
Definition: TGHtml.h:1252
TGHtmlElement * TableDimensions(TGHtmlTable *pStart, int lineWidth)
pStart points to a <table>.
int fTableRelief
Definition: TGHtml.h:1265
GcCache_t fAGcCache[32]
Definition: TGHtml.h:1242
void PrintList(TGHtmlElement *first, TGHtmlElement *last)
Print a list of tokens.
TGHtmlForm * fFormStart
Definition: TGHtml.h:1205
void HandleMenu(Int_t)
Handle context menu entries events.
Definition: TGHtml.cxx:1373
float ColorDistance(ColorStruct_t *pA, ColorStruct_t *pB)
Compute the squared distance between two colors.
Definition: TGHtml.cxx:1613
void FlashCursor()
Flash the insertion cursor.
Definition: TGHtml.cxx:1026
int GetDarkShadowColor(int iBgColor)
Given that the background color is iBgColor, figure out an appropriate color for the dark part of a 3...
Definition: TGHtml.cxx:1692
int GetRuleRelief() const
Definition: TGHtml.h:901
int fInsStatus
Definition: TGHtml.h:1168
TGHtml(const TGWindow *p, int w, int h, int id=-1)
HTML Widget constructor.
Definition: TGHtml.cxx:79
Bool_t HandleHtmlInput(TGHtmlInput *pr, Event_t *event)
Handle html input (button, checkbox, ...) event.
Definition: TGHtml.cxx:1176
int fInParse
Definition: TGHtml.h:1280
void AddFormInfo(TGHtmlElement *p)
Add the DOM control information for form elements.
Definition: TGHtmlForm.cxx:565
int DecodeBaseIndex(const char *zBase, TGHtmlElement **ppToken, int *pIndex)
Given a base index name (without any modifiers) return a pointer to the token described,...
void UnlinkAndFreeBlock(TGHtmlBlock *pBlock)
Destroy the given Block after first unlinking it from the element list.
Definition: TGHtmlDraw.cxx:70
int GetMarginWidth()
Definition: TGHtml.h:967
int fTableBorderMin
Definition: TGHtml.h:1255
SHtmlExtensions_t * fExts
Definition: TGHtml.h:1283
int fIDark[32]
Definition: TGHtml.h:1235
char * fZBaseHref
Definition: TGHtml.h:1269
TGHtmlInput * fLastInput
Definition: TGHtml.h:1146
void ResetLayoutContext()
Reset the main layout context in the main widget.
Definition: TGHtml.cxx:533
int fNText
Definition: TGHtml.h:1177
Handle idle events, i.e.
Definition: TGIdleHandler.h:19
Int_t fR
Definition: TGDimension.h:75
Int_t fL
Definition: TGDimension.h:74
Int_t fB
Definition: TGDimension.h:77
Int_t fT
Definition: TGDimension.h:76
A listbox is a box, possibly with scrollbar, containing entries.
Definition: TGListBox.h:221
This class creates a popup menu object.
Definition: TGMenu.h:110
TGString wraps a TString and adds some graphics routines like drawing, size of string on screen depen...
Definition: TGString.h:20
A TGView provides the infrastructure for text viewer and editor widgets.
Definition: TGView.h:23
ROOT GUI Window base class.
Definition: TGWindow.h:23
THashTable implements a hash table to store TObject's.
Definition: THashTable.h:35
An abstract interface to image processing library.
Definition: TImage.h:29
Mother of all ROOT objects.
Definition: TObject.h:37
void Emit(const char *signal, const T &arg)
Activate signal with single parameter.
Definition: TQObject.h:164
Handles synchronous and a-synchronous timer events.
Definition: TTimer.h:51
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
const Int_t n
Definition: legend1.C:16
Definition: first.py:1
Event structure.
Definition: GuiTypes.h:174
Html_u8_t fIndex
Definition: TGHtml.h:825
Html_u8_t fFont
Definition: TGHtml.h:823
Html_u8_t fColor
Definition: TGHtml.h:824
GContext_t fGc
Definition: TGHtml.h:822
void * fExts
Definition: TGHtml.h:484
SHtmlExtensions_t * fNext
Definition: TGHtml.h:487
TGHtmlElement * fP
Definition: TGHtml.h:833
SHtmlMargin_t * fPNext
Definition: TGHtml.h:747
int fIndent
Definition: TGHtml.h:744
int fBottom
Definition: TGHtml.h:745
SHtmlStyle_t fStyle
Definition: TGHtml.h:736
SHtmlStyleStack_t * fPNext
Definition: TGHtml.h:734
unsigned int fColor
Definition: TGHtml.h:146
signed int fSubscript
Definition: TGHtml.h:147
unsigned int fExpbg
Definition: TGHtml.h:150
unsigned int fAlign
Definition: TGHtml.h:148
unsigned int fBgcolor
Definition: TGHtml.h:149
unsigned int fFont
Definition: TGHtml.h:145
unsigned int fFlags
Definition: TGHtml.h:151
Html_16_t fObjType
Definition: TGHtml.h:843
Html_16_t fType
Definition: TGHtml.h:842
SHtmlTokenMap_t * fPCollide
Definition: TGHtml.h:844
const char * fZName
Definition: TGHtml.h:841