source: GTP/trunk/Lib/Illum/GPUObscurancesGT/Libraries/wx/include/wx/html/htmlcell.h @ 1648

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