]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: htmlcell.h | |
3 | // Purpose: wxHtmlCell class is used by wxHtmlWindow/wxHtmlWinParser | |
4 | // as a basic visual element of HTML page | |
5 | // Author: Vaclav Slavik | |
6 | // RCS-ID: $Id$ | |
7 | // Copyright: (c) 1999-2003 Vaclav Slavik | |
8 | // Licence: wxWindows licence | |
9 | ///////////////////////////////////////////////////////////////////////////// | |
10 | ||
11 | #ifndef _WX_HTMLCELL_H_ | |
12 | #define _WX_HTMLCELL_H_ | |
13 | ||
14 | #include "wx/defs.h" | |
15 | ||
16 | #if wxUSE_HTML | |
17 | ||
18 | #include "wx/html/htmltag.h" | |
19 | #include "wx/html/htmldefs.h" | |
20 | #include "wx/window.h" | |
21 | ||
22 | ||
23 | class WXDLLIMPEXP_FWD_HTML wxHtmlWindowInterface; | |
24 | class WXDLLIMPEXP_FWD_HTML wxHtmlLinkInfo; | |
25 | class WXDLLIMPEXP_FWD_HTML wxHtmlCell; | |
26 | class WXDLLIMPEXP_FWD_HTML wxHtmlContainerCell; | |
27 | ||
28 | ||
29 | // wxHtmlSelection is data holder with information about text selection. | |
30 | // Selection is defined by two positions (beginning and end of the selection) | |
31 | // and two leaf(!) cells at these positions. | |
32 | class WXDLLIMPEXP_HTML wxHtmlSelection | |
33 | { | |
34 | public: | |
35 | wxHtmlSelection() | |
36 | : m_fromPos(wxDefaultPosition), m_toPos(wxDefaultPosition), | |
37 | m_fromPrivPos(wxDefaultPosition), m_toPrivPos(wxDefaultPosition), | |
38 | m_fromCell(NULL), m_toCell(NULL) {} | |
39 | ||
40 | void Set(const wxPoint& fromPos, const wxHtmlCell *fromCell, | |
41 | const wxPoint& toPos, const wxHtmlCell *toCell); | |
42 | void Set(const wxHtmlCell *fromCell, const wxHtmlCell *toCell); | |
43 | ||
44 | const wxHtmlCell *GetFromCell() const { return m_fromCell; } | |
45 | const wxHtmlCell *GetToCell() const { return m_toCell; } | |
46 | ||
47 | // these values are in absolute coordinates: | |
48 | const wxPoint& GetFromPos() const { return m_fromPos; } | |
49 | const wxPoint& GetToPos() const { return m_toPos; } | |
50 | ||
51 | // these are From/ToCell's private data | |
52 | const wxPoint& GetFromPrivPos() const { return m_fromPrivPos; } | |
53 | const wxPoint& GetToPrivPos() const { return m_toPrivPos; } | |
54 | void SetFromPrivPos(const wxPoint& pos) { m_fromPrivPos = pos; } | |
55 | void SetToPrivPos(const wxPoint& pos) { m_toPrivPos = pos; } | |
56 | void ClearPrivPos() { m_toPrivPos = m_fromPrivPos = wxDefaultPosition; } | |
57 | ||
58 | bool IsEmpty() const | |
59 | { return m_fromPos == wxDefaultPosition && | |
60 | m_toPos == wxDefaultPosition; } | |
61 | ||
62 | private: | |
63 | wxPoint m_fromPos, m_toPos; | |
64 | wxPoint m_fromPrivPos, m_toPrivPos; | |
65 | const wxHtmlCell *m_fromCell, *m_toCell; | |
66 | }; | |
67 | ||
68 | ||
69 | ||
70 | enum wxHtmlSelectionState | |
71 | { | |
72 | wxHTML_SEL_OUT, // currently rendered cell is outside the selection | |
73 | wxHTML_SEL_IN, // ... is inside selection | |
74 | wxHTML_SEL_CHANGING // ... is the cell on which selection state changes | |
75 | }; | |
76 | ||
77 | // Selection state is passed to wxHtmlCell::Draw so that it can render itself | |
78 | // differently e.g. when inside text selection or outside it. | |
79 | class WXDLLIMPEXP_HTML wxHtmlRenderingState | |
80 | { | |
81 | public: | |
82 | wxHtmlRenderingState() : m_selState(wxHTML_SEL_OUT) {} | |
83 | ||
84 | void SetSelectionState(wxHtmlSelectionState s) { m_selState = s; } | |
85 | wxHtmlSelectionState GetSelectionState() const { return m_selState; } | |
86 | ||
87 | void SetFgColour(const wxColour& c) { m_fgColour = c; } | |
88 | const wxColour& GetFgColour() const { return m_fgColour; } | |
89 | void SetBgColour(const wxColour& c) { m_bgColour = c; } | |
90 | const wxColour& GetBgColour() const { return m_bgColour; } | |
91 | ||
92 | private: | |
93 | wxHtmlSelectionState m_selState; | |
94 | wxColour m_fgColour, m_bgColour; | |
95 | }; | |
96 | ||
97 | ||
98 | // HTML rendering customization. This class is used when rendering wxHtmlCells | |
99 | // as a callback: | |
100 | class WXDLLIMPEXP_HTML wxHtmlRenderingStyle | |
101 | { | |
102 | public: | |
103 | virtual ~wxHtmlRenderingStyle() {} | |
104 | virtual wxColour GetSelectedTextColour(const wxColour& clr) = 0; | |
105 | virtual wxColour GetSelectedTextBgColour(const wxColour& clr) = 0; | |
106 | }; | |
107 | ||
108 | // Standard style: | |
109 | class WXDLLIMPEXP_HTML wxDefaultHtmlRenderingStyle : public wxHtmlRenderingStyle | |
110 | { | |
111 | public: | |
112 | virtual wxColour GetSelectedTextColour(const wxColour& clr); | |
113 | virtual wxColour GetSelectedTextBgColour(const wxColour& clr); | |
114 | }; | |
115 | ||
116 | ||
117 | // Information given to cells when drawing them. Contains rendering state, | |
118 | // selection information and rendering style object that can be used to | |
119 | // customize the output. | |
120 | class WXDLLIMPEXP_HTML wxHtmlRenderingInfo | |
121 | { | |
122 | public: | |
123 | wxHtmlRenderingInfo() : m_selection(NULL), m_style(NULL) {} | |
124 | ||
125 | void SetSelection(wxHtmlSelection *s) { m_selection = s; } | |
126 | wxHtmlSelection *GetSelection() const { return m_selection; } | |
127 | ||
128 | void SetStyle(wxHtmlRenderingStyle *style) { m_style = style; } | |
129 | wxHtmlRenderingStyle& GetStyle() { return *m_style; } | |
130 | ||
131 | wxHtmlRenderingState& GetState() { return m_state; } | |
132 | ||
133 | protected: | |
134 | wxHtmlSelection *m_selection; | |
135 | wxHtmlRenderingStyle *m_style; | |
136 | wxHtmlRenderingState m_state; | |
137 | }; | |
138 | ||
139 | ||
140 | // Flags for wxHtmlCell::FindCellByPos | |
141 | enum | |
142 | { | |
143 | wxHTML_FIND_EXACT = 1, | |
144 | wxHTML_FIND_NEAREST_BEFORE = 2, | |
145 | wxHTML_FIND_NEAREST_AFTER = 4 | |
146 | }; | |
147 | ||
148 | ||
149 | // Superscript/subscript/normal script mode of a cell | |
150 | enum wxHtmlScriptMode | |
151 | { | |
152 | wxHTML_SCRIPT_NORMAL, | |
153 | wxHTML_SCRIPT_SUB, | |
154 | wxHTML_SCRIPT_SUP | |
155 | }; | |
156 | ||
157 | ||
158 | // --------------------------------------------------------------------------- | |
159 | // wxHtmlCell | |
160 | // Internal data structure. It represents fragments of parsed | |
161 | // HTML page - a word, picture, table, horizontal line and so | |
162 | // on. It is used by wxHtmlWindow to represent HTML page in | |
163 | // memory. | |
164 | // --------------------------------------------------------------------------- | |
165 | ||
166 | ||
167 | class WXDLLIMPEXP_HTML wxHtmlCell : public wxObject | |
168 | { | |
169 | public: | |
170 | wxHtmlCell(); | |
171 | virtual ~wxHtmlCell(); | |
172 | ||
173 | void SetParent(wxHtmlContainerCell *p) {m_Parent = p;} | |
174 | wxHtmlContainerCell *GetParent() const {return m_Parent;} | |
175 | ||
176 | int GetPosX() const {return m_PosX;} | |
177 | int GetPosY() const {return m_PosY;} | |
178 | int GetWidth() const {return m_Width;} | |
179 | ||
180 | // Returns the maximum possible length of the cell. | |
181 | // Call Layout at least once before using GetMaxTotalWidth() | |
182 | virtual int GetMaxTotalWidth() const { return m_Width; } | |
183 | ||
184 | int GetHeight() const {return m_Height;} | |
185 | int GetDescent() const {return m_Descent;} | |
186 | ||
187 | void SetScriptMode(wxHtmlScriptMode mode, long previousBase); | |
188 | wxHtmlScriptMode GetScriptMode() const { return m_ScriptMode; } | |
189 | long GetScriptBaseline() { return m_ScriptBaseline; } | |
190 | ||
191 | // Formatting cells are not visible on the screen, they only alter | |
192 | // renderer's state. | |
193 | bool IsFormattingCell() const { return m_Width == 0 && m_Height == 0; } | |
194 | ||
195 | const wxString& GetId() const { return m_id; } | |
196 | void SetId(const wxString& id) { m_id = id; } | |
197 | ||
198 | // returns the link associated with this cell. The position is position | |
199 | // within the cell so it varies from 0 to m_Width, from 0 to m_Height | |
200 | virtual wxHtmlLinkInfo* GetLink(int WXUNUSED(x) = 0, | |
201 | int WXUNUSED(y) = 0) const | |
202 | { return m_Link; } | |
203 | ||
204 | // Returns cursor to be used when mouse is over the cell: | |
205 | virtual wxCursor GetMouseCursor(wxHtmlWindowInterface *window) const; | |
206 | ||
207 | #if WXWIN_COMPATIBILITY_2_6 | |
208 | // this was replaced by GetMouseCursor, don't use in new code! | |
209 | virtual wxCursor GetCursor() const; | |
210 | #endif | |
211 | ||
212 | // return next cell among parent's cells | |
213 | wxHtmlCell *GetNext() const {return m_Next;} | |
214 | // returns first child cell (if there are any, i.e. if this is container): | |
215 | virtual wxHtmlCell* GetFirstChild() const { return NULL; } | |
216 | ||
217 | // members writing methods | |
218 | virtual void SetPos(int x, int y) {m_PosX = x, m_PosY = y;} | |
219 | void SetLink(const wxHtmlLinkInfo& link); | |
220 | void SetNext(wxHtmlCell *cell) {m_Next = cell;} | |
221 | ||
222 | // 1. adjust cell's width according to the fact that maximal possible width | |
223 | // is w. (this has sense when working with horizontal lines, tables | |
224 | // etc.) | |
225 | // 2. prepare layout (=fill-in m_PosX, m_PosY (and sometime m_Height) | |
226 | // members) = place items to fit window, according to the width w | |
227 | virtual void Layout(int w); | |
228 | ||
229 | // renders the cell | |
230 | virtual void Draw(wxDC& WXUNUSED(dc), | |
231 | int WXUNUSED(x), int WXUNUSED(y), | |
232 | int WXUNUSED(view_y1), int WXUNUSED(view_y2), | |
233 | wxHtmlRenderingInfo& WXUNUSED(info)) {} | |
234 | ||
235 | // proceed drawing actions in case the cell is not visible (scrolled out of | |
236 | // screen). This is needed to change fonts, colors and so on. | |
237 | virtual void DrawInvisible(wxDC& WXUNUSED(dc), | |
238 | int WXUNUSED(x), int WXUNUSED(y), | |
239 | wxHtmlRenderingInfo& WXUNUSED(info)) {} | |
240 | ||
241 | // This method returns pointer to the FIRST cell for that | |
242 | // the condition | |
243 | // is true. It first checks if the condition is true for this | |
244 | // cell and then calls m_Next->Find(). (Note: it checks | |
245 | // all subcells if the cell is container) | |
246 | // Condition is unique condition identifier (see htmldefs.h) | |
247 | // (user-defined condition IDs should start from 10000) | |
248 | // and param is optional parameter | |
249 | // Example : m_Cell->Find(wxHTML_COND_ISANCHOR, "news"); | |
250 | // returns pointer to anchor news | |
251 | virtual const wxHtmlCell* Find(int condition, const void* param) const; | |
252 | ||
253 | ||
254 | // This function is called when mouse button is clicked over the cell. | |
255 | // Returns true if a link is clicked, false otherwise. | |
256 | // | |
257 | // 'window' is pointer to wxHtmlWindowInterface of the window which | |
258 | // generated the event. | |
259 | // HINT: if this handling is not enough for you you should use | |
260 | // wxHtmlWidgetCell | |
261 | virtual bool ProcessMouseClick(wxHtmlWindowInterface *window, | |
262 | const wxPoint& pos, | |
263 | const wxMouseEvent& event); | |
264 | ||
265 | #if WXWIN_COMPATIBILITY_2_6 | |
266 | // this was replaced by ProcessMouseClick, don't use in new code! | |
267 | virtual void OnMouseClick(wxWindow *window, | |
268 | int x, int y, const wxMouseEvent& event); | |
269 | #endif | |
270 | ||
271 | // This method used to adjust pagebreak position. The parameter is variable | |
272 | // that contains y-coordinate of page break (= horizontal line that should | |
273 | // not be crossed by words, images etc.). If this cell cannot be divided | |
274 | // into two pieces (each one on another page) then it moves the pagebreak | |
275 | // few pixels up. | |
276 | // | |
277 | // Returned value : true if pagebreak was modified, false otherwise | |
278 | // Usage : while (container->AdjustPagebreak(&p)) {} | |
279 | virtual bool AdjustPagebreak(int *pagebreak, | |
280 | wxArrayInt& known_pagebreaks) const; | |
281 | ||
282 | // Sets cell's behaviour on pagebreaks (see AdjustPagebreak). Default | |
283 | // is true - the cell can be split on two pages | |
284 | void SetCanLiveOnPagebreak(bool can) { m_CanLiveOnPagebreak = can; } | |
285 | ||
286 | // Can the line be broken before this cell? | |
287 | virtual bool IsLinebreakAllowed() const | |
288 | { return !IsFormattingCell(); } | |
289 | ||
290 | // Returns true for simple == terminal cells, i.e. not composite ones. | |
291 | // This if for internal usage only and may disappear in future versions! | |
292 | virtual bool IsTerminalCell() const { return true; } | |
293 | ||
294 | // Find a cell inside this cell positioned at the given coordinates | |
295 | // (relative to this's positions). Returns NULL if no such cell exists. | |
296 | // The flag can be used to specify whether to look for terminal or | |
297 | // nonterminal cells or both. In either case, returned cell is deepest | |
298 | // cell in cells tree that contains [x,y]. | |
299 | virtual wxHtmlCell *FindCellByPos(wxCoord x, wxCoord y, | |
300 | unsigned flags = wxHTML_FIND_EXACT) const; | |
301 | ||
302 | // Returns absolute position of the cell on HTML canvas. | |
303 | // If rootCell is provided, then it's considered to be the root of the | |
304 | // hierarchy and the returned value is relative to it. | |
305 | wxPoint GetAbsPos(wxHtmlCell *rootCell = NULL) const; | |
306 | ||
307 | // Returns root cell of the hierarchy (i.e. grand-grand-...-parent that | |
308 | // doesn't have a parent itself) | |
309 | wxHtmlCell *GetRootCell() const; | |
310 | ||
311 | // Returns first (last) terminal cell inside this cell. It may return NULL, | |
312 | // but it is rare -- only if there are no terminals in the tree. | |
313 | virtual wxHtmlCell *GetFirstTerminal() const | |
314 | { return wxConstCast(this, wxHtmlCell); } | |
315 | virtual wxHtmlCell *GetLastTerminal() const | |
316 | { return wxConstCast(this, wxHtmlCell); } | |
317 | ||
318 | // Returns cell's depth, i.e. how far under the root cell it is | |
319 | // (if it is the root, depth is 0) | |
320 | unsigned GetDepth() const; | |
321 | ||
322 | // Returns true if the cell appears before 'cell' in natural order of | |
323 | // cells (= as they are read). If cell A is (grand)parent of cell B, | |
324 | // then both A.IsBefore(B) and B.IsBefore(A) always return true. | |
325 | bool IsBefore(wxHtmlCell *cell) const; | |
326 | ||
327 | // Converts the cell into text representation. If sel != NULL then | |
328 | // only part of the cell inside the selection is converted. | |
329 | virtual wxString ConvertToText(wxHtmlSelection *WXUNUSED(sel)) const | |
330 | { return wxEmptyString; } | |
331 | ||
332 | protected: | |
333 | // pointer to the next cell | |
334 | wxHtmlCell *m_Next; | |
335 | // pointer to parent cell | |
336 | wxHtmlContainerCell *m_Parent; | |
337 | ||
338 | // dimensions of fragment (m_Descent is used to position text & images) | |
339 | long m_Width, m_Height, m_Descent; | |
340 | // position where the fragment is drawn: | |
341 | long m_PosX, m_PosY; | |
342 | ||
343 | // superscript/subscript/normal: | |
344 | wxHtmlScriptMode m_ScriptMode; | |
345 | long m_ScriptBaseline; | |
346 | ||
347 | // destination address if this fragment is hypertext link, NULL otherwise | |
348 | wxHtmlLinkInfo *m_Link; | |
349 | // true if this cell can be placed on pagebreak, false otherwise | |
350 | bool m_CanLiveOnPagebreak; | |
351 | // unique identifier of the cell, generated from "id" property of tags | |
352 | wxString m_id; | |
353 | ||
354 | DECLARE_ABSTRACT_CLASS(wxHtmlCell) | |
355 | wxDECLARE_NO_COPY_CLASS(wxHtmlCell); | |
356 | }; | |
357 | ||
358 | ||
359 | ||
360 | ||
361 | // ---------------------------------------------------------------------------- | |
362 | // Inherited cells: | |
363 | // ---------------------------------------------------------------------------- | |
364 | ||
365 | ||
366 | // ---------------------------------------------------------------------------- | |
367 | // wxHtmlWordCell | |
368 | // Single word in input stream. | |
369 | // ---------------------------------------------------------------------------- | |
370 | ||
371 | class WXDLLIMPEXP_HTML wxHtmlWordCell : public wxHtmlCell | |
372 | { | |
373 | public: | |
374 | wxHtmlWordCell(const wxString& word, const wxDC& dc); | |
375 | void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2, | |
376 | wxHtmlRenderingInfo& info); | |
377 | virtual wxCursor GetMouseCursor(wxHtmlWindowInterface *window) const; | |
378 | virtual wxString ConvertToText(wxHtmlSelection *sel) const; | |
379 | bool IsLinebreakAllowed() const { return m_allowLinebreak; } | |
380 | ||
381 | void SetPreviousWord(wxHtmlWordCell *cell); | |
382 | ||
383 | protected: | |
384 | virtual wxString GetAllAsText() const | |
385 | { return m_Word; } | |
386 | virtual wxString GetPartAsText(int begin, int end) const | |
387 | { return m_Word.Mid(begin, end - begin); } | |
388 | ||
389 | void SetSelectionPrivPos(const wxDC& dc, wxHtmlSelection *s) const; | |
390 | void Split(const wxDC& dc, | |
391 | const wxPoint& selFrom, const wxPoint& selTo, | |
392 | unsigned& pos1, unsigned& pos2) const; | |
393 | ||
394 | wxString m_Word; | |
395 | bool m_allowLinebreak; | |
396 | ||
397 | DECLARE_ABSTRACT_CLASS(wxHtmlWordCell) | |
398 | wxDECLARE_NO_COPY_CLASS(wxHtmlWordCell); | |
399 | }; | |
400 | ||
401 | ||
402 | // wxHtmlWordCell specialization for storing text fragments with embedded | |
403 | // '\t's; these differ from normal words in that the displayed text is | |
404 | // different from the text copied to clipboard | |
405 | class WXDLLIMPEXP_HTML wxHtmlWordWithTabsCell : public wxHtmlWordCell | |
406 | { | |
407 | public: | |
408 | wxHtmlWordWithTabsCell(const wxString& word, | |
409 | const wxString& wordOrig, | |
410 | size_t linepos, | |
411 | const wxDC& dc) | |
412 | : wxHtmlWordCell(word, dc), | |
413 | m_wordOrig(wordOrig), | |
414 | m_linepos(linepos) | |
415 | {} | |
416 | ||
417 | protected: | |
418 | virtual wxString GetAllAsText() const; | |
419 | virtual wxString GetPartAsText(int begin, int end) const; | |
420 | ||
421 | wxString m_wordOrig; | |
422 | size_t m_linepos; | |
423 | }; | |
424 | ||
425 | ||
426 | // Container contains other cells, thus forming tree structure of rendering | |
427 | // elements. Basic code of layout algorithm is contained in this class. | |
428 | class WXDLLIMPEXP_HTML wxHtmlContainerCell : public wxHtmlCell | |
429 | { | |
430 | public: | |
431 | wxHtmlContainerCell(wxHtmlContainerCell *parent); | |
432 | virtual ~wxHtmlContainerCell(); | |
433 | ||
434 | virtual void Layout(int w); | |
435 | virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2, | |
436 | wxHtmlRenderingInfo& info); | |
437 | virtual void DrawInvisible(wxDC& dc, int x, int y, | |
438 | wxHtmlRenderingInfo& info); | |
439 | /* virtual bool AdjustPagebreak(int *pagebreak, int *known_pagebreaks = NULL, int number_of_pages = 0) const;*/ | |
440 | virtual bool AdjustPagebreak(int *pagebreak, wxArrayInt& known_pagebreaks) const; | |
441 | ||
442 | // insert cell at the end of m_Cells list | |
443 | void InsertCell(wxHtmlCell *cell); | |
444 | ||
445 | // sets horizontal/vertical alignment | |
446 | void SetAlignHor(int al) {m_AlignHor = al; m_LastLayout = -1;} | |
447 | int GetAlignHor() const {return m_AlignHor;} | |
448 | void SetAlignVer(int al) {m_AlignVer = al; m_LastLayout = -1;} | |
449 | int GetAlignVer() const {return m_AlignVer;} | |
450 | ||
451 | // sets left-border indentation. units is one of wxHTML_UNITS_* constants | |
452 | // what is combination of wxHTML_INDENT_* | |
453 | void SetIndent(int i, int what, int units = wxHTML_UNITS_PIXELS); | |
454 | // returns the indentation. ind is one of wxHTML_INDENT_* constants | |
455 | int GetIndent(int ind) const; | |
456 | // returns type of value returned by GetIndent(ind) | |
457 | int GetIndentUnits(int ind) const; | |
458 | ||
459 | // sets alignment info based on given tag's params | |
460 | void SetAlign(const wxHtmlTag& tag); | |
461 | // sets floating width adjustment | |
462 | // (examples : 32 percent of parent container, | |
463 | // -15 pixels percent (this means 100 % - 15 pixels) | |
464 | void SetWidthFloat(int w, int units) {m_WidthFloat = w; m_WidthFloatUnits = units; m_LastLayout = -1;} | |
465 | void SetWidthFloat(const wxHtmlTag& tag, double pixel_scale = 1.0); | |
466 | // sets minimal height of this container. | |
467 | void SetMinHeight(int h, int align = wxHTML_ALIGN_TOP) {m_MinHeight = h; m_MinHeightAlign = align; m_LastLayout = -1;} | |
468 | ||
469 | void SetBackgroundColour(const wxColour& clr) {m_UseBkColour = true; m_BkColour = clr;} | |
470 | // returns background colour (of wxNullColour if none set), so that widgets can | |
471 | // adapt to it: | |
472 | wxColour GetBackgroundColour(); | |
473 | void SetBorder(const wxColour& clr1, const wxColour& clr2, int border = 1) {m_Border = border; m_BorderColour1 = clr1, m_BorderColour2 = clr2;} | |
474 | virtual wxHtmlLinkInfo* GetLink(int x = 0, int y = 0) const; | |
475 | virtual const wxHtmlCell* Find(int condition, const void* param) const; | |
476 | ||
477 | #if WXWIN_COMPATIBILITY_2_6 | |
478 | // this was replaced by ProcessMouseClick, don't use in new code! | |
479 | virtual void OnMouseClick(wxWindow *window, | |
480 | int x, int y, const wxMouseEvent& event); | |
481 | #endif | |
482 | virtual bool ProcessMouseClick(wxHtmlWindowInterface *window, | |
483 | const wxPoint& pos, | |
484 | const wxMouseEvent& event); | |
485 | ||
486 | virtual wxHtmlCell* GetFirstChild() const { return m_Cells; } | |
487 | ||
488 | // returns last child cell: | |
489 | wxHtmlCell* GetLastChild() const { return m_LastCell; } | |
490 | ||
491 | // see comment in wxHtmlCell about this method | |
492 | virtual bool IsTerminalCell() const { return false; } | |
493 | ||
494 | virtual wxHtmlCell *FindCellByPos(wxCoord x, wxCoord y, | |
495 | unsigned flags = wxHTML_FIND_EXACT) const; | |
496 | ||
497 | virtual wxHtmlCell *GetFirstTerminal() const; | |
498 | virtual wxHtmlCell *GetLastTerminal() const; | |
499 | ||
500 | ||
501 | // Removes indentation on top or bottom of the container (i.e. above or | |
502 | // below first/last terminal cell). For internal use only. | |
503 | virtual void RemoveExtraSpacing(bool top, bool bottom); | |
504 | ||
505 | // Returns the maximum possible length of the container. | |
506 | // Call Layout at least once before using GetMaxTotalWidth() | |
507 | virtual int GetMaxTotalWidth() const { return m_MaxTotalWidth; } | |
508 | ||
509 | protected: | |
510 | void UpdateRenderingStatePre(wxHtmlRenderingInfo& info, | |
511 | wxHtmlCell *cell) const; | |
512 | void UpdateRenderingStatePost(wxHtmlRenderingInfo& info, | |
513 | wxHtmlCell *cell) const; | |
514 | ||
515 | protected: | |
516 | int m_IndentLeft, m_IndentRight, m_IndentTop, m_IndentBottom; | |
517 | // indentation of subcells. There is always m_Indent pixels | |
518 | // big space between given border of the container and the subcells | |
519 | // it m_Indent < 0 it is in PERCENTS, otherwise it is in pixels | |
520 | int m_MinHeight, m_MinHeightAlign; | |
521 | // minimal height. | |
522 | wxHtmlCell *m_Cells, *m_LastCell; | |
523 | // internal cells, m_Cells points to the first of them, m_LastCell to the last one. | |
524 | // (LastCell is needed only to speed-up InsertCell) | |
525 | int m_AlignHor, m_AlignVer; | |
526 | // alignment horizontal and vertical (left, center, right) | |
527 | int m_WidthFloat, m_WidthFloatUnits; | |
528 | // width float is used in adjustWidth | |
529 | bool m_UseBkColour; | |
530 | wxColour m_BkColour; | |
531 | // background color of this container | |
532 | int m_Border; | |
533 | // border size. Draw only if m_Border > 0 | |
534 | wxColour m_BorderColour1, m_BorderColour2; | |
535 | // borders color of this container | |
536 | int m_LastLayout; | |
537 | // if != -1 then call to Layout may be no-op | |
538 | // if previous call to Layout has same argument | |
539 | int m_MaxTotalWidth; | |
540 | // Maximum possible length if ignoring line wrap | |
541 | ||
542 | ||
543 | DECLARE_ABSTRACT_CLASS(wxHtmlContainerCell) | |
544 | wxDECLARE_NO_COPY_CLASS(wxHtmlContainerCell); | |
545 | }; | |
546 | ||
547 | ||
548 | ||
549 | // --------------------------------------------------------------------------- | |
550 | // wxHtmlColourCell | |
551 | // Color changer. | |
552 | // --------------------------------------------------------------------------- | |
553 | ||
554 | class WXDLLIMPEXP_HTML wxHtmlColourCell : public wxHtmlCell | |
555 | { | |
556 | public: | |
557 | wxHtmlColourCell(const wxColour& clr, int flags = wxHTML_CLR_FOREGROUND) : wxHtmlCell() {m_Colour = clr; m_Flags = flags;} | |
558 | virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2, | |
559 | wxHtmlRenderingInfo& info); | |
560 | virtual void DrawInvisible(wxDC& dc, int x, int y, | |
561 | wxHtmlRenderingInfo& info); | |
562 | ||
563 | protected: | |
564 | wxColour m_Colour; | |
565 | unsigned m_Flags; | |
566 | ||
567 | DECLARE_ABSTRACT_CLASS(wxHtmlColourCell) | |
568 | wxDECLARE_NO_COPY_CLASS(wxHtmlColourCell); | |
569 | }; | |
570 | ||
571 | ||
572 | ||
573 | ||
574 | //-------------------------------------------------------------------------------- | |
575 | // wxHtmlFontCell | |
576 | // Sets actual font used for text rendering | |
577 | //-------------------------------------------------------------------------------- | |
578 | ||
579 | class WXDLLIMPEXP_HTML wxHtmlFontCell : public wxHtmlCell | |
580 | { | |
581 | public: | |
582 | wxHtmlFontCell(wxFont *font) : wxHtmlCell() { m_Font = (*font); } | |
583 | virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2, | |
584 | wxHtmlRenderingInfo& info); | |
585 | virtual void DrawInvisible(wxDC& dc, int x, int y, | |
586 | wxHtmlRenderingInfo& info); | |
587 | ||
588 | protected: | |
589 | wxFont m_Font; | |
590 | ||
591 | DECLARE_ABSTRACT_CLASS(wxHtmlFontCell) | |
592 | wxDECLARE_NO_COPY_CLASS(wxHtmlFontCell); | |
593 | }; | |
594 | ||
595 | ||
596 | ||
597 | ||
598 | ||
599 | ||
600 | //-------------------------------------------------------------------------------- | |
601 | // wxHtmlwidgetCell | |
602 | // This cell is connected with wxWindow object | |
603 | // You can use it to insert windows into HTML page | |
604 | // (buttons, input boxes etc.) | |
605 | //-------------------------------------------------------------------------------- | |
606 | ||
607 | class WXDLLIMPEXP_HTML wxHtmlWidgetCell : public wxHtmlCell | |
608 | { | |
609 | public: | |
610 | // !!! wnd must have correct parent! | |
611 | // if w != 0 then the m_Wnd has 'floating' width - it adjust | |
612 | // it's width according to parent container's width | |
613 | // (w is percent of parent's width) | |
614 | wxHtmlWidgetCell(wxWindow *wnd, int w = 0); | |
615 | virtual ~wxHtmlWidgetCell() { m_Wnd->Destroy(); } | |
616 | virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2, | |
617 | wxHtmlRenderingInfo& info); | |
618 | virtual void DrawInvisible(wxDC& dc, int x, int y, | |
619 | wxHtmlRenderingInfo& info); | |
620 | virtual void Layout(int w); | |
621 | ||
622 | protected: | |
623 | wxWindow* m_Wnd; | |
624 | int m_WidthFloat; | |
625 | // width float is used in adjustWidth (it is in percents) | |
626 | ||
627 | DECLARE_ABSTRACT_CLASS(wxHtmlWidgetCell) | |
628 | wxDECLARE_NO_COPY_CLASS(wxHtmlWidgetCell); | |
629 | }; | |
630 | ||
631 | ||
632 | ||
633 | //-------------------------------------------------------------------------------- | |
634 | // wxHtmlLinkInfo | |
635 | // Internal data structure. It represents hypertext link | |
636 | //-------------------------------------------------------------------------------- | |
637 | ||
638 | class WXDLLIMPEXP_HTML wxHtmlLinkInfo : public wxObject | |
639 | { | |
640 | public: | |
641 | wxHtmlLinkInfo() : wxObject() | |
642 | { m_Href = m_Target = wxEmptyString; m_Event = NULL, m_Cell = NULL; } | |
643 | wxHtmlLinkInfo(const wxString& href, const wxString& target = wxEmptyString) : wxObject() | |
644 | { m_Href = href; m_Target = target; m_Event = NULL, m_Cell = NULL; } | |
645 | wxHtmlLinkInfo(const wxHtmlLinkInfo& l) : wxObject() | |
646 | { m_Href = l.m_Href, m_Target = l.m_Target, m_Event = l.m_Event; | |
647 | m_Cell = l.m_Cell; } | |
648 | wxHtmlLinkInfo& operator=(const wxHtmlLinkInfo& l) | |
649 | { m_Href = l.m_Href, m_Target = l.m_Target, m_Event = l.m_Event; | |
650 | m_Cell = l.m_Cell; return *this; } | |
651 | ||
652 | void SetEvent(const wxMouseEvent *e) { m_Event = e; } | |
653 | void SetHtmlCell(const wxHtmlCell *e) { m_Cell = e; } | |
654 | ||
655 | wxString GetHref() const { return m_Href; } | |
656 | wxString GetTarget() const { return m_Target; } | |
657 | const wxMouseEvent* GetEvent() const { return m_Event; } | |
658 | const wxHtmlCell* GetHtmlCell() const { return m_Cell; } | |
659 | ||
660 | private: | |
661 | wxString m_Href, m_Target; | |
662 | const wxMouseEvent *m_Event; | |
663 | const wxHtmlCell *m_Cell; | |
664 | }; | |
665 | ||
666 | ||
667 | ||
668 | // ---------------------------------------------------------------------------- | |
669 | // wxHtmlTerminalCellsInterator | |
670 | // ---------------------------------------------------------------------------- | |
671 | ||
672 | class WXDLLIMPEXP_HTML wxHtmlTerminalCellsInterator | |
673 | { | |
674 | public: | |
675 | wxHtmlTerminalCellsInterator(const wxHtmlCell *from, const wxHtmlCell *to) | |
676 | : m_to(to), m_pos(from) {} | |
677 | ||
678 | operator bool() const { return m_pos != NULL; } | |
679 | const wxHtmlCell* operator++(); | |
680 | const wxHtmlCell* operator->() const { return m_pos; } | |
681 | const wxHtmlCell* operator*() const { return m_pos; } | |
682 | ||
683 | private: | |
684 | const wxHtmlCell *m_to, *m_pos; | |
685 | }; | |
686 | ||
687 | ||
688 | ||
689 | #endif // wxUSE_HTML | |
690 | ||
691 | #endif // _WX_HTMLCELL_H_ | |
692 |