]> git.saurik.com Git - wxWidgets.git/blame_incremental - include/wx/richtext/richtextbuffer.h
don't draw borders for bitmap buttons with wxBORDER_NONE style
[wxWidgets.git] / include / wx / richtext / richtextbuffer.h
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: wx/richtext/richtextbuffer.h
3// Purpose: Buffer for wxRichTextCtrl
4// Author: Julian Smart
5// Modified by:
6// Created: 2005-09-30
7// RCS-ID: $Id$
8// Copyright: (c) Julian Smart
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12#ifndef _WX_RICHTEXTBUFFER_H_
13#define _WX_RICHTEXTBUFFER_H_
14
15/*
16
17 Data structures
18 ===============
19
20 Data is represented by a hierarchy of objects, all derived from
21 wxRichTextObject.
22
23 The top of the hierarchy is the buffer, a kind of wxRichTextParagraphLayoutBox.
24 These boxes will allow flexible placement of text boxes on a page, but
25 for now there is a single box representing the document, and this box is
26 a wxRichTextParagraphLayoutBox which contains further wxRichTextParagraph
27 objects, each of which can include text and images.
28
29 Each object maintains a range (start and end position) measured
30 from the start of the main parent box.
31 A paragraph object knows its range, and a text fragment knows its range
32 too. So, a character or image in a page has a position relative to the
33 start of the document, and a character in an embedded text box has
34 a position relative to that text box. For now, we will not be dealing with
35 embedded objects but it's something to bear in mind for later.
36
37 Note that internally, a range (5,5) represents a range of one character.
38 In the public wx[Rich]TextCtrl API, this would be passed to e.g. SetSelection
39 as (5,6). A paragraph with one character might have an internal range of (0, 1)
40 since the end of the paragraph takes up one position.
41
42 Layout
43 ======
44
45 When Layout is called on an object, it is given a size which the object
46 must limit itself to, or one or more flexible directions (vertical
47 or horizontal). So for example a centered paragraph is given the page
48 width to play with (minus any margins), but can extend indefinitely
49 in the vertical direction. The implementation of Layout can then
50 cache the calculated size and position within the parent.
51
52 */
53
54/*!
55 * Includes
56 */
57
58#include "wx/defs.h"
59
60#if wxUSE_RICHTEXT
61
62#include "wx/list.h"
63#include "wx/textctrl.h"
64#include "wx/bitmap.h"
65#include "wx/image.h"
66#include "wx/cmdproc.h"
67#include "wx/txtstrm.h"
68
69#if wxUSE_DATAOBJ
70#include "wx/dataobj.h"
71#endif
72
73// Compatibility
74#define wxRichTextAttr wxTextAttr
75#define wxTextAttrEx wxTextAttr
76
77// Setting wxRICHTEXT_USE_OWN_CARET to 1 implements a
78// cursor reliably without using wxClientDC in case there
79// are platform-specific problems with the generic caret.
80#ifdef __WXMAC__
81#define wxRICHTEXT_USE_OWN_CARET 1
82#else
83#define wxRICHTEXT_USE_OWN_CARET 0
84#endif
85
86// Switch off for binary compatibility, on for faster drawing
87// Note: this seems to be buggy (overzealous use of extents) so
88// don't use for now
89#define wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING 0
90
91/*!
92 * Special characters
93 */
94
95extern WXDLLIMPEXP_RICHTEXT const wxChar wxRichTextLineBreakChar;
96
97/*!
98 * File types in wxRichText context.
99 */
100enum wxRichTextFileType
101{
102 wxRICHTEXT_TYPE_ANY = 0,
103 wxRICHTEXT_TYPE_TEXT,
104 wxRICHTEXT_TYPE_XML,
105 wxRICHTEXT_TYPE_HTML,
106 wxRICHTEXT_TYPE_RTF,
107 wxRICHTEXT_TYPE_PDF
108};
109
110/*!
111 * Forward declarations
112 */
113
114class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextCtrl;
115class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextObject;
116class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextCacheObject;
117class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextObjectList;
118class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextLine;
119class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextParagraph;
120class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextFileHandler;
121class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextStyleSheet;
122class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextListStyleDefinition;
123class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextEvent;
124class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextRenderer;
125class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextBuffer;
126
127/*!
128 * Flags determining the available space, passed to Layout
129 */
130
131#define wxRICHTEXT_FIXED_WIDTH 0x01
132#define wxRICHTEXT_FIXED_HEIGHT 0x02
133#define wxRICHTEXT_VARIABLE_WIDTH 0x04
134#define wxRICHTEXT_VARIABLE_HEIGHT 0x08
135
136// Only lay out the part of the buffer that lies within
137// the rect passed to Layout.
138#define wxRICHTEXT_LAYOUT_SPECIFIED_RECT 0x10
139
140/*!
141 * Flags to pass to Draw
142 */
143
144// Ignore paragraph cache optimization, e.g. for printing purposes
145// where one line may be drawn higher (on the next page) compared
146// with the previous line
147#define wxRICHTEXT_DRAW_IGNORE_CACHE 0x01
148
149/*!
150 * Flags returned from hit-testing
151 */
152enum wxRichTextHitTestFlags
153{
154 // The point was not on this object
155 wxRICHTEXT_HITTEST_NONE = 0x01,
156
157 // The point was before the position returned from HitTest
158 wxRICHTEXT_HITTEST_BEFORE = 0x02,
159
160 // The point was after the position returned from HitTest
161 wxRICHTEXT_HITTEST_AFTER = 0x04,
162
163 // The point was on the position returned from HitTest
164 wxRICHTEXT_HITTEST_ON = 0x08,
165
166 // The point was on space outside content
167 wxRICHTEXT_HITTEST_OUTSIDE = 0x10
168};
169
170/*!
171 * Flags for GetRangeSize
172 */
173
174#define wxRICHTEXT_FORMATTED 0x01
175#define wxRICHTEXT_UNFORMATTED 0x02
176#define wxRICHTEXT_CACHE_SIZE 0x04
177#define wxRICHTEXT_HEIGHT_ONLY 0x08
178
179/*!
180 * Flags for SetStyle/SetListStyle
181 */
182
183#define wxRICHTEXT_SETSTYLE_NONE 0x00
184
185// Specifies that this operation should be undoable
186#define wxRICHTEXT_SETSTYLE_WITH_UNDO 0x01
187
188// Specifies that the style should not be applied if the
189// combined style at this point is already the style in question.
190#define wxRICHTEXT_SETSTYLE_OPTIMIZE 0x02
191
192// Specifies that the style should only be applied to paragraphs,
193// and not the content. This allows content styling to be
194// preserved independently from that of e.g. a named paragraph style.
195#define wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY 0x04
196
197// Specifies that the style should only be applied to characters,
198// and not the paragraph. This allows content styling to be
199// preserved independently from that of e.g. a named paragraph style.
200#define wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY 0x08
201
202// For SetListStyle only: specifies starting from the given number, otherwise
203// deduces number from existing attributes
204#define wxRICHTEXT_SETSTYLE_RENUMBER 0x10
205
206// For SetListStyle only: specifies the list level for all paragraphs, otherwise
207// the current indentation will be used
208#define wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL 0x20
209
210// Resets the existing style before applying the new style
211#define wxRICHTEXT_SETSTYLE_RESET 0x40
212
213// Removes the given style instead of applying it
214#define wxRICHTEXT_SETSTYLE_REMOVE 0x80
215
216/*!
217 * Flags for text insertion
218 */
219
220#define wxRICHTEXT_INSERT_NONE 0x00
221#define wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE 0x01
222#define wxRICHTEXT_INSERT_INTERACTIVE 0x02
223
224// A special flag telling the buffer to keep the first paragraph style
225// as-is, when deleting a paragraph marker. In future we might pass a
226// flag to InsertFragment and DeleteRange to indicate the appropriate mode.
227#define wxTEXT_ATTR_KEEP_FIRST_PARA_STYLE 0x10000000
228
229/*!
230 * Default superscript/subscript font multiplication factor
231 */
232
233#define wxSCRIPT_MUL_FACTOR 1.5
234
235/*!
236 * wxRichTextFontTable
237 * Manages quick access to a pool of fonts for rendering rich text
238 */
239
240class WXDLLIMPEXP_RICHTEXT wxRichTextFontTable: public wxObject
241{
242public:
243 wxRichTextFontTable();
244
245 wxRichTextFontTable(const wxRichTextFontTable& table);
246 virtual ~wxRichTextFontTable();
247
248 bool IsOk() const { return m_refData != NULL; }
249
250 wxFont FindFont(const wxTextAttr& fontSpec);
251 void Clear();
252
253 void operator= (const wxRichTextFontTable& table);
254 bool operator == (const wxRichTextFontTable& table) const;
255 bool operator != (const wxRichTextFontTable& table) const { return !(*this == table); }
256
257protected:
258
259 DECLARE_DYNAMIC_CLASS(wxRichTextFontTable)
260};
261
262/*!
263 * wxRichTextRange class declaration
264 * This stores beginning and end positions for a range of data.
265 * TODO: consider renaming wxTextRange and using for all text controls.
266 */
267
268class WXDLLIMPEXP_RICHTEXT wxRichTextRange
269{
270public:
271// Constructors
272
273 wxRichTextRange() { m_start = 0; m_end = 0; }
274 wxRichTextRange(long start, long end) { m_start = start; m_end = end; }
275 wxRichTextRange(const wxRichTextRange& range) { m_start = range.m_start; m_end = range.m_end; }
276 ~wxRichTextRange() {}
277
278 void operator =(const wxRichTextRange& range) { m_start = range.m_start; m_end = range.m_end; }
279 bool operator ==(const wxRichTextRange& range) const { return (m_start == range.m_start && m_end == range.m_end); }
280 bool operator !=(const wxRichTextRange& range) const { return (m_start != range.m_start || m_end != range.m_end); }
281 wxRichTextRange operator -(const wxRichTextRange& range) const { return wxRichTextRange(m_start - range.m_start, m_end - range.m_end); }
282 wxRichTextRange operator +(const wxRichTextRange& range) const { return wxRichTextRange(m_start + range.m_start, m_end + range.m_end); }
283
284 void SetRange(long start, long end) { m_start = start; m_end = end; }
285
286 void SetStart(long start) { m_start = start; }
287 long GetStart() const { return m_start; }
288
289 void SetEnd(long end) { m_end = end; }
290 long GetEnd() const { return m_end; }
291
292 /// Returns true if this range is completely outside 'range'
293 bool IsOutside(const wxRichTextRange& range) const { return range.m_start > m_end || range.m_end < m_start; }
294
295 /// Returns true if this range is completely within 'range'
296 bool IsWithin(const wxRichTextRange& range) const { return m_start >= range.m_start && m_end <= range.m_end; }
297
298 /// Returns true if the given position is within this range. Allow
299 /// for the possibility of an empty range - assume the position
300 /// is within this empty range. NO, I think we should not match with an empty range.
301 // bool Contains(long pos) const { return pos >= m_start && (pos <= m_end || GetLength() == 0); }
302 bool Contains(long pos) const { return pos >= m_start && pos <= m_end ; }
303
304 /// Limit this range to be within 'range'
305 bool LimitTo(const wxRichTextRange& range) ;
306
307 /// Gets the length of the range
308 long GetLength() const { return m_end - m_start + 1; }
309
310 /// Swaps the start and end
311 void Swap() { long tmp = m_start; m_start = m_end; m_end = tmp; }
312
313 /// Convert to internal form: (n, n) is the range of a single character.
314 wxRichTextRange ToInternal() const { return wxRichTextRange(m_start, m_end-1); }
315
316 /// Convert from internal to public API form: (n, n+1) is the range of a single character.
317 wxRichTextRange FromInternal() const { return wxRichTextRange(m_start, m_end+1); }
318
319protected:
320 long m_start;
321 long m_end;
322};
323
324#define wxRICHTEXT_ALL wxRichTextRange(-2, -2)
325#define wxRICHTEXT_NONE wxRichTextRange(-1, -1)
326
327/*!
328 * wxRichTextObject class declaration
329 * This is the base for drawable objects.
330 */
331
332class WXDLLIMPEXP_RICHTEXT wxRichTextObject: public wxObject
333{
334 DECLARE_CLASS(wxRichTextObject)
335public:
336// Constructors
337
338 wxRichTextObject(wxRichTextObject* parent = NULL);
339 virtual ~wxRichTextObject();
340
341// Overrideables
342
343 /// Draw the item, within the given range. Some objects may ignore the range (for
344 /// example paragraphs) while others must obey it (lines, to implement wrapping)
345 virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style) = 0;
346
347 /// Lay the item out at the specified position with the given size constraint.
348 /// Layout must set the cached size.
349 virtual bool Layout(wxDC& dc, const wxRect& rect, int style) = 0;
350
351 /// Hit-testing: returns a flag indicating hit test details, plus
352 /// information about position
353 virtual int HitTest(wxDC& WXUNUSED(dc), const wxPoint& WXUNUSED(pt), long& WXUNUSED(textPosition)) { return false; }
354
355 /// Finds the absolute position and row height for the given character position
356 virtual bool FindPosition(wxDC& WXUNUSED(dc), long WXUNUSED(index), wxPoint& WXUNUSED(pt), int* WXUNUSED(height), bool WXUNUSED(forceLineStart)) { return false; }
357
358 /// Get the best size, i.e. the ideal starting size for this object irrespective
359 /// of available space. For a short text string, it will be the size that exactly encloses
360 /// the text. For a longer string, it might use the parent width for example.
361 virtual wxSize GetBestSize() const { return m_size; }
362
363 /// Get the object size for the given range. Returns false if the range
364 /// is invalid for this object.
365 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const = 0;
366
367 /// Do a split, returning an object containing the second part, and setting
368 /// the first part in 'this'.
369 virtual wxRichTextObject* DoSplit(long WXUNUSED(pos)) { return NULL; }
370
371 /// Calculate range. By default, guess that the object is 1 unit long.
372 virtual void CalculateRange(long start, long& end) { end = start ; m_range.SetRange(start, end); }
373
374 /// Delete range
375 virtual bool DeleteRange(const wxRichTextRange& WXUNUSED(range)) { return false; }
376
377 /// Returns true if the object is empty
378 virtual bool IsEmpty() const { return false; }
379
380 /// Get any text in this object for the given range
381 virtual wxString GetTextForRange(const wxRichTextRange& WXUNUSED(range)) const { return wxEmptyString; }
382
383 /// Returns true if this object can merge itself with the given one.
384 virtual bool CanMerge(wxRichTextObject* WXUNUSED(object)) const { return false; }
385
386 /// Returns true if this object merged itself with the given one.
387 /// The calling code will then delete the given object.
388 virtual bool Merge(wxRichTextObject* WXUNUSED(object)) { return false; }
389
390 /// Dump to output stream for debugging
391 virtual void Dump(wxTextOutputStream& stream);
392
393// Accessors
394
395 /// Get/set the cached object size as calculated by Layout.
396 virtual wxSize GetCachedSize() const { return m_size; }
397 virtual void SetCachedSize(const wxSize& sz) { m_size = sz; }
398
399 /// Get/set the object position
400 virtual wxPoint GetPosition() const { return m_pos; }
401 virtual void SetPosition(const wxPoint& pos) { m_pos = pos; }
402
403 /// Get the rectangle enclosing the object
404 virtual wxRect GetRect() const { return wxRect(GetPosition(), GetCachedSize()); }
405
406 /// Set the range
407 void SetRange(const wxRichTextRange& range) { m_range = range; }
408
409 /// Get the range
410 const wxRichTextRange& GetRange() const { return m_range; }
411 wxRichTextRange& GetRange() { return m_range; }
412
413 /// Get/set dirty flag (whether the object needs Layout to be called)
414 virtual bool GetDirty() const { return m_dirty; }
415 virtual void SetDirty(bool dirty) { m_dirty = dirty; }
416
417 /// Is this composite?
418 virtual bool IsComposite() const { return false; }
419
420 /// Get/set the parent.
421 virtual wxRichTextObject* GetParent() const { return m_parent; }
422 virtual void SetParent(wxRichTextObject* parent) { m_parent = parent; }
423
424 /// Set the margin around the object
425 virtual void SetMargins(int margin);
426 virtual void SetMargins(int leftMargin, int rightMargin, int topMargin, int bottomMargin);
427 virtual int GetLeftMargin() const { return m_leftMargin; }
428 virtual int GetRightMargin() const { return m_rightMargin; }
429 virtual int GetTopMargin() const { return m_topMargin; }
430 virtual int GetBottomMargin() const { return m_bottomMargin; }
431
432 /// Set attributes object
433 void SetAttributes(const wxTextAttr& attr) { m_attributes = attr; }
434 const wxTextAttr& GetAttributes() const { return m_attributes; }
435 wxTextAttr& GetAttributes() { return m_attributes; }
436
437 /// Set/get stored descent
438 void SetDescent(int descent) { m_descent = descent; }
439 int GetDescent() const { return m_descent; }
440
441 /// Gets the containing buffer
442 wxRichTextBuffer* GetBuffer() const;
443
444// Operations
445
446 /// Clone the object
447 virtual wxRichTextObject* Clone() const { return NULL; }
448
449 /// Copy
450 void Copy(const wxRichTextObject& obj);
451
452 /// Reference-counting allows us to use the same object in multiple
453 /// lists (not yet used)
454 void Reference() { m_refCount ++; }
455 void Dereference();
456
457 /// Convert units in tenths of a millimetre to device units
458 int ConvertTenthsMMToPixels(wxDC& dc, int units);
459 static int ConvertTenthsMMToPixels(int ppi, int units);
460
461protected:
462 wxSize m_size;
463 wxPoint m_pos;
464 int m_descent; // Descent for this object (if any)
465 bool m_dirty;
466 int m_refCount;
467 wxRichTextObject* m_parent;
468
469 /// The range of this object (start position to end position)
470 wxRichTextRange m_range;
471
472 /// Margins
473 int m_leftMargin;
474 int m_rightMargin;
475 int m_topMargin;
476 int m_bottomMargin;
477
478 /// Attributes
479 wxTextAttr m_attributes;
480};
481
482WX_DECLARE_LIST_WITH_DECL( wxRichTextObject, wxRichTextObjectList, class WXDLLIMPEXP_RICHTEXT );
483
484/*!
485 * wxRichTextCompositeObject class declaration
486 * Objects of this class can contain other objects.
487 */
488
489class WXDLLIMPEXP_RICHTEXT wxRichTextCompositeObject: public wxRichTextObject
490{
491 DECLARE_CLASS(wxRichTextCompositeObject)
492public:
493// Constructors
494
495 wxRichTextCompositeObject(wxRichTextObject* parent = NULL);
496 virtual ~wxRichTextCompositeObject();
497
498// Overrideables
499
500 /// Hit-testing: returns a flag indicating hit test details, plus
501 /// information about position
502 virtual int HitTest(wxDC& dc, const wxPoint& pt, long& textPosition);
503
504 /// Finds the absolute position and row height for the given character position
505 virtual bool FindPosition(wxDC& dc, long index, wxPoint& pt, int* height, bool forceLineStart);
506
507 /// Calculate range
508 virtual void CalculateRange(long start, long& end);
509
510 /// Delete range
511 virtual bool DeleteRange(const wxRichTextRange& range);
512
513 /// Get any text in this object for the given range
514 virtual wxString GetTextForRange(const wxRichTextRange& range) const;
515
516 /// Dump to output stream for debugging
517 virtual void Dump(wxTextOutputStream& stream);
518
519// Accessors
520
521 /// Get the children
522 wxRichTextObjectList& GetChildren() { return m_children; }
523 const wxRichTextObjectList& GetChildren() const { return m_children; }
524
525 /// Get the child count
526 size_t GetChildCount() const ;
527
528 /// Get the nth child
529 wxRichTextObject* GetChild(size_t n) const ;
530
531 /// Get/set dirty flag
532 virtual bool GetDirty() const { return m_dirty; }
533 virtual void SetDirty(bool dirty) { m_dirty = dirty; }
534
535 /// Is this composite?
536 virtual bool IsComposite() const { return true; }
537
538 /// Returns true if the buffer is empty
539 virtual bool IsEmpty() const { return GetChildCount() == 0; }
540
541// Operations
542
543 /// Copy
544 void Copy(const wxRichTextCompositeObject& obj);
545
546 /// Assignment
547 void operator= (const wxRichTextCompositeObject& obj) { Copy(obj); }
548
549 /// Append a child, returning the position
550 size_t AppendChild(wxRichTextObject* child) ;
551
552 /// Insert the child in front of the given object, or at the beginning
553 bool InsertChild(wxRichTextObject* child, wxRichTextObject* inFrontOf) ;
554
555 /// Delete the child
556 bool RemoveChild(wxRichTextObject* child, bool deleteChild = false) ;
557
558 /// Delete all children
559 bool DeleteChildren() ;
560
561 /// Recursively merge all pieces that can be merged.
562 bool Defragment(const wxRichTextRange& range = wxRICHTEXT_ALL);
563
564protected:
565 wxRichTextObjectList m_children;
566};
567
568/*!
569 * wxRichTextBox class declaration
570 * This defines a 2D space to lay out objects
571 */
572
573class WXDLLIMPEXP_RICHTEXT wxRichTextBox: public wxRichTextCompositeObject
574{
575 DECLARE_DYNAMIC_CLASS(wxRichTextBox)
576public:
577// Constructors
578
579 wxRichTextBox(wxRichTextObject* parent = NULL);
580 wxRichTextBox(const wxRichTextBox& obj): wxRichTextCompositeObject() { Copy(obj); }
581
582// Overrideables
583
584 /// Draw the item
585 virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style);
586
587 /// Lay the item out
588 virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
589
590 /// Get/set the object size for the given range. Returns false if the range
591 /// is invalid for this object.
592 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
593
594// Accessors
595
596// Operations
597
598 /// Clone
599 virtual wxRichTextObject* Clone() const { return new wxRichTextBox(*this); }
600
601 /// Copy
602 void Copy(const wxRichTextBox& obj);
603
604protected:
605};
606
607/*!
608 * wxRichTextParagraphBox class declaration
609 * This box knows how to lay out paragraphs.
610 */
611
612class WXDLLIMPEXP_RICHTEXT wxRichTextParagraphLayoutBox: public wxRichTextBox
613{
614 DECLARE_DYNAMIC_CLASS(wxRichTextParagraphLayoutBox)
615public:
616// Constructors
617
618 wxRichTextParagraphLayoutBox(wxRichTextObject* parent = NULL);
619 wxRichTextParagraphLayoutBox(const wxRichTextParagraphLayoutBox& obj): wxRichTextBox() { Init(); Copy(obj); }
620
621// Overrideables
622
623 /// Draw the item
624 virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style);
625
626 /// Lay the item out
627 virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
628
629 /// Get/set the object size for the given range. Returns false if the range
630 /// is invalid for this object.
631 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
632
633 /// Delete range
634 virtual bool DeleteRange(const wxRichTextRange& range);
635
636 /// Get any text in this object for the given range
637 virtual wxString GetTextForRange(const wxRichTextRange& range) const;
638
639// Accessors
640
641 /// Associate a control with the buffer, for operations that for example require refreshing the window.
642 void SetRichTextCtrl(wxRichTextCtrl* ctrl) { m_ctrl = ctrl; }
643
644 /// Get the associated control.
645 wxRichTextCtrl* GetRichTextCtrl() const { return m_ctrl; }
646
647 /// Get/set whether the last paragraph is partial or complete
648 void SetPartialParagraph(bool partialPara) { m_partialParagraph = partialPara; }
649 bool GetPartialParagraph() const { return m_partialParagraph; }
650
651 /// If this is a buffer, returns the current style sheet. The base layout box
652 /// class doesn't have an associated style sheet.
653 virtual wxRichTextStyleSheet* GetStyleSheet() const { return NULL; }
654
655// Operations
656
657 /// Initialize the object.
658 void Init();
659
660 /// Clear all children
661 virtual void Clear();
662
663 /// Clear and initialize with one blank paragraph
664 virtual void Reset();
665
666 /// Convenience function to add a paragraph of text
667 virtual wxRichTextRange AddParagraph(const wxString& text, wxTextAttr* paraStyle = NULL);
668
669 /// Convenience function to add an image
670 virtual wxRichTextRange AddImage(const wxImage& image, wxTextAttr* paraStyle = NULL);
671
672 /// Adds multiple paragraphs, based on newlines.
673 virtual wxRichTextRange AddParagraphs(const wxString& text, wxTextAttr* paraStyle = NULL);
674
675 /// Get the line at the given position. If caretPosition is true, the position is
676 /// a caret position, which is normally a smaller number.
677 virtual wxRichTextLine* GetLineAtPosition(long pos, bool caretPosition = false) const;
678
679 /// Get the line at the given y pixel position, or the last line.
680 virtual wxRichTextLine* GetLineAtYPosition(int y) const;
681
682 /// Get the paragraph at the given character or caret position
683 virtual wxRichTextParagraph* GetParagraphAtPosition(long pos, bool caretPosition = false) const;
684
685 /// Get the line size at the given position
686 virtual wxSize GetLineSizeAtPosition(long pos, bool caretPosition = false) const;
687
688 /// Given a position, get the number of the visible line (potentially many to a paragraph),
689 /// starting from zero at the start of the buffer. We also have to pass a bool (startOfLine)
690 /// that indicates whether the caret is being shown at the end of the previous line or at the start
691 /// of the next, since the caret can be shown at 2 visible positions for the same underlying
692 /// position.
693 virtual long GetVisibleLineNumber(long pos, bool caretPosition = false, bool startOfLine = false) const;
694
695 /// Given a line number, get the corresponding wxRichTextLine object.
696 virtual wxRichTextLine* GetLineForVisibleLineNumber(long lineNumber) const;
697
698 /// Get the leaf object in a paragraph at this position.
699 /// Given a line number, get the corresponding wxRichTextLine object.
700 virtual wxRichTextObject* GetLeafObjectAtPosition(long position) const;
701
702 /// Get the paragraph by number
703 virtual wxRichTextParagraph* GetParagraphAtLine(long paragraphNumber) const;
704
705 /// Get the paragraph for a given line
706 virtual wxRichTextParagraph* GetParagraphForLine(wxRichTextLine* line) const;
707
708 /// Get the length of the paragraph
709 virtual int GetParagraphLength(long paragraphNumber) const;
710
711 /// Get the number of paragraphs
712 virtual int GetParagraphCount() const { return static_cast<int>(GetChildCount()); }
713
714 /// Get the number of visible lines
715 virtual int GetLineCount() const;
716
717 /// Get the text of the paragraph
718 virtual wxString GetParagraphText(long paragraphNumber) const;
719
720 /// Convert zero-based line column and paragraph number to a position.
721 virtual long XYToPosition(long x, long y) const;
722
723 /// Convert zero-based position to line column and paragraph number
724 virtual bool PositionToXY(long pos, long* x, long* y) const;
725
726 /// Set text attributes: character and/or paragraph styles.
727 virtual bool SetStyle(const wxRichTextRange& range, const wxTextAttr& style, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
728
729 /// Get the conbined text attributes for this position.
730 virtual bool GetStyle(long position, wxTextAttr& style);
731
732 /// Get the content (uncombined) attributes for this position.
733 virtual bool GetUncombinedStyle(long position, wxTextAttr& style);
734
735 /// Implementation helper for GetStyle. If combineStyles is true, combine base, paragraph and
736 /// context attributes.
737 virtual bool DoGetStyle(long position, wxTextAttr& style, bool combineStyles = true);
738
739 /// Get the combined style for a range - if any attribute is different within the range,
740 /// that attribute is not present within the flags
741 virtual bool GetStyleForRange(const wxRichTextRange& range, wxTextAttr& style);
742
743 /// Combines 'style' with 'currentStyle' for the purpose of summarising the attributes of a range of
744 /// content.
745 bool CollectStyle(wxTextAttr& currentStyle, const wxTextAttr& style, long& multipleStyleAttributes, int& multipleTextEffectAttributes, int& absentStyleAttributes, int& absentTextEffectAttributes);
746
747 /// Set list style
748 virtual bool SetListStyle(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
749 virtual bool SetListStyle(const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
750
751 /// Clear list for given range
752 virtual bool ClearListStyle(const wxRichTextRange& range, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
753
754 /// Number/renumber any list elements in the given range.
755 /// def/defName can be NULL/empty to indicate that the existing list style should be used.
756 virtual bool NumberList(const wxRichTextRange& range, wxRichTextListStyleDefinition* def = NULL, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
757 virtual bool NumberList(const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
758
759 /// Promote the list items within the given range. promoteBy can be a positive or negative number, e.g. 1 or -1
760 /// def/defName can be NULL/empty to indicate that the existing list style should be used.
761 virtual bool PromoteList(int promoteBy, const wxRichTextRange& range, wxRichTextListStyleDefinition* def = NULL, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int specifiedLevel = -1);
762 virtual bool PromoteList(int promoteBy, const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int specifiedLevel = -1);
763
764 /// Helper for NumberList and PromoteList, that does renumbering and promotion simultaneously
765 /// def/defName can be NULL/empty to indicate that the existing list style should be used.
766 virtual bool DoNumberList(const wxRichTextRange& range, const wxRichTextRange& promotionRange, int promoteBy, wxRichTextListStyleDefinition* def, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
767
768 /// Fills in the attributes for numbering a paragraph after previousParagraph.
769 virtual bool FindNextParagraphNumber(wxRichTextParagraph* previousParagraph, wxTextAttr& attr) const;
770
771 /// Test if this whole range has character attributes of the specified kind. If any
772 /// of the attributes are different within the range, the test fails. You
773 /// can use this to implement, for example, bold button updating. style must have
774 /// flags indicating which attributes are of interest.
775 virtual bool HasCharacterAttributes(const wxRichTextRange& range, const wxTextAttr& style) const;
776
777 /// Test if this whole range has paragraph attributes of the specified kind. If any
778 /// of the attributes are different within the range, the test fails. You
779 /// can use this to implement, for example, centering button updating. style must have
780 /// flags indicating which attributes are of interest.
781 virtual bool HasParagraphAttributes(const wxRichTextRange& range, const wxTextAttr& style) const;
782
783 /// Clone
784 virtual wxRichTextObject* Clone() const { return new wxRichTextParagraphLayoutBox(*this); }
785
786 /// Insert fragment into this box at the given position. If partialParagraph is true,
787 /// it is assumed that the last (or only) paragraph is just a piece of data with no paragraph
788 /// marker.
789 virtual bool InsertFragment(long position, wxRichTextParagraphLayoutBox& fragment);
790
791 /// Make a copy of the fragment corresponding to the given range, putting it in 'fragment'.
792 virtual bool CopyFragment(const wxRichTextRange& range, wxRichTextParagraphLayoutBox& fragment);
793
794 /// Apply the style sheet to the buffer, for example if the styles have changed.
795 virtual bool ApplyStyleSheet(wxRichTextStyleSheet* styleSheet);
796
797 /// Copy
798 void Copy(const wxRichTextParagraphLayoutBox& obj);
799
800 /// Assignment
801 void operator= (const wxRichTextParagraphLayoutBox& obj) { Copy(obj); }
802
803 /// Calculate ranges
804 virtual void UpdateRanges() { long end; CalculateRange(0, end); }
805
806 /// Get all the text
807 virtual wxString GetText() const;
808
809 /// Set default style for new content. Setting it to a default attribute
810 /// makes new content take on the 'basic' style.
811 virtual bool SetDefaultStyle(const wxTextAttr& style);
812
813 /// Get default style
814 virtual const wxTextAttr& GetDefaultStyle() const { return m_defaultAttributes; }
815
816 /// Set basic (overall) style
817 virtual void SetBasicStyle(const wxTextAttr& style) { m_attributes = style; }
818
819 /// Get basic (overall) style
820 virtual const wxTextAttr& GetBasicStyle() const { return m_attributes; }
821
822 /// Invalidate the buffer. With no argument, invalidates whole buffer.
823 void Invalidate(const wxRichTextRange& invalidRange = wxRICHTEXT_ALL);
824
825 /// Get invalid range, rounding to entire paragraphs if argument is true.
826 wxRichTextRange GetInvalidRange(bool wholeParagraphs = false) const;
827
828protected:
829 wxRichTextCtrl* m_ctrl;
830 wxTextAttr m_defaultAttributes;
831
832 /// The invalidated range that will need full layout
833 wxRichTextRange m_invalidRange;
834
835 // Is the last paragraph partial or complete?
836 bool m_partialParagraph;
837};
838
839/*!
840 * wxRichTextLine class declaration
841 * This object represents a line in a paragraph, and stores
842 * offsets from the start of the paragraph representing the
843 * start and end positions of the line.
844 */
845
846class WXDLLIMPEXP_RICHTEXT wxRichTextLine
847{
848public:
849// Constructors
850
851 wxRichTextLine(wxRichTextParagraph* parent);
852 wxRichTextLine(const wxRichTextLine& obj) { Init( NULL); Copy(obj); }
853 virtual ~wxRichTextLine() {}
854
855// Overrideables
856
857// Accessors
858
859 /// Set the range
860 void SetRange(const wxRichTextRange& range) { m_range = range; }
861 void SetRange(long from, long to) { m_range = wxRichTextRange(from, to); }
862
863 /// Get the parent paragraph
864 wxRichTextParagraph* GetParent() { return m_parent; }
865
866 /// Get the range
867 const wxRichTextRange& GetRange() const { return m_range; }
868 wxRichTextRange& GetRange() { return m_range; }
869
870 /// Get the absolute range
871 wxRichTextRange GetAbsoluteRange() const;
872
873 /// Get/set the line size as calculated by Layout.
874 virtual wxSize GetSize() const { return m_size; }
875 virtual void SetSize(const wxSize& sz) { m_size = sz; }
876
877 /// Get/set the object position relative to the parent
878 virtual wxPoint GetPosition() const { return m_pos; }
879 virtual void SetPosition(const wxPoint& pos) { m_pos = pos; }
880
881 /// Get the absolute object position
882 virtual wxPoint GetAbsolutePosition() const;
883
884 /// Get the rectangle enclosing the line
885 virtual wxRect GetRect() const { return wxRect(GetAbsolutePosition(), GetSize()); }
886
887 /// Set/get stored descent
888 void SetDescent(int descent) { m_descent = descent; }
889 int GetDescent() const { return m_descent; }
890
891#if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING
892 wxArrayInt& GetObjectSizes() { return m_objectSizes; }
893 const wxArrayInt& GetObjectSizes() const { return m_objectSizes; }
894#endif
895
896// Operations
897
898 /// Initialisation
899 void Init(wxRichTextParagraph* parent);
900
901 /// Copy
902 void Copy(const wxRichTextLine& obj);
903
904 /// Clone
905 virtual wxRichTextLine* Clone() const { return new wxRichTextLine(*this); }
906
907protected:
908
909 /// The range of the line (start position to end position)
910 /// This is relative to the parent paragraph.
911 wxRichTextRange m_range;
912
913 /// Size and position measured relative to top of paragraph
914 wxPoint m_pos;
915 wxSize m_size;
916
917 /// Maximum descent for this line (location of text baseline)
918 int m_descent;
919
920 // The parent object
921 wxRichTextParagraph* m_parent;
922
923#if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING
924 wxArrayInt m_objectSizes;
925#endif
926};
927
928WX_DECLARE_LIST_WITH_DECL( wxRichTextLine, wxRichTextLineList , class WXDLLIMPEXP_RICHTEXT );
929
930/*!
931 * wxRichTextParagraph class declaration
932 * This object represents a single paragraph (or in a straight text editor, a line).
933 */
934
935class WXDLLIMPEXP_RICHTEXT wxRichTextParagraph: public wxRichTextBox
936{
937 DECLARE_DYNAMIC_CLASS(wxRichTextParagraph)
938public:
939// Constructors
940
941 wxRichTextParagraph(wxRichTextObject* parent = NULL, wxTextAttr* style = NULL);
942 wxRichTextParagraph(const wxString& text, wxRichTextObject* parent = NULL, wxTextAttr* paraStyle = NULL, wxTextAttr* charStyle = NULL);
943 virtual ~wxRichTextParagraph();
944 wxRichTextParagraph(const wxRichTextParagraph& obj): wxRichTextBox() { Copy(obj); }
945
946// Overrideables
947
948 /// Draw the item
949 virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style);
950
951 /// Lay the item out
952 virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
953
954 /// Get/set the object size for the given range. Returns false if the range
955 /// is invalid for this object.
956 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
957
958 /// Finds the absolute position and row height for the given character position
959 virtual bool FindPosition(wxDC& dc, long index, wxPoint& pt, int* height, bool forceLineStart);
960
961 /// Hit-testing: returns a flag indicating hit test details, plus
962 /// information about position
963 virtual int HitTest(wxDC& dc, const wxPoint& pt, long& textPosition);
964
965 /// Calculate range
966 virtual void CalculateRange(long start, long& end);
967
968// Accessors
969
970 /// Get the cached lines
971 wxRichTextLineList& GetLines() { return m_cachedLines; }
972
973// Operations
974
975 /// Copy
976 void Copy(const wxRichTextParagraph& obj);
977
978 /// Clone
979 virtual wxRichTextObject* Clone() const { return new wxRichTextParagraph(*this); }
980
981 /// Clear the cached lines
982 void ClearLines();
983
984// Implementation
985
986 /// Apply paragraph styles such as centering to the wrapped lines
987 virtual void ApplyParagraphStyle(const wxTextAttr& attr, const wxRect& rect, wxDC& dc);
988
989 /// Insert text at the given position
990 virtual bool InsertText(long pos, const wxString& text);
991
992 /// Split an object at this position if necessary, and return
993 /// the previous object, or NULL if inserting at beginning.
994 virtual wxRichTextObject* SplitAt(long pos, wxRichTextObject** previousObject = NULL);
995
996 /// Move content to a list from this point
997 virtual void MoveToList(wxRichTextObject* obj, wxList& list);
998
999 /// Add content back from list
1000 virtual void MoveFromList(wxList& list);
1001
1002 /// Get the plain text searching from the start or end of the range.
1003 /// The resulting string may be shorter than the range given.
1004 bool GetContiguousPlainText(wxString& text, const wxRichTextRange& range, bool fromStart = true);
1005
1006 /// Find a suitable wrap position. wrapPosition is the last position in the line to the left
1007 /// of the split.
1008 bool FindWrapPosition(const wxRichTextRange& range, wxDC& dc, int availableSpace, long& wrapPosition, wxArrayInt* partialExtents);
1009
1010 /// Find the object at the given position
1011 wxRichTextObject* FindObjectAtPosition(long position);
1012
1013 /// Get the bullet text for this paragraph.
1014 wxString GetBulletText();
1015
1016 /// Allocate or reuse a line object
1017 wxRichTextLine* AllocateLine(int pos);
1018
1019 /// Clear remaining unused line objects, if any
1020 bool ClearUnusedLines(int lineCount);
1021
1022 /// Get combined attributes of the base style, paragraph style and character style. We use this to dynamically
1023 /// retrieve the actual style.
1024 wxTextAttr GetCombinedAttributes(const wxTextAttr& contentStyle) const;
1025
1026 /// Get combined attributes of the base style and paragraph style.
1027 wxTextAttr GetCombinedAttributes() const;
1028
1029 /// Get the first position from pos that has a line break character.
1030 long GetFirstLineBreakPosition(long pos);
1031
1032 /// Create default tabstop array
1033 static void InitDefaultTabs();
1034
1035 /// Clear default tabstop array
1036 static void ClearDefaultTabs();
1037
1038 /// Get default tabstop array
1039 static const wxArrayInt& GetDefaultTabs() { return sm_defaultTabs; }
1040
1041protected:
1042 /// The lines that make up the wrapped paragraph
1043 wxRichTextLineList m_cachedLines;
1044
1045 /// Default tabstops
1046 static wxArrayInt sm_defaultTabs;
1047};
1048
1049/*!
1050 * wxRichTextPlainText class declaration
1051 * This object represents a single piece of text.
1052 */
1053
1054class WXDLLIMPEXP_RICHTEXT wxRichTextPlainText: public wxRichTextObject
1055{
1056 DECLARE_DYNAMIC_CLASS(wxRichTextPlainText)
1057public:
1058// Constructors
1059
1060 wxRichTextPlainText(const wxString& text = wxEmptyString, wxRichTextObject* parent = NULL, wxTextAttr* style = NULL);
1061 wxRichTextPlainText(const wxRichTextPlainText& obj): wxRichTextObject() { Copy(obj); }
1062
1063// Overrideables
1064
1065 /// Draw the item
1066 virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style);
1067
1068 /// Lay the item out
1069 virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
1070
1071 /// Get/set the object size for the given range. Returns false if the range
1072 /// is invalid for this object.
1073 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
1074
1075 /// Get any text in this object for the given range
1076 virtual wxString GetTextForRange(const wxRichTextRange& range) const;
1077
1078 /// Do a split, returning an object containing the second part, and setting
1079 /// the first part in 'this'.
1080 virtual wxRichTextObject* DoSplit(long pos);
1081
1082 /// Calculate range
1083 virtual void CalculateRange(long start, long& end);
1084
1085 /// Delete range
1086 virtual bool DeleteRange(const wxRichTextRange& range);
1087
1088 /// Returns true if the object is empty
1089 virtual bool IsEmpty() const { return m_text.empty(); }
1090
1091 /// Returns true if this object can merge itself with the given one.
1092 virtual bool CanMerge(wxRichTextObject* object) const;
1093
1094 /// Returns true if this object merged itself with the given one.
1095 /// The calling code will then delete the given object.
1096 virtual bool Merge(wxRichTextObject* object);
1097
1098 /// Dump to output stream for debugging
1099 virtual void Dump(wxTextOutputStream& stream);
1100
1101 /// Get the first position from pos that has a line break character.
1102 long GetFirstLineBreakPosition(long pos);
1103
1104// Accessors
1105
1106 /// Get the text
1107 const wxString& GetText() const { return m_text; }
1108
1109 /// Set the text
1110 void SetText(const wxString& text) { m_text = text; }
1111
1112// Operations
1113
1114 /// Copy
1115 void Copy(const wxRichTextPlainText& obj);
1116
1117 /// Clone
1118 virtual wxRichTextObject* Clone() const { return new wxRichTextPlainText(*this); }
1119private:
1120 bool DrawTabbedString(wxDC& dc, const wxTextAttr& attr, const wxRect& rect, wxString& str, wxCoord& x, wxCoord& y, bool selected);
1121
1122protected:
1123 wxString m_text;
1124};
1125
1126/*!
1127 * wxRichTextImageBlock stores information about an image, in binary in-memory form
1128 */
1129
1130class WXDLLIMPEXP_FWD_BASE wxDataInputStream;
1131class WXDLLIMPEXP_FWD_BASE wxDataOutputStream;
1132
1133class WXDLLIMPEXP_RICHTEXT wxRichTextImageBlock: public wxObject
1134{
1135public:
1136 wxRichTextImageBlock();
1137 wxRichTextImageBlock(const wxRichTextImageBlock& block);
1138 virtual ~wxRichTextImageBlock();
1139
1140 void Init();
1141 void Clear();
1142
1143 // Load the original image into a memory block.
1144 // If the image is not a JPEG, we must convert it into a JPEG
1145 // to conserve space.
1146 // If it's not a JPEG we can make use of 'image', already scaled, so we don't have to
1147 // load the image a 2nd time.
1148 virtual bool MakeImageBlock(const wxString& filename, wxBitmapType imageType,
1149 wxImage& image, bool convertToJPEG = true);
1150
1151 // Make an image block from the wxImage in the given
1152 // format.
1153 virtual bool MakeImageBlock(wxImage& image, wxBitmapType imageType, int quality = 80);
1154
1155 // Write to a file
1156 bool Write(const wxString& filename);
1157
1158 // Write data in hex to a stream
1159 bool WriteHex(wxOutputStream& stream);
1160
1161 // Read data in hex from a stream
1162 bool ReadHex(wxInputStream& stream, int length, wxBitmapType imageType);
1163
1164 // Copy from 'block'
1165 void Copy(const wxRichTextImageBlock& block);
1166
1167 // Load a wxImage from the block
1168 bool Load(wxImage& image);
1169
1170//// Operators
1171 void operator=(const wxRichTextImageBlock& block);
1172
1173//// Accessors
1174
1175 unsigned char* GetData() const { return m_data; }
1176 size_t GetDataSize() const { return m_dataSize; }
1177 wxBitmapType GetImageType() const { return m_imageType; }
1178
1179 void SetData(unsigned char* image) { m_data = image; }
1180 void SetDataSize(size_t size) { m_dataSize = size; }
1181 void SetImageType(wxBitmapType imageType) { m_imageType = imageType; }
1182
1183 bool Ok() const { return IsOk(); }
1184 bool IsOk() const { return GetData() != NULL; }
1185
1186 // Gets the extension for the block's type
1187 wxString GetExtension() const;
1188
1189/// Implementation
1190
1191 // Allocate and read from stream as a block of memory
1192 static unsigned char* ReadBlock(wxInputStream& stream, size_t size);
1193 static unsigned char* ReadBlock(const wxString& filename, size_t size);
1194
1195 // Write memory block to stream
1196 static bool WriteBlock(wxOutputStream& stream, unsigned char* block, size_t size);
1197
1198 // Write memory block to file
1199 static bool WriteBlock(const wxString& filename, unsigned char* block, size_t size);
1200
1201protected:
1202 // Size in bytes of the image stored.
1203 // This is in the raw, original form such as a JPEG file.
1204 unsigned char* m_data;
1205 size_t m_dataSize;
1206 wxBitmapType m_imageType;
1207};
1208
1209
1210/*!
1211 * wxRichTextImage class declaration
1212 * This object represents an image.
1213 */
1214
1215class WXDLLIMPEXP_RICHTEXT wxRichTextImage: public wxRichTextObject
1216{
1217 DECLARE_DYNAMIC_CLASS(wxRichTextImage)
1218public:
1219// Constructors
1220
1221 wxRichTextImage(wxRichTextObject* parent = NULL): wxRichTextObject(parent) { }
1222 wxRichTextImage(const wxImage& image, wxRichTextObject* parent = NULL, wxTextAttr* charStyle = NULL);
1223 wxRichTextImage(const wxRichTextImageBlock& imageBlock, wxRichTextObject* parent = NULL, wxTextAttr* charStyle = NULL);
1224 wxRichTextImage(const wxRichTextImage& obj): wxRichTextObject() { Copy(obj); }
1225
1226// Overrideables
1227
1228 /// Draw the item
1229 virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style);
1230
1231 /// Lay the item out
1232 virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
1233
1234 /// Get the object size for the given range. Returns false if the range
1235 /// is invalid for this object.
1236 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
1237
1238 /// Returns true if the object is empty
1239 virtual bool IsEmpty() const { return !m_image.Ok(); }
1240
1241// Accessors
1242
1243 /// Get the image
1244 const wxImage& GetImage() const { return m_image; }
1245
1246 /// Set the image
1247 void SetImage(const wxImage& image) { m_image = image; }
1248
1249 /// Get the image block containing the raw data
1250 wxRichTextImageBlock& GetImageBlock() { return m_imageBlock; }
1251
1252// Operations
1253
1254 /// Copy
1255 void Copy(const wxRichTextImage& obj);
1256
1257 /// Clone
1258 virtual wxRichTextObject* Clone() const { return new wxRichTextImage(*this); }
1259
1260 /// Load wxImage from the block
1261 virtual bool LoadFromBlock();
1262
1263 /// Make block from the wxImage
1264 virtual bool MakeBlock();
1265
1266protected:
1267 // TODO: reduce the multiple representations of data
1268 wxImage m_image;
1269 wxBitmap m_bitmap;
1270 wxRichTextImageBlock m_imageBlock;
1271};
1272
1273
1274/*!
1275 * wxRichTextBuffer class declaration
1276 * This is a kind of box, used to represent the whole buffer
1277 */
1278
1279class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextCommand;
1280class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextAction;
1281
1282class WXDLLIMPEXP_RICHTEXT wxRichTextBuffer: public wxRichTextParagraphLayoutBox
1283{
1284 DECLARE_DYNAMIC_CLASS(wxRichTextBuffer)
1285public:
1286// Constructors
1287
1288 wxRichTextBuffer() { Init(); }
1289 wxRichTextBuffer(const wxRichTextBuffer& obj): wxRichTextParagraphLayoutBox() { Init(); Copy(obj); }
1290 virtual ~wxRichTextBuffer() ;
1291
1292// Accessors
1293
1294 /// Gets the command processor
1295 wxCommandProcessor* GetCommandProcessor() const { return m_commandProcessor; }
1296
1297 /// Set style sheet, if any.
1298 void SetStyleSheet(wxRichTextStyleSheet* styleSheet) { m_styleSheet = styleSheet; }
1299 virtual wxRichTextStyleSheet* GetStyleSheet() const { return m_styleSheet; }
1300
1301 /// Set style sheet and notify of the change
1302 bool SetStyleSheetAndNotify(wxRichTextStyleSheet* sheet);
1303
1304 /// Push style sheet to top of stack
1305 bool PushStyleSheet(wxRichTextStyleSheet* styleSheet);
1306
1307 /// Pop style sheet from top of stack
1308 wxRichTextStyleSheet* PopStyleSheet();
1309
1310 /// Set/get table storing fonts
1311 wxRichTextFontTable& GetFontTable() { return m_fontTable; }
1312 const wxRichTextFontTable& GetFontTable() const { return m_fontTable; }
1313 void SetFontTable(const wxRichTextFontTable& table) { m_fontTable = table; }
1314
1315// Operations
1316
1317 /// Initialisation
1318 void Init();
1319
1320 /// Clears the buffer, adds an empty paragraph, and clears the command processor.
1321 virtual void ResetAndClearCommands();
1322
1323 /// Load a file
1324 virtual bool LoadFile(const wxString& filename, wxRichTextFileType type = wxRICHTEXT_TYPE_ANY);
1325
1326 /// Save a file
1327 virtual bool SaveFile(const wxString& filename, wxRichTextFileType type = wxRICHTEXT_TYPE_ANY);
1328
1329 /// Load from a stream
1330 virtual bool LoadFile(wxInputStream& stream, wxRichTextFileType type = wxRICHTEXT_TYPE_ANY);
1331
1332 /// Save to a stream
1333 virtual bool SaveFile(wxOutputStream& stream, wxRichTextFileType type = wxRICHTEXT_TYPE_ANY);
1334
1335 /// Set the handler flags, controlling loading and saving
1336 void SetHandlerFlags(int flags) { m_handlerFlags = flags; }
1337
1338 /// Get the handler flags, controlling loading and saving
1339 int GetHandlerFlags() const { return m_handlerFlags; }
1340
1341 /// Convenience function to add a paragraph of text
1342 virtual wxRichTextRange AddParagraph(const wxString& text, wxTextAttr* paraStyle = NULL) { Modify(); return wxRichTextParagraphLayoutBox::AddParagraph(text, paraStyle); }
1343
1344 /// Begin collapsing undo/redo commands. Note that this may not work properly
1345 /// if combining commands that delete or insert content, changing ranges for
1346 /// subsequent actions.
1347 virtual bool BeginBatchUndo(const wxString& cmdName);
1348
1349 /// End collapsing undo/redo commands
1350 virtual bool EndBatchUndo();
1351
1352 /// Collapsing commands?
1353 virtual bool BatchingUndo() const { return m_batchedCommandDepth > 0; }
1354
1355 /// Submit immediately, or delay according to whether collapsing is on
1356 virtual bool SubmitAction(wxRichTextAction* action);
1357
1358 /// Get collapsed command
1359 virtual wxRichTextCommand* GetBatchedCommand() const { return m_batchedCommand; }
1360
1361 /// Begin suppressing undo/redo commands. The way undo is suppressed may be implemented
1362 /// differently by each command. If not dealt with by a command implementation, then
1363 /// it will be implemented automatically by not storing the command in the undo history
1364 /// when the action is submitted to the command processor.
1365 virtual bool BeginSuppressUndo();
1366
1367 /// End suppressing undo/redo commands.
1368 virtual bool EndSuppressUndo();
1369
1370 /// Collapsing commands?
1371 virtual bool SuppressingUndo() const { return m_suppressUndo > 0; }
1372
1373 /// Copy the range to the clipboard
1374 virtual bool CopyToClipboard(const wxRichTextRange& range);
1375
1376 /// Paste the clipboard content to the buffer
1377 virtual bool PasteFromClipboard(long position);
1378
1379 /// Can we paste from the clipboard?
1380 virtual bool CanPasteFromClipboard() const;
1381
1382 /// Begin using a style
1383 virtual bool BeginStyle(const wxTextAttr& style);
1384
1385 /// End the style
1386 virtual bool EndStyle();
1387
1388 /// End all styles
1389 virtual bool EndAllStyles();
1390
1391 /// Clear the style stack
1392 virtual void ClearStyleStack();
1393
1394 /// Get the size of the style stack, for example to check correct nesting
1395 virtual size_t GetStyleStackSize() const { return m_attributeStack.GetCount(); }
1396
1397 /// Begin using bold
1398 bool BeginBold();
1399
1400 /// End using bold
1401 bool EndBold() { return EndStyle(); }
1402
1403 /// Begin using italic
1404 bool BeginItalic();
1405
1406 /// End using italic
1407 bool EndItalic() { return EndStyle(); }
1408
1409 /// Begin using underline
1410 bool BeginUnderline();
1411
1412 /// End using underline
1413 bool EndUnderline() { return EndStyle(); }
1414
1415 /// Begin using point size
1416 bool BeginFontSize(int pointSize);
1417
1418 /// End using point size
1419 bool EndFontSize() { return EndStyle(); }
1420
1421 /// Begin using this font
1422 bool BeginFont(const wxFont& font);
1423
1424 /// End using a font
1425 bool EndFont() { return EndStyle(); }
1426
1427 /// Begin using this colour
1428 bool BeginTextColour(const wxColour& colour);
1429
1430 /// End using a colour
1431 bool EndTextColour() { return EndStyle(); }
1432
1433 /// Begin using alignment
1434 bool BeginAlignment(wxTextAttrAlignment alignment);
1435
1436 /// End alignment
1437 bool EndAlignment() { return EndStyle(); }
1438
1439 /// Begin left indent
1440 bool BeginLeftIndent(int leftIndent, int leftSubIndent = 0);
1441
1442 /// End left indent
1443 bool EndLeftIndent() { return EndStyle(); }
1444
1445 /// Begin right indent
1446 bool BeginRightIndent(int rightIndent);
1447
1448 /// End right indent
1449 bool EndRightIndent() { return EndStyle(); }
1450
1451 /// Begin paragraph spacing
1452 bool BeginParagraphSpacing(int before, int after);
1453
1454 /// End paragraph spacing
1455 bool EndParagraphSpacing() { return EndStyle(); }
1456
1457 /// Begin line spacing
1458 bool BeginLineSpacing(int lineSpacing);
1459
1460 /// End line spacing
1461 bool EndLineSpacing() { return EndStyle(); }
1462
1463 /// Begin numbered bullet
1464 bool BeginNumberedBullet(int bulletNumber, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_ARABIC|wxTEXT_ATTR_BULLET_STYLE_PERIOD);
1465
1466 /// End numbered bullet
1467 bool EndNumberedBullet() { return EndStyle(); }
1468
1469 /// Begin symbol bullet
1470 bool BeginSymbolBullet(const wxString& symbol, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_SYMBOL);
1471
1472 /// End symbol bullet
1473 bool EndSymbolBullet() { return EndStyle(); }
1474
1475 /// Begin standard bullet
1476 bool BeginStandardBullet(const wxString& bulletName, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_STANDARD);
1477
1478 /// End standard bullet
1479 bool EndStandardBullet() { return EndStyle(); }
1480
1481 /// Begin named character style
1482 bool BeginCharacterStyle(const wxString& characterStyle);
1483
1484 /// End named character style
1485 bool EndCharacterStyle() { return EndStyle(); }
1486
1487 /// Begin named paragraph style
1488 bool BeginParagraphStyle(const wxString& paragraphStyle);
1489
1490 /// End named character style
1491 bool EndParagraphStyle() { return EndStyle(); }
1492
1493 /// Begin named list style
1494 bool BeginListStyle(const wxString& listStyle, int level = 1, int number = 1);
1495
1496 /// End named character style
1497 bool EndListStyle() { return EndStyle(); }
1498
1499 /// Begin URL
1500 bool BeginURL(const wxString& url, const wxString& characterStyle = wxEmptyString);
1501
1502 /// End URL
1503 bool EndURL() { return EndStyle(); }
1504
1505// Event handling
1506
1507 /// Add an event handler
1508 bool AddEventHandler(wxEvtHandler* handler);
1509
1510 /// Remove an event handler
1511 bool RemoveEventHandler(wxEvtHandler* handler, bool deleteHandler = false);
1512
1513 /// Clear event handlers
1514 void ClearEventHandlers();
1515
1516 /// Send event to event handlers. If sendToAll is true, will send to all event handlers,
1517 /// otherwise will stop at the first successful one.
1518 bool SendEvent(wxEvent& event, bool sendToAll = true);
1519
1520// Implementation
1521
1522 /// Copy
1523 void Copy(const wxRichTextBuffer& obj);
1524
1525 /// Clone
1526 virtual wxRichTextObject* Clone() const { return new wxRichTextBuffer(*this); }
1527
1528 /// Submit command to insert paragraphs
1529 bool InsertParagraphsWithUndo(long pos, const wxRichTextParagraphLayoutBox& paragraphs, wxRichTextCtrl* ctrl, int flags = 0);
1530
1531 /// Submit command to insert the given text
1532 bool InsertTextWithUndo(long pos, const wxString& text, wxRichTextCtrl* ctrl, int flags = 0);
1533
1534 /// Submit command to insert a newline
1535 bool InsertNewlineWithUndo(long pos, wxRichTextCtrl* ctrl, int flags = 0);
1536
1537 /// Submit command to insert the given image
1538 bool InsertImageWithUndo(long pos, const wxRichTextImageBlock& imageBlock, wxRichTextCtrl* ctrl, int flags = 0);
1539
1540 /// Submit command to delete this range
1541 bool DeleteRangeWithUndo(const wxRichTextRange& range, wxRichTextCtrl* ctrl);
1542
1543 /// Mark modified
1544 void Modify(bool modify = true) { m_modified = modify; }
1545 bool IsModified() const { return m_modified; }
1546
1547 /// Get the style that is appropriate for a new paragraph at this position.
1548 /// If the previous paragraph has a paragraph style name, look up the next-paragraph
1549 /// style.
1550 wxTextAttr GetStyleForNewParagraph(long pos, bool caretPosition = false, bool lookUpNewParaStyle=false) const;
1551
1552 /// Dumps contents of buffer for debugging purposes
1553 virtual void Dump();
1554 virtual void Dump(wxTextOutputStream& stream) { wxRichTextParagraphLayoutBox::Dump(stream); }
1555
1556 /// Returns the file handlers
1557 static wxList& GetHandlers() { return sm_handlers; }
1558
1559 /// Adds a handler to the end
1560 static void AddHandler(wxRichTextFileHandler *handler);
1561
1562 /// Inserts a handler at the front
1563 static void InsertHandler(wxRichTextFileHandler *handler);
1564
1565 /// Removes a handler
1566 static bool RemoveHandler(const wxString& name);
1567
1568 /// Finds a handler by name
1569 static wxRichTextFileHandler *FindHandler(const wxString& name);
1570
1571 /// Finds a handler by extension and type
1572 static wxRichTextFileHandler *FindHandler(const wxString& extension, wxRichTextFileType imageType);
1573
1574 /// Finds a handler by filename or, if supplied, type
1575 static wxRichTextFileHandler *FindHandlerFilenameOrType(const wxString& filename,
1576 wxRichTextFileType imageType);
1577
1578 /// Finds a handler by type
1579 static wxRichTextFileHandler *FindHandler(wxRichTextFileType imageType);
1580
1581 /// Gets a wildcard incorporating all visible handlers. If 'types' is present,
1582 /// will be filled with the file type corresponding to each filter. This can be
1583 /// used to determine the type to pass to LoadFile given a selected filter.
1584 static wxString GetExtWildcard(bool combine = false, bool save = false, wxArrayInt* types = NULL);
1585
1586 /// Clean up handlers
1587 static void CleanUpHandlers();
1588
1589 /// Initialise the standard handlers
1590 static void InitStandardHandlers();
1591
1592 /// Get renderer
1593 static wxRichTextRenderer* GetRenderer() { return sm_renderer; }
1594
1595 /// Set renderer, deleting old one
1596 static void SetRenderer(wxRichTextRenderer* renderer);
1597
1598 /// Minimum margin between bullet and paragraph in 10ths of a mm
1599 static int GetBulletRightMargin() { return sm_bulletRightMargin; }
1600 static void SetBulletRightMargin(int margin) { sm_bulletRightMargin = margin; }
1601
1602 /// Factor to multiply by character height to get a reasonable bullet size
1603 static float GetBulletProportion() { return sm_bulletProportion; }
1604 static void SetBulletProportion(float prop) { sm_bulletProportion = prop; }
1605
1606 /// Scale factor for calculating dimensions
1607 double GetScale() const { return m_scale; }
1608 void SetScale(double scale) { m_scale = scale; }
1609
1610protected:
1611
1612 /// Command processor
1613 wxCommandProcessor* m_commandProcessor;
1614
1615 /// Table storing fonts
1616 wxRichTextFontTable m_fontTable;
1617
1618 /// Has been modified?
1619 bool m_modified;
1620
1621 /// Collapsed command stack
1622 int m_batchedCommandDepth;
1623
1624 /// Name for collapsed command
1625 wxString m_batchedCommandsName;
1626
1627 /// Current collapsed command accumulating actions
1628 wxRichTextCommand* m_batchedCommand;
1629
1630 /// Whether to suppress undo
1631 int m_suppressUndo;
1632
1633 /// Style sheet, if any
1634 wxRichTextStyleSheet* m_styleSheet;
1635
1636 /// List of event handlers that will be notified of events
1637 wxList m_eventHandlers;
1638
1639 /// Stack of attributes for convenience functions
1640 wxList m_attributeStack;
1641
1642 /// Flags to be passed to handlers
1643 int m_handlerFlags;
1644
1645 /// File handlers
1646 static wxList sm_handlers;
1647
1648 /// Renderer
1649 static wxRichTextRenderer* sm_renderer;
1650
1651 /// Minimum margin between bullet and paragraph in 10ths of a mm
1652 static int sm_bulletRightMargin;
1653
1654 /// Factor to multiply by character height to get a reasonable bullet size
1655 static float sm_bulletProportion;
1656
1657 /// Scaling factor in use: needed to calculate correct dimensions when printing
1658 double m_scale;
1659};
1660
1661/*!
1662 * The command identifiers
1663 *
1664 */
1665
1666enum wxRichTextCommandId
1667{
1668 wxRICHTEXT_INSERT,
1669 wxRICHTEXT_DELETE,
1670 wxRICHTEXT_CHANGE_STYLE
1671};
1672
1673/*!
1674 * Command classes for undo/redo
1675 *
1676 */
1677
1678class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextAction;
1679class WXDLLIMPEXP_RICHTEXT wxRichTextCommand: public wxCommand
1680{
1681public:
1682 // Ctor for one action
1683 wxRichTextCommand(const wxString& name, wxRichTextCommandId id, wxRichTextBuffer* buffer,
1684 wxRichTextCtrl* ctrl, bool ignoreFirstTime = false);
1685
1686 // Ctor for multiple actions
1687 wxRichTextCommand(const wxString& name);
1688
1689 virtual ~wxRichTextCommand();
1690
1691 bool Do();
1692 bool Undo();
1693
1694 void AddAction(wxRichTextAction* action);
1695 void ClearActions();
1696
1697 wxList& GetActions() { return m_actions; }
1698
1699protected:
1700
1701 wxList m_actions;
1702};
1703
1704/*!
1705 * wxRichTextAction class declaration
1706 * There can be more than one action in a command.
1707 */
1708
1709class WXDLLIMPEXP_RICHTEXT wxRichTextAction: public wxObject
1710{
1711public:
1712 wxRichTextAction(wxRichTextCommand* cmd, const wxString& name, wxRichTextCommandId id, wxRichTextBuffer* buffer,
1713 wxRichTextCtrl* ctrl, bool ignoreFirstTime = false);
1714
1715 virtual ~wxRichTextAction();
1716
1717 bool Do();
1718 bool Undo();
1719
1720 /// Update the control appearance
1721 void UpdateAppearance(long caretPosition, bool sendUpdateEvent = false,
1722 wxArrayInt* optimizationLineCharPositions = NULL, wxArrayInt* optimizationLineYPositions = NULL, bool isDoCmd = true);
1723
1724 /// Replace the buffer paragraphs with the given fragment.
1725 void ApplyParagraphs(const wxRichTextParagraphLayoutBox& fragment);
1726
1727 /// Get the fragments
1728 wxRichTextParagraphLayoutBox& GetNewParagraphs() { return m_newParagraphs; }
1729 wxRichTextParagraphLayoutBox& GetOldParagraphs() { return m_oldParagraphs; }
1730
1731 /// Calculate arrays for refresh optimization
1732 void CalculateRefreshOptimizations(wxArrayInt& optimizationLineCharPositions, wxArrayInt& optimizationLineYPositions);
1733
1734 /// Set/get the position used for e.g. insertion
1735 void SetPosition(long pos) { m_position = pos; }
1736 long GetPosition() const { return m_position; }
1737
1738 /// Set/get the range for e.g. deletion
1739 void SetRange(const wxRichTextRange& range) { m_range = range; }
1740 const wxRichTextRange& GetRange() const { return m_range; }
1741
1742 /// Get name
1743 const wxString& GetName() const { return m_name; }
1744
1745protected:
1746 // Action name
1747 wxString m_name;
1748
1749 // Buffer
1750 wxRichTextBuffer* m_buffer;
1751
1752 // Control
1753 wxRichTextCtrl* m_ctrl;
1754
1755 // Stores the new paragraphs
1756 wxRichTextParagraphLayoutBox m_newParagraphs;
1757
1758 // Stores the old paragraphs
1759 wxRichTextParagraphLayoutBox m_oldParagraphs;
1760
1761 // The affected range
1762 wxRichTextRange m_range;
1763
1764 // The insertion point for this command
1765 long m_position;
1766
1767 // Ignore 1st 'Do' operation because we already did it
1768 bool m_ignoreThis;
1769
1770 // The command identifier
1771 wxRichTextCommandId m_cmdId;
1772};
1773
1774/*!
1775 * Handler flags
1776 */
1777
1778// Include style sheet when loading and saving
1779#define wxRICHTEXT_HANDLER_INCLUDE_STYLESHEET 0x0001
1780
1781// Save images to memory file system in HTML handler
1782#define wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_MEMORY 0x0010
1783
1784// Save images to files in HTML handler
1785#define wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_FILES 0x0020
1786
1787// Save images as inline base64 data in HTML handler
1788#define wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_BASE64 0x0040
1789
1790// Don't write header and footer (or BODY), so we can include the fragment
1791// in a larger document
1792#define wxRICHTEXT_HANDLER_NO_HEADER_FOOTER 0x0080
1793
1794// Convert the more common face names to names that will work on the current platform
1795// in a larger document
1796#define wxRICHTEXT_HANDLER_CONVERT_FACENAMES 0x0100
1797
1798/*!
1799 * wxRichTextFileHandler
1800 * Base class for file handlers
1801 */
1802
1803class WXDLLIMPEXP_RICHTEXT wxRichTextFileHandler: public wxObject
1804{
1805 DECLARE_CLASS(wxRichTextFileHandler)
1806public:
1807 wxRichTextFileHandler(const wxString& name = wxEmptyString, const wxString& ext = wxEmptyString, int type = 0)
1808 : m_name(name), m_extension(ext), m_type(type), m_flags(0), m_visible(true)
1809 { }
1810
1811#if wxUSE_STREAMS
1812 bool LoadFile(wxRichTextBuffer *buffer, wxInputStream& stream)
1813 { return DoLoadFile(buffer, stream); }
1814 bool SaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream)
1815 { return DoSaveFile(buffer, stream); }
1816#endif
1817
1818#if wxUSE_FFILE && wxUSE_STREAMS
1819 virtual bool LoadFile(wxRichTextBuffer *buffer, const wxString& filename);
1820 virtual bool SaveFile(wxRichTextBuffer *buffer, const wxString& filename);
1821#endif // wxUSE_STREAMS && wxUSE_STREAMS
1822
1823 /// Can we handle this filename (if using files)? By default, checks the extension.
1824 virtual bool CanHandle(const wxString& filename) const;
1825
1826 /// Can we save using this handler?
1827 virtual bool CanSave() const { return false; }
1828
1829 /// Can we load using this handler?
1830 virtual bool CanLoad() const { return false; }
1831
1832 /// Should this handler be visible to the user?
1833 virtual bool IsVisible() const { return m_visible; }
1834 virtual void SetVisible(bool visible) { m_visible = visible; }
1835
1836 /// The name of the nandler
1837 void SetName(const wxString& name) { m_name = name; }
1838 wxString GetName() const { return m_name; }
1839
1840 /// The default extension to recognise
1841 void SetExtension(const wxString& ext) { m_extension = ext; }
1842 wxString GetExtension() const { return m_extension; }
1843
1844 /// The handler type
1845 void SetType(int type) { m_type = type; }
1846 int GetType() const { return m_type; }
1847
1848 /// Flags controlling how loading and saving is done
1849 void SetFlags(int flags) { m_flags = flags; }
1850 int GetFlags() const { return m_flags; }
1851
1852 /// Encoding to use when saving a file. If empty, a suitable encoding is chosen
1853 void SetEncoding(const wxString& encoding) { m_encoding = encoding; }
1854 const wxString& GetEncoding() const { return m_encoding; }
1855
1856protected:
1857
1858#if wxUSE_STREAMS
1859 virtual bool DoLoadFile(wxRichTextBuffer *buffer, wxInputStream& stream) = 0;
1860 virtual bool DoSaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream) = 0;
1861#endif
1862
1863 wxString m_name;
1864 wxString m_encoding;
1865 wxString m_extension;
1866 int m_type;
1867 int m_flags;
1868 bool m_visible;
1869};
1870
1871/*!
1872 * wxRichTextPlainTextHandler
1873 * Plain text handler
1874 */
1875
1876class WXDLLIMPEXP_RICHTEXT wxRichTextPlainTextHandler: public wxRichTextFileHandler
1877{
1878 DECLARE_CLASS(wxRichTextPlainTextHandler)
1879public:
1880 wxRichTextPlainTextHandler(const wxString& name = wxT("Text"),
1881 const wxString& ext = wxT("txt"),
1882 wxRichTextFileType type = wxRICHTEXT_TYPE_TEXT)
1883 : wxRichTextFileHandler(name, ext, type)
1884 { }
1885
1886 /// Can we save using this handler?
1887 virtual bool CanSave() const { return true; }
1888
1889 /// Can we load using this handler?
1890 virtual bool CanLoad() const { return true; }
1891
1892protected:
1893
1894#if wxUSE_STREAMS
1895 virtual bool DoLoadFile(wxRichTextBuffer *buffer, wxInputStream& stream);
1896 virtual bool DoSaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream);
1897#endif
1898
1899};
1900
1901#if wxUSE_DATAOBJ
1902
1903/*!
1904 * The data object for a wxRichTextBuffer
1905 */
1906
1907class WXDLLIMPEXP_RICHTEXT wxRichTextBufferDataObject: public wxDataObjectSimple
1908{
1909public:
1910 // ctor doesn't copy the pointer, so it shouldn't go away while this object
1911 // is alive
1912 wxRichTextBufferDataObject(wxRichTextBuffer* richTextBuffer = NULL);
1913 virtual ~wxRichTextBufferDataObject();
1914
1915 // after a call to this function, the buffer is owned by the caller and it
1916 // is responsible for deleting it
1917 wxRichTextBuffer* GetRichTextBuffer();
1918
1919 // Returns the id for the new data format
1920 static const wxChar* GetRichTextBufferFormatId() { return ms_richTextBufferFormatId; }
1921
1922 // base class pure virtuals
1923
1924 virtual wxDataFormat GetPreferredFormat(Direction dir) const;
1925 virtual size_t GetDataSize() const;
1926 virtual bool GetDataHere(void *pBuf) const;
1927 virtual bool SetData(size_t len, const void *buf);
1928
1929 // prevent warnings
1930
1931 virtual size_t GetDataSize(const wxDataFormat&) const { return GetDataSize(); }
1932 virtual bool GetDataHere(const wxDataFormat&, void *buf) const { return GetDataHere(buf); }
1933 virtual bool SetData(const wxDataFormat&, size_t len, const void *buf) { return SetData(len, buf); }
1934
1935private:
1936 wxDataFormat m_formatRichTextBuffer; // our custom format
1937 wxRichTextBuffer* m_richTextBuffer; // our data
1938 static const wxChar* ms_richTextBufferFormatId; // our format id
1939};
1940
1941#endif
1942
1943/*!
1944 * wxRichTextRenderer isolates common drawing functionality
1945 */
1946
1947class WXDLLIMPEXP_RICHTEXT wxRichTextRenderer: public wxObject
1948{
1949public:
1950 wxRichTextRenderer() {}
1951 virtual ~wxRichTextRenderer() {}
1952
1953 /// Draw a standard bullet, as specified by the value of GetBulletName
1954 virtual bool DrawStandardBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxTextAttr& attr, const wxRect& rect) = 0;
1955
1956 /// Draw a bullet that can be described by text, such as numbered or symbol bullets
1957 virtual bool DrawTextBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxTextAttr& attr, const wxRect& rect, const wxString& text) = 0;
1958
1959 /// Draw a bitmap bullet, where the bullet bitmap is specified by the value of GetBulletName
1960 virtual bool DrawBitmapBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxTextAttr& attr, const wxRect& rect) = 0;
1961
1962 /// Enumerate the standard bullet names currently supported
1963 virtual bool EnumerateStandardBulletNames(wxArrayString& bulletNames) = 0;
1964};
1965
1966/*!
1967 * wxRichTextStdRenderer: standard renderer
1968 */
1969
1970class WXDLLIMPEXP_RICHTEXT wxRichTextStdRenderer: public wxRichTextRenderer
1971{
1972public:
1973 wxRichTextStdRenderer() {}
1974
1975 /// Draw a standard bullet, as specified by the value of GetBulletName
1976 virtual bool DrawStandardBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxTextAttr& attr, const wxRect& rect);
1977
1978 /// Draw a bullet that can be described by text, such as numbered or symbol bullets
1979 virtual bool DrawTextBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxTextAttr& attr, const wxRect& rect, const wxString& text);
1980
1981 /// Draw a bitmap bullet, where the bullet bitmap is specified by the value of GetBulletName
1982 virtual bool DrawBitmapBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxTextAttr& attr, const wxRect& rect);
1983
1984 /// Enumerate the standard bullet names currently supported
1985 virtual bool EnumerateStandardBulletNames(wxArrayString& bulletNames);
1986};
1987
1988/*!
1989 * Utilities
1990 *
1991 */
1992
1993inline bool wxRichTextHasStyle(int flags, int style)
1994{
1995 return ((flags & style) == style);
1996}
1997
1998/// Compare two attribute objects
1999WXDLLIMPEXP_RICHTEXT bool wxTextAttrEq(const wxTextAttr& attr1, const wxTextAttr& attr2);
2000WXDLLIMPEXP_RICHTEXT bool wxTextAttrEq(const wxTextAttr& attr1, const wxTextAttr& attr2);
2001
2002/// Compare two attribute objects, but take into account the flags
2003/// specifying attributes of interest.
2004WXDLLIMPEXP_RICHTEXT bool wxTextAttrEqPartial(const wxTextAttr& attr1, const wxTextAttr& attr2, int flags);
2005
2006/// Apply one style to another
2007WXDLLIMPEXP_RICHTEXT bool wxRichTextApplyStyle(wxTextAttr& destStyle, const wxTextAttr& style, wxTextAttr* compareWith = NULL);
2008
2009// Remove attributes
2010WXDLLIMPEXP_RICHTEXT bool wxRichTextRemoveStyle(wxTextAttr& destStyle, const wxTextAttr& style);
2011
2012/// Combine two bitlists
2013WXDLLIMPEXP_RICHTEXT bool wxRichTextCombineBitlists(int& valueA, int valueB, int& flagsA, int flagsB);
2014
2015/// Compare two bitlists
2016WXDLLIMPEXP_RICHTEXT bool wxRichTextBitlistsEqPartial(int valueA, int valueB, int flags);
2017
2018/// Split into paragraph and character styles
2019WXDLLIMPEXP_RICHTEXT bool wxRichTextSplitParaCharStyles(const wxTextAttr& style, wxTextAttr& parStyle, wxTextAttr& charStyle);
2020
2021/// Compare tabs
2022WXDLLIMPEXP_RICHTEXT bool wxRichTextTabsEq(const wxArrayInt& tabs1, const wxArrayInt& tabs2);
2023
2024/// Convert a decimal to Roman numerals
2025WXDLLIMPEXP_RICHTEXT wxString wxRichTextDecimalToRoman(long n);
2026
2027WXDLLIMPEXP_RICHTEXT void wxRichTextModuleInit();
2028
2029#endif
2030 // wxUSE_RICHTEXT
2031
2032#endif
2033 // _WX_RICHTEXTBUFFER_H_
2034