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