]>
Commit | Line | Data |
---|---|---|
5526e819 VS |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: htmlwin.h | |
3 | // Purpose: wxHtmlWindow class for parsing & displaying HTML | |
4 | // Author: Vaclav Slavik | |
69941f05 | 5 | // RCS-ID: $Id$ |
5526e819 | 6 | // Copyright: (c) 1999 Vaclav Slavik |
65571936 | 7 | // Licence: wxWindows licence |
5526e819 VS |
8 | ///////////////////////////////////////////////////////////////////////////// |
9 | ||
69941f05 VS |
10 | #ifndef _WX_HTMLWIN_H_ |
11 | #define _WX_HTMLWIN_H_ | |
5526e819 | 12 | |
5526e819 VS |
13 | #include "wx/defs.h" |
14 | #if wxUSE_HTML | |
15 | ||
69941f05 VS |
16 | #include "wx/window.h" |
17 | #include "wx/scrolwin.h" | |
18 | #include "wx/config.h" | |
33f81fc7 | 19 | #include "wx/stopwatch.h" |
69941f05 VS |
20 | #include "wx/html/winpars.h" |
21 | #include "wx/html/htmlcell.h" | |
22 | #include "wx/filesys.h" | |
23 | #include "wx/html/htmlfilt.h" | |
903972f9 | 24 | #include "wx/filename.h" |
e05a12c9 | 25 | #include "wx/bitmap.h" |
5526e819 | 26 | |
bfb9ee96 | 27 | class wxHtmlProcessor; |
892aeafc VS |
28 | class wxHtmlWinModule; |
29 | class wxHtmlHistoryArray; | |
30 | class wxHtmlProcessorList; | |
6acba9a7 | 31 | class WXDLLIMPEXP_HTML wxHtmlWinAutoScrollTimer; |
5526e819 | 32 | |
6cc4e6b8 VS |
33 | |
34 | // wxHtmlWindow flags: | |
35 | #define wxHW_SCROLLBAR_NEVER 0x0002 | |
36 | #define wxHW_SCROLLBAR_AUTO 0x0004 | |
f65a786f VS |
37 | #define wxHW_NO_SELECTION 0x0008 |
38 | ||
39 | #define wxHW_DEFAULT_STYLE wxHW_SCROLLBAR_AUTO | |
40 | ||
bc55e31b | 41 | /// Enum for wxHtmlWindow::OnOpeningURL and wxHtmlWindowInterface::OnOpeningURL |
6cc4e6b8 VS |
42 | enum wxHtmlOpeningStatus |
43 | { | |
bc55e31b | 44 | /// Open the requested URL |
6cc4e6b8 | 45 | wxHTML_OPEN, |
bc55e31b | 46 | /// Do not open the URL |
6cc4e6b8 | 47 | wxHTML_BLOCK, |
bc55e31b | 48 | /// Redirect to another URL (returned from OnOpeningURL) |
6cc4e6b8 VS |
49 | wxHTML_REDIRECT |
50 | }; | |
51 | ||
bc55e31b VS |
52 | /** |
53 | Abstract interface to a HTML rendering window (such as wxHtmlWindow or | |
54 | wxHtmlListBox) that is passed to wxHtmlWinParser. It encapsulates all | |
55 | communication from the parser to the window. | |
56 | */ | |
57 | class WXDLLIMPEXP_HTML wxHtmlWindowInterface | |
58 | { | |
59 | public: | |
60 | /// Ctor | |
61 | wxHtmlWindowInterface() {} | |
62 | virtual ~wxHtmlWindowInterface() {} | |
63 | ||
64 | /** | |
65 | Called by the parser to set window's title to given text. | |
66 | */ | |
67 | virtual void SetHTMLWindowTitle(const wxString& title) = 0; | |
68 | ||
69 | /** | |
70 | Called when a link is clicked. | |
71 | ||
72 | @param link information about the clicked link | |
73 | */ | |
74 | virtual void OnHTMLLinkClicked(const wxHtmlLinkInfo& link) = 0; | |
75 | ||
76 | /** | |
77 | Called when the parser needs to open another URL (e.g. an image). | |
78 | ||
79 | @param type Type of the URL request (e.g. image) | |
80 | @param url URL the parser wants to open | |
81 | @param redirect If the return value is wxHTML_REDIRECT, then the | |
82 | URL to redirect to will be stored in this variable | |
83 | (the pointer must never be NULL) | |
84 | ||
85 | @return indicator of how to treat the request | |
86 | */ | |
87 | virtual wxHtmlOpeningStatus OnHTMLOpeningURL(wxHtmlURLType type, | |
88 | const wxString& url, | |
89 | wxString *redirect) const = 0; | |
90 | ||
91 | /** | |
92 | Converts coordinates @a pos relative to given @a cell to | |
93 | physical coordinates in the window. | |
94 | */ | |
95 | virtual wxPoint HTMLCoordsToWindow(wxHtmlCell *cell, | |
96 | const wxPoint& pos) const = 0; | |
97 | ||
98 | /// Returns the window used for rendering (may be NULL). | |
99 | virtual wxWindow* GetHTMLWindow() = 0; | |
100 | ||
101 | /// Returns background colour to use by default. | |
102 | virtual wxColour GetHTMLBackgroundColour() const = 0; | |
103 | ||
104 | /// Sets window's background to colour @a clr. | |
105 | virtual void SetHTMLBackgroundColour(const wxColour& clr) = 0; | |
106 | ||
107 | /// Sets window's background to given bitmap. | |
108 | virtual void SetHTMLBackgroundImage(const wxBitmap& bmpBg) = 0; | |
109 | ||
110 | /// Sets status bar text. | |
111 | virtual void SetHTMLStatusText(const wxString& text) = 0; | |
88a1b648 VS |
112 | |
113 | /// Type of mouse cursor | |
114 | enum HTMLCursor | |
115 | { | |
116 | /// Standard mouse cursor (typically an arrow) | |
117 | HTMLCursor_Default, | |
118 | /// Cursor shown over links | |
119 | HTMLCursor_Link, | |
120 | /// Cursor shown over selectable text | |
121 | HTMLCursor_Text | |
122 | }; | |
123 | ||
124 | /** | |
125 | Returns mouse cursor of given @a type. | |
126 | */ | |
127 | virtual wxCursor GetHTMLCursor(HTMLCursor type) const = 0; | |
bc55e31b VS |
128 | }; |
129 | ||
130 | /** | |
131 | Helper class that implements part of mouse handling for wxHtmlWindow and | |
132 | wxHtmlListBox. Cursor changes and clicking on links are handled, text | |
133 | selection is not. | |
134 | */ | |
135 | class WXDLLIMPEXP_HTML wxHtmlWindowMouseHelper | |
136 | { | |
137 | public: | |
138 | /** | |
139 | Ctor. | |
140 | ||
141 | @param iface Interface to the owner window. | |
142 | */ | |
143 | wxHtmlWindowMouseHelper(wxHtmlWindowInterface *iface); | |
144 | ||
145 | /// Returns true if the mouse moved since the last call to HandleIdle | |
146 | bool DidMouseMove() const { return m_tmpMouseMoved; } | |
147 | ||
148 | /// Call this from EVT_MOTION event handler | |
149 | void HandleMouseMoved(); | |
150 | ||
151 | /** | |
152 | Call this from EVT_LEFT_UP handler (or, alternatively, EVT_LEFT_DOWN). | |
153 | ||
154 | @param rootCell HTML cell inside which the click occured. This doesn't | |
155 | have to be the leaf cell, it can be e.g. toplevel | |
156 | container, but the mouse must be inside the container's | |
157 | area, otherwise the event would be ignored. | |
158 | @param pos Mouse position in coordinates relative to @a cell | |
159 | @param event The event that triggered the call | |
160 | */ | |
161 | bool HandleMouseClick(wxHtmlCell *rootCell, | |
162 | const wxPoint& pos, const wxMouseEvent& event); | |
163 | ||
164 | /** | |
165 | Call this from OnInternalIdle of the HTML displaying window. Handles | |
166 | mouse movements and must be used together with HandleMouseMoved. | |
167 | ||
168 | @param rootCell HTML cell inside which the click occured. This doesn't | |
169 | have to be the leaf cell, it can be e.g. toplevel | |
170 | container, but the mouse must be inside the container's | |
171 | area, otherwise the event would be ignored. | |
172 | @param pos Current mouse position in coordinates relative to | |
173 | @a cell | |
174 | */ | |
175 | void HandleIdle(wxHtmlCell *rootCell, const wxPoint& pos); | |
176 | ||
177 | /** | |
178 | Called by HandleIdle when the mouse hovers over a cell. Default | |
179 | behaviour is to do nothing. | |
180 | ||
181 | @param cell the cell the mouse is over | |
182 | @param x, y coordinates of mouse relative to the cell | |
183 | */ | |
184 | virtual void OnCellMouseHover(wxHtmlCell *cell, wxCoord x, wxCoord y); | |
185 | ||
186 | /** | |
187 | Called by HandleMouseClick when the user clicks on a cell. | |
188 | Default behavior is to call wxHtmlWindowInterface::OnLinkClicked() | |
189 | if this cell corresponds to a hypertext link. | |
190 | ||
191 | @param cell the cell the mouse is over | |
192 | @param x, y coordinates of mouse relative to the cell | |
193 | @param event The event that triggered the call | |
194 | ||
195 | ||
196 | @return true if a link was clicked, false otherwise. | |
197 | */ | |
198 | virtual bool OnCellClicked(wxHtmlCell *cell, | |
199 | wxCoord x, wxCoord y, | |
200 | const wxMouseEvent& event); | |
201 | ||
202 | protected: | |
203 | // this flag indicates if the mouse moved (used by HandleIdle) | |
204 | bool m_tmpMouseMoved; | |
205 | // contains last link name | |
206 | wxHtmlLinkInfo *m_tmpLastLink; | |
207 | // contains the last (terminal) cell which contained the mouse | |
208 | wxHtmlCell *m_tmpLastCell; | |
209 | ||
210 | private: | |
211 | wxHtmlWindowInterface *m_interface; | |
212 | }; | |
213 | ||
f65a786f | 214 | // ---------------------------------------------------------------------------- |
5526e819 | 215 | // wxHtmlWindow |
3ef01ce5 | 216 | // (This is probably the only class you will directly use.) |
5526e819 | 217 | // Purpose of this class is to display HTML page (either local |
f65a786f VS |
218 | // file or downloaded via HTTP protocol) in a window. Width of |
219 | // window is constant - given in constructor - virtual height | |
220 | // is changed dynamicly depending on page size. Once the | |
221 | // window is created you can set it's content by calling | |
3ef01ce5 | 222 | // SetPage(text) or LoadPage(filename). |
f65a786f | 223 | // ---------------------------------------------------------------------------- |
5526e819 | 224 | |
bc55e31b VS |
225 | class WXDLLIMPEXP_HTML wxHtmlWindow : public wxScrolledWindow, |
226 | public wxHtmlWindowInterface, | |
227 | private wxHtmlWindowMouseHelper | |
5526e819 VS |
228 | { |
229 | DECLARE_DYNAMIC_CLASS(wxHtmlWindow) | |
66806a0b | 230 | friend class wxHtmlWinModule; |
5526e819 | 231 | |
97494971 | 232 | public: |
bc55e31b | 233 | wxHtmlWindow() : wxHtmlWindowMouseHelper(this) { Init(); } |
6953da00 | 234 | wxHtmlWindow(wxWindow *parent, wxWindowID id = wxID_ANY, |
bfb9ee96 | 235 | const wxPoint& pos = wxDefaultPosition, |
97494971 | 236 | const wxSize& size = wxDefaultSize, |
f65a786f | 237 | long style = wxHW_DEFAULT_STYLE, |
4f417130 | 238 | const wxString& name = wxT("htmlWindow")) |
bc55e31b | 239 | : wxHtmlWindowMouseHelper(this) |
4f417130 VS |
240 | { |
241 | Init(); | |
242 | Create(parent, id, pos, size, style, name); | |
243 | } | |
97494971 VS |
244 | ~wxHtmlWindow(); |
245 | ||
6953da00 | 246 | bool Create(wxWindow *parent, wxWindowID id = wxID_ANY, |
4f417130 VS |
247 | const wxPoint& pos = wxDefaultPosition, |
248 | const wxSize& size = wxDefaultSize, | |
249 | long style = wxHW_SCROLLBAR_AUTO, | |
250 | const wxString& name = wxT("htmlWindow")); | |
251 | ||
97494971 VS |
252 | // Set HTML page and display it. !! source is HTML document itself, |
253 | // it is NOT address/filename of HTML document. If you want to | |
254 | // specify document location, use LoadPage() istead | |
3103e8a9 | 255 | // Return value : false if an error occurred, true otherwise |
04f109ec | 256 | virtual bool SetPage(const wxString& source); |
574c939e | 257 | |
39029898 VS |
258 | // Append to current page |
259 | bool AppendToPage(const wxString& source); | |
97494971 VS |
260 | |
261 | // Load HTML page from given location. Location can be either | |
262 | // a) /usr/wxGTK2/docs/html/wx.htm | |
263 | // b) http://www.somewhere.uk/document.htm | |
264 | // c) ftp://ftp.somesite.cz/pub/something.htm | |
265 | // In case there is no prefix (http:,ftp:), the method | |
266 | // will try to find it itself (1. local file, then http or ftp) | |
267 | // After the page is loaded, the method calls SetPage() to display it. | |
268 | // Note : you can also use path relative to previously loaded page | |
269 | // Return value : same as SetPage | |
38caaa61 | 270 | virtual bool LoadPage(const wxString& location); |
97494971 | 271 | |
903972f9 VS |
272 | // Loads HTML page from file |
273 | bool LoadFile(const wxFileName& filename); | |
274 | ||
97494971 VS |
275 | // Returns full location of opened page |
276 | wxString GetOpenedPage() const {return m_OpenedPage;} | |
277 | // Returns anchor within opened page | |
278 | wxString GetOpenedAnchor() const {return m_OpenedAnchor;} | |
279 | // Returns <TITLE> of opened page or empty string otherwise | |
280 | wxString GetOpenedPageTitle() const {return m_OpenedPageTitle;} | |
281 | ||
282 | // Sets frame in which page title will be displayed. Format is format of | |
283 | // frame title, e.g. "HtmlHelp : %s". It must contain exactly one %s | |
284 | void SetRelatedFrame(wxFrame* frame, const wxString& format); | |
285 | wxFrame* GetRelatedFrame() const {return m_RelatedFrame;} | |
286 | ||
67a99992 | 287 | #if wxUSE_STATUSBAR |
97494971 VS |
288 | // After(!) calling SetRelatedFrame, this sets statusbar slot where messages |
289 | // will be displayed. Default is -1 = no messages. | |
290 | void SetRelatedStatusBar(int bar); | |
67a99992 | 291 | #endif // wxUSE_STATUSBAR |
97494971 VS |
292 | |
293 | // Sets fonts to be used when displaying HTML page. | |
fbfb8bcc | 294 | void SetFonts(const wxString& normal_face, const wxString& fixed_face, |
4eecf115 | 295 | const int *sizes = NULL); |
97494971 | 296 | |
10e5c7ea VS |
297 | // Sets font sizes to be relative to the given size or the system |
298 | // default size; use either specified or default font | |
299 | void SetStandardFonts(int size = -1, | |
300 | const wxString& normal_face = wxEmptyString, | |
301 | const wxString& fixed_face = wxEmptyString); | |
6953da00 | 302 | |
97494971 VS |
303 | // Sets space between text and window borders. |
304 | void SetBorders(int b) {m_Borders = b;} | |
305 | ||
97e490f8 VZ |
306 | // Sets the bitmap to use for background (currnetly it will be tiled, |
307 | // when/if we have CSS support we could add other possibilities...) | |
308 | void SetBackgroundImage(const wxBitmap& bmpBg) { m_bmpBg = bmpBg; } | |
309 | ||
97494971 VS |
310 | // Saves custom settings into cfg config. it will use the path 'path' |
311 | // if given, otherwise it will save info into currently selected path. | |
312 | // saved values : things set by SetFonts, SetBorders. | |
313 | virtual void ReadCustomization(wxConfigBase *cfg, wxString path = wxEmptyString); | |
314 | // ... | |
315 | virtual void WriteCustomization(wxConfigBase *cfg, wxString path = wxEmptyString); | |
316 | ||
317 | // Goes to previous/next page (in browsing history) | |
6953da00 | 318 | // Returns true if successful, false otherwise |
97494971 VS |
319 | bool HistoryBack(); |
320 | bool HistoryForward(); | |
321 | bool HistoryCanBack(); | |
322 | bool HistoryCanForward(); | |
323 | // Resets history | |
324 | void HistoryClear(); | |
325 | ||
326 | // Returns pointer to conteiners/cells structure. | |
327 | // It should be used ONLY when printing | |
328 | wxHtmlContainerCell* GetInternalRepresentation() const {return m_Cell;} | |
329 | ||
330 | // Adds input filter | |
331 | static void AddFilter(wxHtmlFilter *filter); | |
332 | ||
6cc4e6b8 VS |
333 | // Returns a pointer to the parser. |
334 | wxHtmlWinParser *GetParser() const { return m_Parser; } | |
335 | ||
336 | // Adds HTML processor to this instance of wxHtmlWindow: | |
337 | void AddProcessor(wxHtmlProcessor *processor); | |
338 | // Adds HTML processor to wxHtmlWindow class as whole: | |
339 | static void AddGlobalProcessor(wxHtmlProcessor *processor); | |
340 | ||
97e490f8 | 341 | |
6cc4e6b8 VS |
342 | // -- Callbacks -- |
343 | ||
344 | // Sets the title of the window | |
345 | // (depending on the information passed to SetRelatedFrame() method) | |
346 | virtual void OnSetTitle(const wxString& title); | |
347 | ||
f6010d8f | 348 | // Called when user clicked on hypertext link. Default behavior is to |
97494971 VS |
349 | // call LoadPage(loc) |
350 | virtual void OnLinkClicked(const wxHtmlLinkInfo& link); | |
574c939e KB |
351 | |
352 | // Called when wxHtmlWindow wants to fetch data from an URL (e.g. when | |
353 | // loading a page or loading an image). The data are downloaded if and only if | |
6953da00 | 354 | // OnOpeningURL returns true. If OnOpeningURL returns wxHTML_REDIRECT, |
6cc4e6b8 | 355 | // it must set *redirect to the new URL |
574c939e KB |
356 | virtual wxHtmlOpeningStatus OnOpeningURL(wxHtmlURLType WXUNUSED(type), |
357 | const wxString& WXUNUSED(url), | |
358 | wxString *WXUNUSED(redirect)) const | |
6cc4e6b8 | 359 | { return wxHTML_OPEN; } |
6953da00 | 360 | |
15622068 VZ |
361 | #if wxUSE_CLIPBOARD |
362 | // Helper functions to select parts of page: | |
363 | void SelectWord(const wxPoint& pos); | |
364 | void SelectLine(const wxPoint& pos); | |
365 | void SelectAll(); | |
6953da00 | 366 | |
5d3f80be VS |
367 | // Convert selection to text: |
368 | wxString SelectionToText() { return DoSelectionToText(m_selection); } | |
369 | ||
370 | // Converts current page to text: | |
371 | wxString ToText(); | |
97e490f8 | 372 | #endif // wxUSE_CLIPBOARD |
6953da00 | 373 | |
6f02a879 VZ |
374 | virtual void OnInternalIdle(); |
375 | ||
88a1b648 VS |
376 | /// Returns standard HTML cursor as used by wxHtmlWindow |
377 | static wxCursor GetDefaultHTMLCursor(HTMLCursor type); | |
bc55e31b | 378 | |
97494971 | 379 | protected: |
4f417130 VS |
380 | void Init(); |
381 | ||
97494971 VS |
382 | // Scrolls to anchor of this name. (Anchor is #news |
383 | // or #features etc. it is part of address sometimes: | |
384 | // http://www.ms.mff.cuni.cz/~vsla8348/wxhtml/index.html#news) | |
6953da00 | 385 | // Return value : true if anchor exists, false otherwise |
97494971 VS |
386 | bool ScrollToAnchor(const wxString& anchor); |
387 | ||
bfb9ee96 | 388 | // Prepares layout (= fill m_PosX, m_PosY for fragments) based on |
97494971 VS |
389 | // actual size of window. This method also setup scrollbars |
390 | void CreateLayout(); | |
391 | ||
1338c59a VS |
392 | void OnEraseBackground(wxEraseEvent& event); |
393 | void OnPaint(wxPaintEvent& event); | |
97494971 | 394 | void OnSize(wxSizeEvent& event); |
31d8b4ad | 395 | void OnMouseMove(wxMouseEvent& event); |
adf2eb2d VS |
396 | void OnMouseDown(wxMouseEvent& event); |
397 | void OnMouseUp(wxMouseEvent& event); | |
61233023 VS |
398 | #if wxUSE_CLIPBOARD |
399 | void OnKeyUp(wxKeyEvent& event); | |
31eefb99 | 400 | void OnDoubleClick(wxMouseEvent& event); |
61233023 | 401 | void OnCopy(wxCommandEvent& event); |
1338c59a VS |
402 | void OnMouseEnter(wxMouseEvent& event); |
403 | void OnMouseLeave(wxMouseEvent& event); | |
d659d703 | 404 | #endif // wxUSE_CLIPBOARD |
97494971 VS |
405 | |
406 | // Returns new filter (will be stored into m_DefaultFilter variable) | |
407 | virtual wxHtmlFilter *GetDefaultFilter() {return new wxHtmlFilterPlainText;} | |
408 | ||
892aeafc | 409 | // cleans static variables |
97494971 | 410 | static void CleanUpStatics(); |
97494971 | 411 | |
f65a786f VS |
412 | // Returns true if text selection is enabled (wxClipboard must be available |
413 | // and wxHW_NO_SELECTION not used) | |
414 | bool IsSelectionEnabled() const; | |
415 | ||
61233023 VS |
416 | enum ClipboardType |
417 | { | |
418 | Primary, | |
419 | Secondary | |
420 | }; | |
d659d703 VZ |
421 | |
422 | // Copies selection to clipboard if the clipboard support is available | |
4bdce112 VZ |
423 | // |
424 | // returns true if anything was copied to clipboard, false otherwise | |
5de65c69 | 425 | bool CopySelection(ClipboardType t = Secondary); |
0994d968 | 426 | |
d659d703 | 427 | #if wxUSE_CLIPBOARD |
0994d968 | 428 | // Automatic scrolling during selection: |
1338c59a | 429 | void StopAutoScrolling(); |
d659d703 | 430 | #endif // wxUSE_CLIPBOARD |
61233023 | 431 | |
977b867e | 432 | wxString DoSelectionToText(wxHtmlSelection *sel); |
6953da00 | 433 | |
73de5077 | 434 | private: |
bc55e31b VS |
435 | // wxHtmlWindowInterface methods: |
436 | virtual void SetHTMLWindowTitle(const wxString& title); | |
437 | virtual void OnHTMLLinkClicked(const wxHtmlLinkInfo& link); | |
438 | virtual wxHtmlOpeningStatus OnHTMLOpeningURL(wxHtmlURLType type, | |
439 | const wxString& url, | |
440 | wxString *redirect) const; | |
441 | virtual wxPoint HTMLCoordsToWindow(wxHtmlCell *cell, | |
442 | const wxPoint& pos) const; | |
443 | virtual wxWindow* GetHTMLWindow(); | |
444 | virtual wxColour GetHTMLBackgroundColour() const; | |
445 | virtual void SetHTMLBackgroundColour(const wxColour& clr); | |
446 | virtual void SetHTMLBackgroundImage(const wxBitmap& bmpBg); | |
447 | virtual void SetHTMLStatusText(const wxString& text); | |
88a1b648 | 448 | virtual wxCursor GetHTMLCursor(HTMLCursor type) const; |
bc55e31b | 449 | |
73de5077 VS |
450 | // implementation of SetPage() |
451 | bool DoSetPage(const wxString& source); | |
452 | ||
453 | protected: | |
1338c59a VS |
454 | // This is pointer to the first cell in parsed data. (Note: the first cell |
455 | // is usually top one = all other cells are sub-cells of this one) | |
97494971 | 456 | wxHtmlContainerCell *m_Cell; |
892aeafc VS |
457 | // parser which is used to parse HTML input. |
458 | // Each wxHtmlWindow has it's own parser because sharing one global | |
459 | // parser would be problematic (because of reentrancy) | |
97494971 | 460 | wxHtmlWinParser *m_Parser; |
892aeafc | 461 | // contains name of actualy opened page or empty string if no page opened |
97494971 | 462 | wxString m_OpenedPage; |
892aeafc | 463 | // contains name of current anchor within m_OpenedPage |
97494971 | 464 | wxString m_OpenedAnchor; |
892aeafc | 465 | // contains title of actualy opened page or empty string if no <TITLE> tag |
97494971 | 466 | wxString m_OpenedPageTitle; |
892aeafc | 467 | // class for opening files (file system) |
97494971 | 468 | wxFileSystem* m_FS; |
97494971 VS |
469 | |
470 | wxFrame *m_RelatedFrame; | |
471 | wxString m_TitleFormat; | |
67a99992 | 472 | #if wxUSE_STATUSBAR |
892aeafc VS |
473 | // frame in which page title should be displayed & number of it's statusbar |
474 | // reserved for usage with this html window | |
97494971 | 475 | int m_RelatedStatusBar; |
67a99992 | 476 | #endif // wxUSE_STATUSBAR |
97494971 | 477 | |
892aeafc VS |
478 | // borders (free space between text and window borders) |
479 | // defaults to 10 pixels. | |
97494971 | 480 | int m_Borders; |
97494971 VS |
481 | |
482 | int m_Style; | |
483 | ||
adf2eb2d VS |
484 | // current text selection or NULL |
485 | wxHtmlSelection *m_selection; | |
486 | ||
487 | // true if the user is dragging mouse to select text | |
488 | bool m_makingSelection; | |
489 | ||
1338c59a | 490 | #if wxUSE_CLIPBOARD |
0994d968 VS |
491 | // time of the last doubleclick event, used to detect tripleclicks |
492 | // (tripleclicks are used to select whole line): | |
33f81fc7 | 493 | wxMilliClock_t m_lastDoubleClick; |
0994d968 VS |
494 | |
495 | // helper class to automatically scroll the window if the user is selecting | |
496 | // text and the mouse leaves wxHtmlWindow: | |
1338c59a | 497 | wxHtmlWinAutoScrollTimer *m_timerAutoScroll; |
d659d703 | 498 | #endif // wxUSE_CLIPBOARD |
1338c59a | 499 | |
97494971 | 500 | private: |
1338c59a VS |
501 | // window content for double buffered rendering: |
502 | wxBitmap *m_backBuffer; | |
d659d703 | 503 | |
97e490f8 VZ |
504 | // background image, may be invalid |
505 | wxBitmap m_bmpBg; | |
506 | ||
adf2eb2d VS |
507 | // variables used when user is selecting text |
508 | wxPoint m_tmpSelFromPos; | |
509 | wxHtmlCell *m_tmpSelFromCell; | |
d659d703 | 510 | |
892aeafc VS |
511 | // if >0 contents of the window is not redrawn |
512 | // (in order to avoid ugly blinking) | |
97494971 | 513 | int m_tmpCanDrawLocks; |
97494971 | 514 | |
892aeafc | 515 | // list of HTML filters |
97494971 | 516 | static wxList m_Filters; |
892aeafc | 517 | // this filter is used when no filter is able to read some file |
97494971 | 518 | static wxHtmlFilter *m_DefaultFilter; |
97494971 | 519 | |
518ba663 VZ |
520 | // html processors array: |
521 | wxHtmlProcessorList *m_Processors; | |
522 | static wxHtmlProcessorList *m_GlobalProcessors; | |
523 | ||
892aeafc | 524 | // browser history |
518ba663 | 525 | wxHtmlHistoryArray *m_History; |
97494971 | 526 | int m_HistoryPos; |
892aeafc | 527 | // if this FLAG is false, items are not added to history |
97494971 | 528 | bool m_HistoryOn; |
bfb9ee96 | 529 | |
518ba663 VZ |
530 | // a flag set if we need to erase background in OnPaint() (otherwise this |
531 | // is supposed to have been done in OnEraseBackground()) | |
532 | bool m_eraseBgInOnPaint; | |
5526e819 | 533 | |
88a1b648 VS |
534 | // standard mouse cursors |
535 | static wxCursor *ms_cursorLink; | |
536 | static wxCursor *ms_cursorText; | |
537 | ||
69941f05 | 538 | DECLARE_EVENT_TABLE() |
22f3361e | 539 | DECLARE_NO_COPY_CLASS(wxHtmlWindow) |
69941f05 | 540 | }; |
5526e819 VS |
541 | |
542 | ||
d659d703 | 543 | #endif // wxUSE_HTML |
69941f05 VS |
544 | |
545 | #endif // _WX_HTMLWIN_H_ | |
19193a2c | 546 |