1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: wxHtmlCell class is used by wxHtmlWindow/wxHtmlWinParser
4 // as a basic visual element of HTML page
5 // Author: Vaclav Slavik
7 // Copyright: (c) 1999 Vaclav Slavik
8 // Licence: wxWindows Licence
9 /////////////////////////////////////////////////////////////////////////////
12 #ifndef _WX_HTMLCELL_H_
13 #define _WX_HTMLCELL_H_
16 #pragma interface "htmlcell.h"
23 #include "wx/html/htmltag.h"
24 #include "wx/html/htmldefs.h"
25 #include "wx/window.h"
28 class WXDLLEXPORT wxHtmlLinkInfo
;
29 class WXDLLEXPORT wxHtmlCell
;
30 class WXDLLEXPORT wxHtmlContainerCell
;
32 //--------------------------------------------------------------------------------
34 // Internal data structure. It represents fragments of parsed HTML
35 // page - a word, picture, table, horizontal line and so on.
36 // It is used by wxHtmlWindow to represent HTML page in memory.
37 //--------------------------------------------------------------------------------
40 class WXDLLEXPORT wxHtmlCell
: public wxObject
44 virtual ~wxHtmlCell();
46 void SetParent(wxHtmlContainerCell
*p
) {m_Parent
= p
;}
47 wxHtmlContainerCell
*GetParent() const {return m_Parent
;}
49 int GetPosX() const {return m_PosX
;}
50 int GetPosY() const {return m_PosY
;}
51 int GetWidth() const {return m_Width
;}
52 int GetHeight() const {return m_Height
;}
53 int GetDescent() const {return m_Descent
;}
55 const wxString
& GetId() const { return m_id
; }
56 void SetId(const wxString
& id
) { m_id
= id
; }
58 // returns the link associated with this cell. The position is position within
59 // the cell so it varies from 0 to m_Width, from 0 to m_Height
60 virtual wxHtmlLinkInfo
* GetLink(int WXUNUSED(x
) = 0, int WXUNUSED(y
) = 0) const
63 // members access methods
64 wxHtmlCell
*GetNext() const {return m_Next
;}
66 // members writing methods
67 virtual void SetPos(int x
, int y
) {m_PosX
= x
, m_PosY
= y
;}
68 void SetLink(const wxHtmlLinkInfo
& link
);
69 void SetNext(wxHtmlCell
*cell
) {m_Next
= cell
;}
71 // 1. adjust cell's width according to the fact that maximal possible width is w.
72 // (this has sense when working with horizontal lines, tables etc.)
73 // 2. prepare layout (=fill-in m_PosX, m_PosY (and sometime m_Height) members)
74 // = place items to fit window, according to the width w
75 virtual void Layout(int w
);
78 virtual void Draw(wxDC
& WXUNUSED(dc
), int WXUNUSED(x
), int WXUNUSED(y
), int WXUNUSED(view_y1
), int WXUNUSED(view_y2
)) {}
80 // proceed drawing actions in case the cell is not visible (scrolled out of screen).
81 // This is needed to change fonts, colors and so on
82 virtual void DrawInvisible(wxDC
& WXUNUSED(dc
), int WXUNUSED(x
), int WXUNUSED(y
)) {}
84 // This method returns pointer to the FIRST cell for that
86 // is true. It first checks if the condition is true for this
87 // cell and then calls m_Next->Find(). (Note: it checks
88 // all subcells if the cell is container)
89 // Condition is unique condition identifier (see htmldefs.h)
90 // (user-defined condition IDs should start from 10000)
91 // and param is optional parameter
92 // Example : m_Cell->Find(wxHTML_COND_ISANCHOR, "news");
93 // returns pointer to anchor news
94 virtual const wxHtmlCell
* Find(int condition
, const void* param
) const;
96 // This function is called when mouse button is clicked over the cell.
98 // Parent is pointer to wxHtmlWindow that generated the event
99 // HINT: if this handling is not enough for you you should use
101 virtual void OnMouseClick(wxWindow
*parent
, int x
, int y
, const wxMouseEvent
& event
);
103 // This method used to adjust pagebreak position. The parameter is
104 // variable that contains y-coordinate of page break (= horizontal line that
105 // should not be crossed by words, images etc.). If this cell cannot be divided
106 // into two pieces (each one on another page) then it moves the pagebreak
109 // Returned value : true if pagebreak was modified, false otherwise
110 // Usage : while (container->AdjustPagebreak(&p)) {}
111 virtual bool AdjustPagebreak(int *pagebreak
) const;
113 // Sets cell's behaviour on pagebreaks (see AdjustPagebreak). Default
114 // is true - the cell can be split on two pages
115 void SetCanLiveOnPagebreak(bool can
) { m_CanLiveOnPagebreak
= can
; }
117 // Returns y-coordinates that contraint the cell, i.e. left is highest
118 // and right lowest coordinate such that the cell lays between then.
119 // Note: this method does not return meaningful values if you haven't
120 // called Layout() before!
121 virtual void GetHorizontalConstraints(int *left
, int *right
) const;
123 // Returns true for simple == terminal cells, i.e. not composite ones.
124 // This if for internal usage only and may disappear in future versions!
125 virtual bool IsTerminalCell() const { return TRUE
; }
127 // Find the terminal cell inside this cell at the given position (relative
130 // Returns NULL if not found
131 virtual wxHtmlCell
*FindCellByPos(wxCoord x
, wxCoord y
) const;
135 // pointer to the next cell
136 wxHtmlContainerCell
*m_Parent
;
137 // pointer to parent cell
138 long m_Width
, m_Height
, m_Descent
;
139 // dimensions of fragment
140 // m_Descent is used to position text&images..
142 // position where the fragment is drawn
143 wxHtmlLinkInfo
*m_Link
;
144 // destination address if this fragment is hypertext link, NULL otherwise
145 bool m_CanLiveOnPagebreak
;
146 // true if this cell can be placed on pagebreak, false otherwise
148 // unique identifier of the cell, generated from "id" property of tags
154 //--------------------------------------------------------------------------------
156 //--------------------------------------------------------------------------------
159 //--------------------------------------------------------------------------------
161 // Single word in input stream.
162 //--------------------------------------------------------------------------------
164 class WXDLLEXPORT wxHtmlWordCell
: public wxHtmlCell
167 wxHtmlWordCell(const wxString
& word
, wxDC
& dc
);
168 void Draw(wxDC
& dc
, int x
, int y
, int view_y1
, int view_y2
);
178 //--------------------------------------------------------------------------------
179 // wxHtmlContainerCell
180 // Container - it contains other cells. Basic of layout algorithm.
181 //--------------------------------------------------------------------------------
183 class WXDLLEXPORT wxHtmlContainerCell
: public wxHtmlCell
186 wxHtmlContainerCell(wxHtmlContainerCell
*parent
);
187 ~wxHtmlContainerCell();
189 virtual void Layout(int w
);
190 virtual void Draw(wxDC
& dc
, int x
, int y
, int view_y1
, int view_y2
);
191 virtual void DrawInvisible(wxDC
& dc
, int x
, int y
);
192 virtual bool AdjustPagebreak(int *pagebreak
) const;
194 // insert cell at the end of m_Cells list
195 void InsertCell(wxHtmlCell
*cell
);
197 // sets horizontal/vertical alignment
198 void SetAlignHor(int al
) {m_AlignHor
= al
; m_LastLayout
= -1;}
199 int GetAlignHor() const {return m_AlignHor
;}
200 void SetAlignVer(int al
) {m_AlignVer
= al
; m_LastLayout
= -1;}
201 int GetAlignVer() const {return m_AlignVer
;}
203 // sets left-border indentation. units is one of wxHTML_UNITS_* constants
204 // what is combination of wxHTML_INDENT_*
205 void SetIndent(int i
, int what
, int units
= wxHTML_UNITS_PIXELS
);
206 // returns the indentation. ind is one of wxHTML_INDENT_* constants
207 int GetIndent(int ind
) const;
208 // returns type of value returned by GetIndent(ind)
209 int GetIndentUnits(int ind
) const;
211 // sets alignment info based on given tag's params
212 void SetAlign(const wxHtmlTag
& tag
);
213 // sets floating width adjustment
214 // (examples : 32 percent of parent container,
215 // -15 pixels percent (this means 100 % - 15 pixels)
216 void SetWidthFloat(int w
, int units
) {m_WidthFloat
= w
; m_WidthFloatUnits
= units
; m_LastLayout
= -1;}
217 void SetWidthFloat(const wxHtmlTag
& tag
, double pixel_scale
= 1.0);
218 // sets minimal height of this container.
219 void SetMinHeight(int h
, int align
= wxHTML_ALIGN_TOP
) {m_MinHeight
= h
; m_MinHeightAlign
= align
; m_LastLayout
= -1;}
221 void SetBackgroundColour(const wxColour
& clr
) {m_UseBkColour
= TRUE
; m_BkColour
= clr
;}
222 void SetBorder(const wxColour
& clr1
, const wxColour
& clr2
) {m_UseBorder
= TRUE
; m_BorderColour1
= clr1
, m_BorderColour2
= clr2
;}
223 virtual wxHtmlLinkInfo
* GetLink(int x
= 0, int y
= 0) const;
224 virtual const wxHtmlCell
* Find(int condition
, const void* param
) const;
225 virtual void OnMouseClick(wxWindow
*parent
, int x
, int y
, const wxMouseEvent
& event
);
226 virtual void GetHorizontalConstraints(int *left
, int *right
) const;
228 // returns pointer to the first cell in container or NULL
229 wxHtmlCell
* GetFirstCell() const {return m_Cells
;}
231 // see comment in wxHtmlCell about this method
232 virtual bool IsTerminalCell() const { return false; }
234 virtual wxHtmlCell
*FindCellByPos(wxCoord x
, wxCoord y
) const;
237 int m_IndentLeft
, m_IndentRight
, m_IndentTop
, m_IndentBottom
;
238 // indentation of subcells. There is always m_Indent pixels
239 // big space between given border of the container and the subcells
240 // it m_Indent < 0 it is in PERCENTS, otherwise it is in pixels
241 int m_MinHeight
, m_MinHeightAlign
;
243 wxHtmlCell
*m_Cells
, *m_LastCell
;
244 // internal cells, m_Cells points to the first of them, m_LastCell to the last one.
245 // (LastCell is needed only to speed-up InsertCell)
246 int m_AlignHor
, m_AlignVer
;
247 // alignment horizontal and vertical (left, center, right)
248 int m_WidthFloat
, m_WidthFloatUnits
;
249 // width float is used in adjustWidth
252 // background color of this container
254 wxColour m_BorderColour1
, m_BorderColour2
;
255 // borders color of this container
257 // if != -1 then call to Layout may be no-op
258 // if previous call to Layout has same argument
265 //--------------------------------------------------------------------------------
268 //--------------------------------------------------------------------------------
270 class WXDLLEXPORT wxHtmlColourCell
: public wxHtmlCell
273 wxHtmlColourCell(const wxColour
& clr
, int flags
= wxHTML_CLR_FOREGROUND
) : wxHtmlCell() {m_Colour
= clr
; m_Flags
= flags
;}
274 virtual void Draw(wxDC
& dc
, int x
, int y
, int view_y1
, int view_y2
);
275 virtual void DrawInvisible(wxDC
& dc
, int x
, int y
);
285 //--------------------------------------------------------------------------------
287 // Sets actual font used for text rendering
288 //--------------------------------------------------------------------------------
290 class WXDLLEXPORT wxHtmlFontCell
: public wxHtmlCell
293 wxHtmlFontCell(wxFont
*font
) : wxHtmlCell() { m_Font
= (*font
); }
294 virtual void Draw(wxDC
& dc
, int x
, int y
, int view_y1
, int view_y2
);
295 virtual void DrawInvisible(wxDC
& dc
, int x
, int y
);
306 //--------------------------------------------------------------------------------
308 // This cell is connected with wxWindow object
309 // You can use it to insert windows into HTML page
310 // (buttons, input boxes etc.)
311 //--------------------------------------------------------------------------------
313 class WXDLLEXPORT wxHtmlWidgetCell
: public wxHtmlCell
316 // !!! wnd must have correct parent!
317 // if w != 0 then the m_Wnd has 'floating' width - it adjust
318 // it's width according to parent container's width
319 // (w is percent of parent's width)
320 wxHtmlWidgetCell(wxWindow
*wnd
, int w
= 0);
321 ~wxHtmlWidgetCell() { m_Wnd
->Destroy(); }
322 virtual void Draw(wxDC
& dc
, int x
, int y
, int view_y1
, int view_y2
);
323 virtual void DrawInvisible(wxDC
& dc
, int x
, int y
);
324 virtual void Layout(int w
);
329 // width float is used in adjustWidth (it is in percents)
334 //--------------------------------------------------------------------------------
336 // Internal data structure. It represents hypertext link
337 //--------------------------------------------------------------------------------
339 class WXDLLEXPORT wxHtmlLinkInfo
: public wxObject
342 wxHtmlLinkInfo() : wxObject()
343 { m_Href
= m_Target
= wxEmptyString
; m_Event
= NULL
, m_Cell
= NULL
; }
344 wxHtmlLinkInfo(const wxString
& href
, const wxString
& target
= wxEmptyString
) : wxObject()
345 { m_Href
= href
; m_Target
= target
; m_Event
= NULL
, m_Cell
= NULL
; }
346 wxHtmlLinkInfo(const wxHtmlLinkInfo
& l
) : wxObject()
347 { m_Href
= l
.m_Href
, m_Target
= l
.m_Target
, m_Event
= l
.m_Event
;
349 wxHtmlLinkInfo
& operator=(const wxHtmlLinkInfo
& l
)
350 { m_Href
= l
.m_Href
, m_Target
= l
.m_Target
, m_Event
= l
.m_Event
;
351 m_Cell
= l
.m_Cell
; return *this; }
353 void SetEvent(const wxMouseEvent
*e
) { m_Event
= e
; }
354 void SetHtmlCell(const wxHtmlCell
*e
) { m_Cell
= e
; }
356 wxString
GetHref() const { return m_Href
; }
357 wxString
GetTarget() const { return m_Target
; }
358 const wxMouseEvent
* GetEvent() const { return m_Event
; }
359 const wxHtmlCell
* GetHtmlCell() const { return m_Cell
; }
362 wxString m_Href
, m_Target
;
363 const wxMouseEvent
*m_Event
;
364 const wxHtmlCell
*m_Cell
;
372 #endif // _WX_HTMLCELL_H_