]> git.saurik.com Git - wxWidgets.git/blame_incremental - include/wx/html/htmlcell.h
Blind bug fix to bug reported by Angel Kry.
[wxWidgets.git] / include / wx / html / htmlcell.h
... / ...
CommitLineData
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
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