| 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 Vaclav Slavik |
| 8 | // Licence: wxWindows Licence |
| 9 | ///////////////////////////////////////////////////////////////////////////// |
| 10 | |
| 11 | |
| 12 | #ifndef _WX_HTMLCELL_H_ |
| 13 | #define _WX_HTMLCELL_H_ |
| 14 | |
| 15 | #ifdef __GNUG__ |
| 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 | |
| 28 | class WXDLLEXPORT wxHtmlLinkInfo; |
| 29 | class WXDLLEXPORT wxHtmlCell; |
| 30 | class WXDLLEXPORT wxHtmlContainerCell; |
| 31 | |
| 32 | //-------------------------------------------------------------------------------- |
| 33 | // wxHtmlCell |
| 34 | // Internal data structure. It represents fragments of parsed HTML |
| 35 | // page - a word, picture, table, horizontal line and so on. |
| 36 | // It is used by wxHtmlWindow to represent HTML page in memory. |
| 37 | //-------------------------------------------------------------------------------- |
| 38 | |
| 39 | |
| 40 | class WXDLLEXPORT wxHtmlCell : public wxObject |
| 41 | { |
| 42 | public: |
| 43 | wxHtmlCell(); |
| 44 | virtual ~wxHtmlCell(); |
| 45 | |
| 46 | void SetParent(wxHtmlContainerCell *p) {m_Parent = p;} |
| 47 | wxHtmlContainerCell *GetParent() const {return m_Parent;} |
| 48 | |
| 49 | int GetPosX() const {return m_PosX;} |
| 50 | int GetPosY() const {return m_PosY;} |
| 51 | int GetWidth() const {return m_Width;} |
| 52 | int GetHeight() const {return m_Height;} |
| 53 | int GetDescent() const {return m_Descent;} |
| 54 | |
| 55 | const wxString& GetId() const { return m_id; } |
| 56 | void SetId(const wxString& id) { m_id = id; } |
| 57 | |
| 58 | // returns the link associated with this cell. The position is position within |
| 59 | // the cell so it varies from 0 to m_Width, from 0 to m_Height |
| 60 | virtual wxHtmlLinkInfo* GetLink(int WXUNUSED(x) = 0, int WXUNUSED(y) = 0) const |
| 61 | { return m_Link; } |
| 62 | |
| 63 | // members access methods |
| 64 | wxHtmlCell *GetNext() const {return m_Next;} |
| 65 | |
| 66 | // members writing methods |
| 67 | virtual void SetPos(int x, int y) {m_PosX = x, m_PosY = y;} |
| 68 | void SetLink(const wxHtmlLinkInfo& link); |
| 69 | void SetNext(wxHtmlCell *cell) {m_Next = cell;} |
| 70 | |
| 71 | // 1. adjust cell's width according to the fact that maximal possible width is w. |
| 72 | // (this has sense when working with horizontal lines, tables etc.) |
| 73 | // 2. prepare layout (=fill-in m_PosX, m_PosY (and sometime m_Height) members) |
| 74 | // = place items to fit window, according to the width w |
| 75 | virtual void Layout(int w); |
| 76 | |
| 77 | // renders the cell |
| 78 | virtual void Draw(wxDC& WXUNUSED(dc), int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(view_y1), int WXUNUSED(view_y2)) {} |
| 79 | |
| 80 | // proceed drawing actions in case the cell is not visible (scrolled out of screen). |
| 81 | // This is needed to change fonts, colors and so on |
| 82 | virtual void DrawInvisible(wxDC& WXUNUSED(dc), int WXUNUSED(x), int WXUNUSED(y)) {} |
| 83 | |
| 84 | // This method returns pointer to the FIRST cell for that |
| 85 | // the condition |
| 86 | // is true. It first checks if the condition is true for this |
| 87 | // cell and then calls m_Next->Find(). (Note: it checks |
| 88 | // all subcells if the cell is container) |
| 89 | // Condition is unique condition identifier (see htmldefs.h) |
| 90 | // (user-defined condition IDs should start from 10000) |
| 91 | // and param is optional parameter |
| 92 | // Example : m_Cell->Find(wxHTML_COND_ISANCHOR, "news"); |
| 93 | // returns pointer to anchor news |
| 94 | virtual const wxHtmlCell* Find(int condition, const void* param) const; |
| 95 | |
| 96 | // This function is called when mouse button is clicked over the cell. |
| 97 | // |
| 98 | // Parent is pointer to wxHtmlWindow that generated the event |
| 99 | // HINT: if this handling is not enough for you you should use |
| 100 | // wxHtmlWidgetCell |
| 101 | virtual void OnMouseClick(wxWindow *parent, int x, int y, const wxMouseEvent& event); |
| 102 | |
| 103 | // This method used to adjust pagebreak position. The parameter is |
| 104 | // variable that contains y-coordinate of page break (= horizontal line that |
| 105 | // should not be crossed by words, images etc.). If this cell cannot be divided |
| 106 | // into two pieces (each one on another page) then it moves the pagebreak |
| 107 | // few pixels up. |
| 108 | // |
| 109 | // Returned value : true if pagebreak was modified, false otherwise |
| 110 | // Usage : while (container->AdjustPagebreak(&p)) {} |
| 111 | virtual bool AdjustPagebreak(int *pagebreak) const; |
| 112 | |
| 113 | // Sets cell's behaviour on pagebreaks (see AdjustPagebreak). Default |
| 114 | // is true - the cell can be split on two pages |
| 115 | void SetCanLiveOnPagebreak(bool can) { m_CanLiveOnPagebreak = can; } |
| 116 | |
| 117 | // Returns y-coordinates that contraint the cell, i.e. left is highest |
| 118 | // and right lowest coordinate such that the cell lays between then. |
| 119 | // Note: this method does not return meaningful values if you haven't |
| 120 | // called Layout() before! |
| 121 | virtual void GetHorizontalConstraints(int *left, int *right) const; |
| 122 | |
| 123 | // Returns true for simple == terminal cells, i.e. not composite ones. |
| 124 | // This if for internal usage only and may disappear in future versions! |
| 125 | virtual bool IsTerminalCell() const { return TRUE; } |
| 126 | |
| 127 | // Find the terminal cell inside this cell at the given position (relative |
| 128 | // to this cell) |
| 129 | // |
| 130 | // Returns NULL if not found |
| 131 | virtual wxHtmlCell *FindCellByPos(wxCoord x, wxCoord y) const; |
| 132 | |
| 133 | protected: |
| 134 | wxHtmlCell *m_Next; |
| 135 | // pointer to the next cell |
| 136 | wxHtmlContainerCell *m_Parent; |
| 137 | // pointer to parent cell |
| 138 | long m_Width, m_Height, m_Descent; |
| 139 | // dimensions of fragment |
| 140 | // m_Descent is used to position text&images.. |
| 141 | long m_PosX, m_PosY; |
| 142 | // position where the fragment is drawn |
| 143 | wxHtmlLinkInfo *m_Link; |
| 144 | // destination address if this fragment is hypertext link, NULL otherwise |
| 145 | bool m_CanLiveOnPagebreak; |
| 146 | // true if this cell can be placed on pagebreak, false otherwise |
| 147 | wxString m_id; |
| 148 | // unique identifier of the cell, generated from "id" property of tags |
| 149 | }; |
| 150 | |
| 151 | |
| 152 | |
| 153 | |
| 154 | //-------------------------------------------------------------------------------- |
| 155 | // Inherited cells: |
| 156 | //-------------------------------------------------------------------------------- |
| 157 | |
| 158 | |
| 159 | //-------------------------------------------------------------------------------- |
| 160 | // wxHtmlWordCell |
| 161 | // Single word in input stream. |
| 162 | //-------------------------------------------------------------------------------- |
| 163 | |
| 164 | class WXDLLEXPORT wxHtmlWordCell : public wxHtmlCell |
| 165 | { |
| 166 | public: |
| 167 | wxHtmlWordCell(const wxString& word, wxDC& dc); |
| 168 | void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2); |
| 169 | |
| 170 | protected: |
| 171 | wxString m_Word; |
| 172 | }; |
| 173 | |
| 174 | |
| 175 | |
| 176 | |
| 177 | |
| 178 | //-------------------------------------------------------------------------------- |
| 179 | // wxHtmlContainerCell |
| 180 | // Container - it contains other cells. Basic of layout algorithm. |
| 181 | //-------------------------------------------------------------------------------- |
| 182 | |
| 183 | class WXDLLEXPORT wxHtmlContainerCell : public wxHtmlCell |
| 184 | { |
| 185 | public: |
| 186 | wxHtmlContainerCell(wxHtmlContainerCell *parent); |
| 187 | ~wxHtmlContainerCell(); |
| 188 | |
| 189 | virtual void Layout(int w); |
| 190 | virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2); |
| 191 | virtual void DrawInvisible(wxDC& dc, int x, int y); |
| 192 | virtual bool AdjustPagebreak(int *pagebreak) const; |
| 193 | |
| 194 | // insert cell at the end of m_Cells list |
| 195 | void InsertCell(wxHtmlCell *cell); |
| 196 | |
| 197 | // sets horizontal/vertical alignment |
| 198 | void SetAlignHor(int al) {m_AlignHor = al; m_LastLayout = -1;} |
| 199 | int GetAlignHor() const {return m_AlignHor;} |
| 200 | void SetAlignVer(int al) {m_AlignVer = al; m_LastLayout = -1;} |
| 201 | int GetAlignVer() const {return m_AlignVer;} |
| 202 | |
| 203 | // sets left-border indentation. units is one of wxHTML_UNITS_* constants |
| 204 | // what is combination of wxHTML_INDENT_* |
| 205 | void SetIndent(int i, int what, int units = wxHTML_UNITS_PIXELS); |
| 206 | // returns the indentation. ind is one of wxHTML_INDENT_* constants |
| 207 | int GetIndent(int ind) const; |
| 208 | // returns type of value returned by GetIndent(ind) |
| 209 | int GetIndentUnits(int ind) const; |
| 210 | |
| 211 | // sets alignment info based on given tag's params |
| 212 | void SetAlign(const wxHtmlTag& tag); |
| 213 | // sets floating width adjustment |
| 214 | // (examples : 32 percent of parent container, |
| 215 | // -15 pixels percent (this means 100 % - 15 pixels) |
| 216 | void SetWidthFloat(int w, int units) {m_WidthFloat = w; m_WidthFloatUnits = units; m_LastLayout = -1;} |
| 217 | void SetWidthFloat(const wxHtmlTag& tag, double pixel_scale = 1.0); |
| 218 | // sets minimal height of this container. |
| 219 | void SetMinHeight(int h, int align = wxHTML_ALIGN_TOP) {m_MinHeight = h; m_MinHeightAlign = align; m_LastLayout = -1;} |
| 220 | |
| 221 | void SetBackgroundColour(const wxColour& clr) {m_UseBkColour = TRUE; m_BkColour = clr;} |
| 222 | void SetBorder(const wxColour& clr1, const wxColour& clr2) {m_UseBorder = TRUE; m_BorderColour1 = clr1, m_BorderColour2 = clr2;} |
| 223 | virtual wxHtmlLinkInfo* GetLink(int x = 0, int y = 0) const; |
| 224 | virtual const wxHtmlCell* Find(int condition, const void* param) const; |
| 225 | virtual void OnMouseClick(wxWindow *parent, int x, int y, const wxMouseEvent& event); |
| 226 | virtual void GetHorizontalConstraints(int *left, int *right) const; |
| 227 | |
| 228 | // returns pointer to the first cell in container or NULL |
| 229 | wxHtmlCell* GetFirstCell() const {return m_Cells;} |
| 230 | |
| 231 | // see comment in wxHtmlCell about this method |
| 232 | virtual bool IsTerminalCell() const { return FALSE; } |
| 233 | |
| 234 | virtual wxHtmlCell *FindCellByPos(wxCoord x, wxCoord y) const; |
| 235 | |
| 236 | protected: |
| 237 | int m_IndentLeft, m_IndentRight, m_IndentTop, m_IndentBottom; |
| 238 | // indentation of subcells. There is always m_Indent pixels |
| 239 | // big space between given border of the container and the subcells |
| 240 | // it m_Indent < 0 it is in PERCENTS, otherwise it is in pixels |
| 241 | int m_MinHeight, m_MinHeightAlign; |
| 242 | // minimal height. |
| 243 | wxHtmlCell *m_Cells, *m_LastCell; |
| 244 | // internal cells, m_Cells points to the first of them, m_LastCell to the last one. |
| 245 | // (LastCell is needed only to speed-up InsertCell) |
| 246 | int m_AlignHor, m_AlignVer; |
| 247 | // alignment horizontal and vertical (left, center, right) |
| 248 | int m_WidthFloat, m_WidthFloatUnits; |
| 249 | // width float is used in adjustWidth |
| 250 | bool m_UseBkColour; |
| 251 | wxColour m_BkColour; |
| 252 | // background color of this container |
| 253 | bool m_UseBorder; |
| 254 | wxColour m_BorderColour1, m_BorderColour2; |
| 255 | // borders color of this container |
| 256 | int m_LastLayout; |
| 257 | // if != -1 then call to Layout may be no-op |
| 258 | // if previous call to Layout has same argument |
| 259 | }; |
| 260 | |
| 261 | |
| 262 | |
| 263 | |
| 264 | |
| 265 | //-------------------------------------------------------------------------------- |
| 266 | // wxHtmlColourCell |
| 267 | // Color changer. |
| 268 | //-------------------------------------------------------------------------------- |
| 269 | |
| 270 | class WXDLLEXPORT wxHtmlColourCell : public wxHtmlCell |
| 271 | { |
| 272 | public: |
| 273 | wxHtmlColourCell(const wxColour& clr, int flags = wxHTML_CLR_FOREGROUND) : wxHtmlCell() {m_Colour = clr; m_Flags = flags;} |
| 274 | virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2); |
| 275 | virtual void DrawInvisible(wxDC& dc, int x, int y); |
| 276 | |
| 277 | protected: |
| 278 | wxColour m_Colour; |
| 279 | unsigned m_Flags; |
| 280 | }; |
| 281 | |
| 282 | |
| 283 | |
| 284 | |
| 285 | //-------------------------------------------------------------------------------- |
| 286 | // wxHtmlFontCell |
| 287 | // Sets actual font used for text rendering |
| 288 | //-------------------------------------------------------------------------------- |
| 289 | |
| 290 | class WXDLLEXPORT wxHtmlFontCell : public wxHtmlCell |
| 291 | { |
| 292 | public: |
| 293 | wxHtmlFontCell(wxFont *font) : wxHtmlCell() { m_Font = (*font); } |
| 294 | virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2); |
| 295 | virtual void DrawInvisible(wxDC& dc, int x, int y); |
| 296 | |
| 297 | protected: |
| 298 | wxFont m_Font; |
| 299 | }; |
| 300 | |
| 301 | |
| 302 | |
| 303 | |
| 304 | |
| 305 | |
| 306 | //-------------------------------------------------------------------------------- |
| 307 | // wxHtmlwidgetCell |
| 308 | // This cell is connected with wxWindow object |
| 309 | // You can use it to insert windows into HTML page |
| 310 | // (buttons, input boxes etc.) |
| 311 | //-------------------------------------------------------------------------------- |
| 312 | |
| 313 | class WXDLLEXPORT wxHtmlWidgetCell : public wxHtmlCell |
| 314 | { |
| 315 | public: |
| 316 | // !!! wnd must have correct parent! |
| 317 | // if w != 0 then the m_Wnd has 'floating' width - it adjust |
| 318 | // it's width according to parent container's width |
| 319 | // (w is percent of parent's width) |
| 320 | wxHtmlWidgetCell(wxWindow *wnd, int w = 0); |
| 321 | ~wxHtmlWidgetCell() { m_Wnd->Destroy(); } |
| 322 | virtual void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2); |
| 323 | virtual void DrawInvisible(wxDC& dc, int x, int y); |
| 324 | virtual void Layout(int w); |
| 325 | |
| 326 | protected: |
| 327 | wxWindow* m_Wnd; |
| 328 | int m_WidthFloat; |
| 329 | // width float is used in adjustWidth (it is in percents) |
| 330 | }; |
| 331 | |
| 332 | |
| 333 | |
| 334 | //-------------------------------------------------------------------------------- |
| 335 | // wxHtmlLinkInfo |
| 336 | // Internal data structure. It represents hypertext link |
| 337 | //-------------------------------------------------------------------------------- |
| 338 | |
| 339 | class WXDLLEXPORT wxHtmlLinkInfo : public wxObject |
| 340 | { |
| 341 | public: |
| 342 | wxHtmlLinkInfo() : wxObject() |
| 343 | { m_Href = m_Target = wxEmptyString; m_Event = NULL, m_Cell = NULL; } |
| 344 | wxHtmlLinkInfo(const wxString& href, const wxString& target = wxEmptyString) : wxObject() |
| 345 | { m_Href = href; m_Target = target; m_Event = NULL, m_Cell = NULL; } |
| 346 | wxHtmlLinkInfo(const wxHtmlLinkInfo& l) : wxObject() |
| 347 | { m_Href = l.m_Href, m_Target = l.m_Target, m_Event = l.m_Event; |
| 348 | m_Cell = l.m_Cell; } |
| 349 | wxHtmlLinkInfo& operator=(const wxHtmlLinkInfo& l) |
| 350 | { m_Href = l.m_Href, m_Target = l.m_Target, m_Event = l.m_Event; |
| 351 | m_Cell = l.m_Cell; return *this; } |
| 352 | |
| 353 | void SetEvent(const wxMouseEvent *e) { m_Event = e; } |
| 354 | void SetHtmlCell(const wxHtmlCell *e) { m_Cell = e; } |
| 355 | |
| 356 | wxString GetHref() const { return m_Href; } |
| 357 | wxString GetTarget() const { return m_Target; } |
| 358 | const wxMouseEvent* GetEvent() const { return m_Event; } |
| 359 | const wxHtmlCell* GetHtmlCell() const { return m_Cell; } |
| 360 | |
| 361 | private: |
| 362 | wxString m_Href, m_Target; |
| 363 | const wxMouseEvent *m_Event; |
| 364 | const wxHtmlCell *m_Cell; |
| 365 | }; |
| 366 | |
| 367 | |
| 368 | |
| 369 | |
| 370 | #endif // wxUSE_HTML |
| 371 | |
| 372 | #endif // _WX_HTMLCELL_H_ |
| 373 | |