1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/richtext/richtextbuffer.h
3 // Purpose: Buffer for wxRichTextCtrl
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 #ifndef _WX_RICHTEXTBUFFER_H_
13 #define _WX_RICHTEXTBUFFER_H_
20 Data is represented by a hierarchy of objects, all derived from
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.
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.
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.
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.
63 #include "wx/textctrl.h"
64 #include "wx/bitmap.h"
66 #include "wx/cmdproc.h"
67 #include "wx/txtstrm.h"
70 #include "wx/dataobj.h"
74 #define wxRichTextAttr wxTextAttr
75 #define wxTextAttrEx wxTextAttr
77 // Setting wxRICHTEXT_USE_OWN_CARET to 1 implements a non-flashing
78 // cursor reliably without using wxClientDC in case there
79 // are platform-specific problems with the generic caret.
80 #define wxRICHTEXT_USE_OWN_CARET 0
82 // Switch off for binary compatibility, on for faster drawing
83 // Note: this seems to be buggy (overzealous use of extents) so
85 #define wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING 0
91 extern WXDLLIMPEXP_RICHTEXT
const wxChar wxRichTextLineBreakChar
;
94 * File types in wxRichText context.
96 enum wxRichTextFileType
98 wxRICHTEXT_TYPE_ANY
= 0,
101 wxRICHTEXT_TYPE_HTML
,
107 * Forward declarations
110 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextCtrl
;
111 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextObject
;
112 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextCacheObject
;
113 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextObjectList
;
114 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextLine
;
115 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextParagraph
;
116 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextFileHandler
;
117 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextStyleSheet
;
118 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextListStyleDefinition
;
119 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextEvent
;
120 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextRenderer
;
121 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextBuffer
;
124 * Flags determining the available space, passed to Layout
127 #define wxRICHTEXT_FIXED_WIDTH 0x01
128 #define wxRICHTEXT_FIXED_HEIGHT 0x02
129 #define wxRICHTEXT_VARIABLE_WIDTH 0x04
130 #define wxRICHTEXT_VARIABLE_HEIGHT 0x08
132 // Only lay out the part of the buffer that lies within
133 // the rect passed to Layout.
134 #define wxRICHTEXT_LAYOUT_SPECIFIED_RECT 0x10
137 * Flags to pass to Draw
140 // Ignore paragraph cache optimization, e.g. for printing purposes
141 // where one line may be drawn higher (on the next page) compared
142 // with the previous line
143 #define wxRICHTEXT_DRAW_IGNORE_CACHE 0x01
146 * Flags returned from hit-testing
148 enum wxRichTextHitTestFlags
150 // The point was not on this object
151 wxRICHTEXT_HITTEST_NONE
= 0x01,
153 // The point was before the position returned from HitTest
154 wxRICHTEXT_HITTEST_BEFORE
= 0x02,
156 // The point was after the position returned from HitTest
157 wxRICHTEXT_HITTEST_AFTER
= 0x04,
159 // The point was on the position returned from HitTest
160 wxRICHTEXT_HITTEST_ON
= 0x08,
162 // The point was on space outside content
163 wxRICHTEXT_HITTEST_OUTSIDE
= 0x10
167 * Flags for GetRangeSize
170 #define wxRICHTEXT_FORMATTED 0x01
171 #define wxRICHTEXT_UNFORMATTED 0x02
172 #define wxRICHTEXT_CACHE_SIZE 0x04
173 #define wxRICHTEXT_HEIGHT_ONLY 0x08
176 * Flags for SetStyle/SetListStyle
179 #define wxRICHTEXT_SETSTYLE_NONE 0x00
181 // Specifies that this operation should be undoable
182 #define wxRICHTEXT_SETSTYLE_WITH_UNDO 0x01
184 // Specifies that the style should not be applied if the
185 // combined style at this point is already the style in question.
186 #define wxRICHTEXT_SETSTYLE_OPTIMIZE 0x02
188 // Specifies that the style should only be applied to paragraphs,
189 // and not the content. This allows content styling to be
190 // preserved independently from that of e.g. a named paragraph style.
191 #define wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY 0x04
193 // Specifies that the style should only be applied to characters,
194 // and not the paragraph. This allows content styling to be
195 // preserved independently from that of e.g. a named paragraph style.
196 #define wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY 0x08
198 // For SetListStyle only: specifies starting from the given number, otherwise
199 // deduces number from existing attributes
200 #define wxRICHTEXT_SETSTYLE_RENUMBER 0x10
202 // For SetListStyle only: specifies the list level for all paragraphs, otherwise
203 // the current indentation will be used
204 #define wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL 0x20
206 // Resets the existing style before applying the new style
207 #define wxRICHTEXT_SETSTYLE_RESET 0x40
209 // Removes the given style instead of applying it
210 #define wxRICHTEXT_SETSTYLE_REMOVE 0x80
213 * Flags for text insertion
216 #define wxRICHTEXT_INSERT_NONE 0x00
217 #define wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE 0x01
218 #define wxRICHTEXT_INSERT_INTERACTIVE 0x02
220 // A special flag telling the buffer to keep the first paragraph style
221 // as-is, when deleting a paragraph marker. In future we might pass a
222 // flag to InsertFragment and DeleteRange to indicate the appropriate mode.
223 #define wxTEXT_ATTR_KEEP_FIRST_PARA_STYLE 0x10000000
226 * Default superscript/subscript font multiplication factor
229 #define wxSCRIPT_MUL_FACTOR 1.5
232 * wxRichTextFontTable
233 * Manages quick access to a pool of fonts for rendering rich text
236 class WXDLLIMPEXP_RICHTEXT wxRichTextFontTable
: public wxObject
239 wxRichTextFontTable();
241 wxRichTextFontTable(const wxRichTextFontTable
& table
);
242 virtual ~wxRichTextFontTable();
244 bool IsOk() const { return m_refData
!= NULL
; }
246 wxFont
FindFont(const wxTextAttr
& fontSpec
);
249 void operator= (const wxRichTextFontTable
& table
);
250 bool operator == (const wxRichTextFontTable
& table
) const;
251 bool operator != (const wxRichTextFontTable
& table
) const { return !(*this == table
); }
255 DECLARE_DYNAMIC_CLASS(wxRichTextFontTable
)
259 * wxRichTextRange class declaration
260 * This stores beginning and end positions for a range of data.
261 * TODO: consider renaming wxTextRange and using for all text controls.
264 class WXDLLIMPEXP_RICHTEXT wxRichTextRange
269 wxRichTextRange() { m_start
= 0; m_end
= 0; }
270 wxRichTextRange(long start
, long end
) { m_start
= start
; m_end
= end
; }
271 wxRichTextRange(const wxRichTextRange
& range
) { m_start
= range
.m_start
; m_end
= range
.m_end
; }
272 ~wxRichTextRange() {}
274 void operator =(const wxRichTextRange
& range
) { m_start
= range
.m_start
; m_end
= range
.m_end
; }
275 bool operator ==(const wxRichTextRange
& range
) const { return (m_start
== range
.m_start
&& m_end
== range
.m_end
); }
276 bool operator !=(const wxRichTextRange
& range
) const { return (m_start
!= range
.m_start
&& m_end
!= range
.m_end
); }
277 wxRichTextRange
operator -(const wxRichTextRange
& range
) const { return wxRichTextRange(m_start
- range
.m_start
, m_end
- range
.m_end
); }
278 wxRichTextRange
operator +(const wxRichTextRange
& range
) const { return wxRichTextRange(m_start
+ range
.m_start
, m_end
+ range
.m_end
); }
280 void SetRange(long start
, long end
) { m_start
= start
; m_end
= end
; }
282 void SetStart(long start
) { m_start
= start
; }
283 long GetStart() const { return m_start
; }
285 void SetEnd(long end
) { m_end
= end
; }
286 long GetEnd() const { return m_end
; }
288 /// Returns true if this range is completely outside 'range'
289 bool IsOutside(const wxRichTextRange
& range
) const { return range
.m_start
> m_end
|| range
.m_end
< m_start
; }
291 /// Returns true if this range is completely within 'range'
292 bool IsWithin(const wxRichTextRange
& range
) const { return m_start
>= range
.m_start
&& m_end
<= range
.m_end
; }
294 /// Returns true if the given position is within this range. Allow
295 /// for the possibility of an empty range - assume the position
296 /// is within this empty range. NO, I think we should not match with an empty range.
297 // bool Contains(long pos) const { return pos >= m_start && (pos <= m_end || GetLength() == 0); }
298 bool Contains(long pos
) const { return pos
>= m_start
&& pos
<= m_end
; }
300 /// Limit this range to be within 'range'
301 bool LimitTo(const wxRichTextRange
& range
) ;
303 /// Gets the length of the range
304 long GetLength() const { return m_end
- m_start
+ 1; }
306 /// Swaps the start and end
307 void Swap() { long tmp
= m_start
; m_start
= m_end
; m_end
= tmp
; }
309 /// Convert to internal form: (n, n) is the range of a single character.
310 wxRichTextRange
ToInternal() const { return wxRichTextRange(m_start
, m_end
-1); }
312 /// Convert from internal to public API form: (n, n+1) is the range of a single character.
313 wxRichTextRange
FromInternal() const { return wxRichTextRange(m_start
, m_end
+1); }
320 #define wxRICHTEXT_ALL wxRichTextRange(-2, -2)
321 #define wxRICHTEXT_NONE wxRichTextRange(-1, -1)
324 * wxRichTextObject class declaration
325 * This is the base for drawable objects.
328 class WXDLLIMPEXP_RICHTEXT wxRichTextObject
: public wxObject
330 DECLARE_CLASS(wxRichTextObject
)
334 wxRichTextObject(wxRichTextObject
* parent
= NULL
);
335 virtual ~wxRichTextObject();
339 /// Draw the item, within the given range. Some objects may ignore the range (for
340 /// example paragraphs) while others must obey it (lines, to implement wrapping)
341 virtual bool Draw(wxDC
& dc
, const wxRichTextRange
& range
, const wxRichTextRange
& selectionRange
, const wxRect
& rect
, int descent
, int style
) = 0;
343 /// Lay the item out at the specified position with the given size constraint.
344 /// Layout must set the cached size.
345 virtual bool Layout(wxDC
& dc
, const wxRect
& rect
, int style
) = 0;
347 /// Hit-testing: returns a flag indicating hit test details, plus
348 /// information about position
349 virtual int HitTest(wxDC
& WXUNUSED(dc
), const wxPoint
& WXUNUSED(pt
), long& WXUNUSED(textPosition
)) { return false; }
351 /// Finds the absolute position and row height for the given character position
352 virtual bool FindPosition(wxDC
& WXUNUSED(dc
), long WXUNUSED(index
), wxPoint
& WXUNUSED(pt
), int* WXUNUSED(height
), bool WXUNUSED(forceLineStart
)) { return false; }
354 /// Get the best size, i.e. the ideal starting size for this object irrespective
355 /// of available space. For a short text string, it will be the size that exactly encloses
356 /// the text. For a longer string, it might use the parent width for example.
357 virtual wxSize
GetBestSize() const { return m_size
; }
359 /// Get the object size for the given range. Returns false if the range
360 /// is invalid for this object.
361 virtual bool GetRangeSize(const wxRichTextRange
& range
, wxSize
& size
, int& descent
, wxDC
& dc
, int flags
, wxPoint position
= wxPoint(0,0), wxArrayInt
* partialExtents
= NULL
) const = 0;
363 /// Do a split, returning an object containing the second part, and setting
364 /// the first part in 'this'.
365 virtual wxRichTextObject
* DoSplit(long WXUNUSED(pos
)) { return NULL
; }
367 /// Calculate range. By default, guess that the object is 1 unit long.
368 virtual void CalculateRange(long start
, long& end
) { end
= start
; m_range
.SetRange(start
, end
); }
371 virtual bool DeleteRange(const wxRichTextRange
& WXUNUSED(range
)) { return false; }
373 /// Returns true if the object is empty
374 virtual bool IsEmpty() const { return false; }
376 /// Get any text in this object for the given range
377 virtual wxString
GetTextForRange(const wxRichTextRange
& WXUNUSED(range
)) const { return wxEmptyString
; }
379 /// Returns true if this object can merge itself with the given one.
380 virtual bool CanMerge(wxRichTextObject
* WXUNUSED(object
)) const { return false; }
382 /// Returns true if this object merged itself with the given one.
383 /// The calling code will then delete the given object.
384 virtual bool Merge(wxRichTextObject
* WXUNUSED(object
)) { return false; }
386 /// Dump to output stream for debugging
387 virtual void Dump(wxTextOutputStream
& stream
);
391 /// Get/set the cached object size as calculated by Layout.
392 virtual wxSize
GetCachedSize() const { return m_size
; }
393 virtual void SetCachedSize(const wxSize
& sz
) { m_size
= sz
; }
395 /// Get/set the object position
396 virtual wxPoint
GetPosition() const { return m_pos
; }
397 virtual void SetPosition(const wxPoint
& pos
) { m_pos
= pos
; }
399 /// Get the rectangle enclosing the object
400 virtual wxRect
GetRect() const { return wxRect(GetPosition(), GetCachedSize()); }
403 void SetRange(const wxRichTextRange
& range
) { m_range
= range
; }
406 const wxRichTextRange
& GetRange() const { return m_range
; }
407 wxRichTextRange
& GetRange() { return m_range
; }
409 /// Get/set dirty flag (whether the object needs Layout to be called)
410 virtual bool GetDirty() const { return m_dirty
; }
411 virtual void SetDirty(bool dirty
) { m_dirty
= dirty
; }
413 /// Is this composite?
414 virtual bool IsComposite() const { return false; }
416 /// Get/set the parent.
417 virtual wxRichTextObject
* GetParent() const { return m_parent
; }
418 virtual void SetParent(wxRichTextObject
* parent
) { m_parent
= parent
; }
420 /// Set the margin around the object
421 virtual void SetMargins(int margin
);
422 virtual void SetMargins(int leftMargin
, int rightMargin
, int topMargin
, int bottomMargin
);
423 virtual int GetLeftMargin() const { return m_leftMargin
; }
424 virtual int GetRightMargin() const { return m_rightMargin
; }
425 virtual int GetTopMargin() const { return m_topMargin
; }
426 virtual int GetBottomMargin() const { return m_bottomMargin
; }
428 /// Set attributes object
429 void SetAttributes(const wxTextAttr
& attr
) { m_attributes
= attr
; }
430 const wxTextAttr
& GetAttributes() const { return m_attributes
; }
431 wxTextAttr
& GetAttributes() { return m_attributes
; }
433 /// Set/get stored descent
434 void SetDescent(int descent
) { m_descent
= descent
; }
435 int GetDescent() const { return m_descent
; }
437 /// Gets the containing buffer
438 wxRichTextBuffer
* GetBuffer() const;
443 virtual wxRichTextObject
* Clone() const { return NULL
; }
446 void Copy(const wxRichTextObject
& obj
);
448 /// Reference-counting allows us to use the same object in multiple
449 /// lists (not yet used)
450 void Reference() { m_refCount
++; }
453 /// Convert units in tenths of a millimetre to device units
454 int ConvertTenthsMMToPixels(wxDC
& dc
, int units
);
455 static int ConvertTenthsMMToPixels(int ppi
, int units
);
460 int m_descent
; // Descent for this object (if any)
463 wxRichTextObject
* m_parent
;
465 /// The range of this object (start position to end position)
466 wxRichTextRange m_range
;
475 wxTextAttr m_attributes
;
478 WX_DECLARE_LIST_WITH_DECL( wxRichTextObject
, wxRichTextObjectList
, class WXDLLIMPEXP_RICHTEXT
);
481 * wxRichTextCompositeObject class declaration
482 * Objects of this class can contain other objects.
485 class WXDLLIMPEXP_RICHTEXT wxRichTextCompositeObject
: public wxRichTextObject
487 DECLARE_CLASS(wxRichTextCompositeObject
)
491 wxRichTextCompositeObject(wxRichTextObject
* parent
= NULL
);
492 virtual ~wxRichTextCompositeObject();
496 /// Hit-testing: returns a flag indicating hit test details, plus
497 /// information about position
498 virtual int HitTest(wxDC
& dc
, const wxPoint
& pt
, long& textPosition
);
500 /// Finds the absolute position and row height for the given character position
501 virtual bool FindPosition(wxDC
& dc
, long index
, wxPoint
& pt
, int* height
, bool forceLineStart
);
504 virtual void CalculateRange(long start
, long& end
);
507 virtual bool DeleteRange(const wxRichTextRange
& range
);
509 /// Get any text in this object for the given range
510 virtual wxString
GetTextForRange(const wxRichTextRange
& range
) const;
512 /// Dump to output stream for debugging
513 virtual void Dump(wxTextOutputStream
& stream
);
518 wxRichTextObjectList
& GetChildren() { return m_children
; }
519 const wxRichTextObjectList
& GetChildren() const { return m_children
; }
521 /// Get the child count
522 size_t GetChildCount() const ;
524 /// Get the nth child
525 wxRichTextObject
* GetChild(size_t n
) const ;
527 /// Get/set dirty flag
528 virtual bool GetDirty() const { return m_dirty
; }
529 virtual void SetDirty(bool dirty
) { m_dirty
= dirty
; }
531 /// Is this composite?
532 virtual bool IsComposite() const { return true; }
534 /// Returns true if the buffer is empty
535 virtual bool IsEmpty() const { return GetChildCount() == 0; }
540 void Copy(const wxRichTextCompositeObject
& obj
);
543 void operator= (const wxRichTextCompositeObject
& obj
) { Copy(obj
); }
545 /// Append a child, returning the position
546 size_t AppendChild(wxRichTextObject
* child
) ;
548 /// Insert the child in front of the given object, or at the beginning
549 bool InsertChild(wxRichTextObject
* child
, wxRichTextObject
* inFrontOf
) ;
552 bool RemoveChild(wxRichTextObject
* child
, bool deleteChild
= false) ;
554 /// Delete all children
555 bool DeleteChildren() ;
557 /// Recursively merge all pieces that can be merged.
558 bool Defragment(const wxRichTextRange
& range
= wxRICHTEXT_ALL
);
561 wxRichTextObjectList m_children
;
565 * wxRichTextBox class declaration
566 * This defines a 2D space to lay out objects
569 class WXDLLIMPEXP_RICHTEXT wxRichTextBox
: public wxRichTextCompositeObject
571 DECLARE_DYNAMIC_CLASS(wxRichTextBox
)
575 wxRichTextBox(wxRichTextObject
* parent
= NULL
);
576 wxRichTextBox(const wxRichTextBox
& obj
): wxRichTextCompositeObject() { Copy(obj
); }
581 virtual bool Draw(wxDC
& dc
, const wxRichTextRange
& range
, const wxRichTextRange
& selectionRange
, const wxRect
& rect
, int descent
, int style
);
584 virtual bool Layout(wxDC
& dc
, const wxRect
& rect
, int style
);
586 /// Get/set the object size for the given range. Returns false if the range
587 /// is invalid for this object.
588 virtual bool GetRangeSize(const wxRichTextRange
& range
, wxSize
& size
, int& descent
, wxDC
& dc
, int flags
, wxPoint position
= wxPoint(0,0), wxArrayInt
* partialExtents
= NULL
) const;
595 virtual wxRichTextObject
* Clone() const { return new wxRichTextBox(*this); }
598 void Copy(const wxRichTextBox
& obj
);
604 * wxRichTextParagraphBox class declaration
605 * This box knows how to lay out paragraphs.
608 class WXDLLIMPEXP_RICHTEXT wxRichTextParagraphLayoutBox
: public wxRichTextBox
610 DECLARE_DYNAMIC_CLASS(wxRichTextParagraphLayoutBox
)
614 wxRichTextParagraphLayoutBox(wxRichTextObject
* parent
= NULL
);
615 wxRichTextParagraphLayoutBox(const wxRichTextParagraphLayoutBox
& obj
): wxRichTextBox() { Init(); Copy(obj
); }
620 virtual bool Draw(wxDC
& dc
, const wxRichTextRange
& range
, const wxRichTextRange
& selectionRange
, const wxRect
& rect
, int descent
, int style
);
623 virtual bool Layout(wxDC
& dc
, const wxRect
& rect
, int style
);
625 /// Get/set the object size for the given range. Returns false if the range
626 /// is invalid for this object.
627 virtual bool GetRangeSize(const wxRichTextRange
& range
, wxSize
& size
, int& descent
, wxDC
& dc
, int flags
, wxPoint position
= wxPoint(0,0), wxArrayInt
* partialExtents
= NULL
) const;
630 virtual bool DeleteRange(const wxRichTextRange
& range
);
632 /// Get any text in this object for the given range
633 virtual wxString
GetTextForRange(const wxRichTextRange
& range
) const;
637 /// Associate a control with the buffer, for operations that for example require refreshing the window.
638 void SetRichTextCtrl(wxRichTextCtrl
* ctrl
) { m_ctrl
= ctrl
; }
640 /// Get the associated control.
641 wxRichTextCtrl
* GetRichTextCtrl() const { return m_ctrl
; }
643 /// Get/set whether the last paragraph is partial or complete
644 void SetPartialParagraph(bool partialPara
) { m_partialParagraph
= partialPara
; }
645 bool GetPartialParagraph() const { return m_partialParagraph
; }
647 /// If this is a buffer, returns the current style sheet. The base layout box
648 /// class doesn't have an associated style sheet.
649 virtual wxRichTextStyleSheet
* GetStyleSheet() const { return NULL
; }
653 /// Initialize the object.
656 /// Clear all children
657 virtual void Clear();
659 /// Clear and initialize with one blank paragraph
660 virtual void Reset();
662 /// Convenience function to add a paragraph of text
663 virtual wxRichTextRange
AddParagraph(const wxString
& text
, wxTextAttr
* paraStyle
= NULL
);
665 /// Convenience function to add an image
666 virtual wxRichTextRange
AddImage(const wxImage
& image
, wxTextAttr
* paraStyle
= NULL
);
668 /// Adds multiple paragraphs, based on newlines.
669 virtual wxRichTextRange
AddParagraphs(const wxString
& text
, wxTextAttr
* paraStyle
= NULL
);
671 /// Get the line at the given position. If caretPosition is true, the position is
672 /// a caret position, which is normally a smaller number.
673 virtual wxRichTextLine
* GetLineAtPosition(long pos
, bool caretPosition
= false) const;
675 /// Get the line at the given y pixel position, or the last line.
676 virtual wxRichTextLine
* GetLineAtYPosition(int y
) const;
678 /// Get the paragraph at the given character or caret position
679 virtual wxRichTextParagraph
* GetParagraphAtPosition(long pos
, bool caretPosition
= false) const;
681 /// Get the line size at the given position
682 virtual wxSize
GetLineSizeAtPosition(long pos
, bool caretPosition
= false) const;
684 /// Given a position, get the number of the visible line (potentially many to a paragraph),
685 /// starting from zero at the start of the buffer. We also have to pass a bool (startOfLine)
686 /// that indicates whether the caret is being shown at the end of the previous line or at the start
687 /// of the next, since the caret can be shown at 2 visible positions for the same underlying
689 virtual long GetVisibleLineNumber(long pos
, bool caretPosition
= false, bool startOfLine
= false) const;
691 /// Given a line number, get the corresponding wxRichTextLine object.
692 virtual wxRichTextLine
* GetLineForVisibleLineNumber(long lineNumber
) const;
694 /// Get the leaf object in a paragraph at this position.
695 /// Given a line number, get the corresponding wxRichTextLine object.
696 virtual wxRichTextObject
* GetLeafObjectAtPosition(long position
) const;
698 /// Get the paragraph by number
699 virtual wxRichTextParagraph
* GetParagraphAtLine(long paragraphNumber
) const;
701 /// Get the paragraph for a given line
702 virtual wxRichTextParagraph
* GetParagraphForLine(wxRichTextLine
* line
) const;
704 /// Get the length of the paragraph
705 virtual int GetParagraphLength(long paragraphNumber
) const;
707 /// Get the number of paragraphs
708 virtual int GetParagraphCount() const { return GetChildCount(); }
710 /// Get the number of visible lines
711 virtual int GetLineCount() const;
713 /// Get the text of the paragraph
714 virtual wxString
GetParagraphText(long paragraphNumber
) const;
716 /// Convert zero-based line column and paragraph number to a position.
717 virtual long XYToPosition(long x
, long y
) const;
719 /// Convert zero-based position to line column and paragraph number
720 virtual bool PositionToXY(long pos
, long* x
, long* y
) const;
722 /// Set text attributes: character and/or paragraph styles.
723 virtual bool SetStyle(const wxRichTextRange
& range
, const wxTextAttr
& style
, int flags
= wxRICHTEXT_SETSTYLE_WITH_UNDO
);
725 /// Get the conbined text attributes for this position.
726 virtual bool GetStyle(long position
, wxTextAttr
& style
);
728 /// Get the content (uncombined) attributes for this position.
729 virtual bool GetUncombinedStyle(long position
, wxTextAttr
& style
);
731 /// Implementation helper for GetStyle. If combineStyles is true, combine base, paragraph and
732 /// context attributes.
733 virtual bool DoGetStyle(long position
, wxTextAttr
& style
, bool combineStyles
= true);
735 /// Get the combined style for a range - if any attribute is different within the range,
736 /// that attribute is not present within the flags
737 virtual bool GetStyleForRange(const wxRichTextRange
& range
, wxTextAttr
& style
);
739 /// Combines 'style' with 'currentStyle' for the purpose of summarising the attributes of a range of
741 bool CollectStyle(wxTextAttr
& currentStyle
, const wxTextAttr
& style
, long& multipleStyleAttributes
, int& multipleTextEffectAttributes
, int& absentStyleAttributes
, int& absentTextEffectAttributes
);
744 virtual bool SetListStyle(const wxRichTextRange
& range
, wxRichTextListStyleDefinition
* def
, int flags
= wxRICHTEXT_SETSTYLE_WITH_UNDO
, int startFrom
= 1, int specifiedLevel
= -1);
745 virtual bool SetListStyle(const wxRichTextRange
& range
, const wxString
& defName
, int flags
= wxRICHTEXT_SETSTYLE_WITH_UNDO
, int startFrom
= 1, int specifiedLevel
= -1);
747 /// Clear list for given range
748 virtual bool ClearListStyle(const wxRichTextRange
& range
, int flags
= wxRICHTEXT_SETSTYLE_WITH_UNDO
);
750 /// Number/renumber any list elements in the given range.
751 /// def/defName can be NULL/empty to indicate that the existing list style should be used.
752 virtual bool NumberList(const wxRichTextRange
& range
, wxRichTextListStyleDefinition
* def
= NULL
, int flags
= wxRICHTEXT_SETSTYLE_WITH_UNDO
, int startFrom
= 1, int specifiedLevel
= -1);
753 virtual bool NumberList(const wxRichTextRange
& range
, const wxString
& defName
, int flags
= wxRICHTEXT_SETSTYLE_WITH_UNDO
, int startFrom
= 1, int specifiedLevel
= -1);
755 /// Promote the list items within the given range. promoteBy can be a positive or negative number, e.g. 1 or -1
756 /// def/defName can be NULL/empty to indicate that the existing list style should be used.
757 virtual bool PromoteList(int promoteBy
, const wxRichTextRange
& range
, wxRichTextListStyleDefinition
* def
= NULL
, int flags
= wxRICHTEXT_SETSTYLE_WITH_UNDO
, int specifiedLevel
= -1);
758 virtual bool PromoteList(int promoteBy
, const wxRichTextRange
& range
, const wxString
& defName
, int flags
= wxRICHTEXT_SETSTYLE_WITH_UNDO
, int specifiedLevel
= -1);
760 /// Helper for NumberList and PromoteList, that does renumbering and promotion simultaneously
761 /// def/defName can be NULL/empty to indicate that the existing list style should be used.
762 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);
764 /// Fills in the attributes for numbering a paragraph after previousParagraph.
765 virtual bool FindNextParagraphNumber(wxRichTextParagraph
* previousParagraph
, wxTextAttr
& attr
) const;
767 /// Test if this whole range has character attributes of the specified kind. If any
768 /// of the attributes are different within the range, the test fails. You
769 /// can use this to implement, for example, bold button updating. style must have
770 /// flags indicating which attributes are of interest.
771 virtual bool HasCharacterAttributes(const wxRichTextRange
& range
, const wxTextAttr
& style
) const;
773 /// Test if this whole range has paragraph attributes of the specified kind. If any
774 /// of the attributes are different within the range, the test fails. You
775 /// can use this to implement, for example, centering button updating. style must have
776 /// flags indicating which attributes are of interest.
777 virtual bool HasParagraphAttributes(const wxRichTextRange
& range
, const wxTextAttr
& style
) const;
780 virtual wxRichTextObject
* Clone() const { return new wxRichTextParagraphLayoutBox(*this); }
782 /// Insert fragment into this box at the given position. If partialParagraph is true,
783 /// it is assumed that the last (or only) paragraph is just a piece of data with no paragraph
785 virtual bool InsertFragment(long position
, wxRichTextParagraphLayoutBox
& fragment
);
787 /// Make a copy of the fragment corresponding to the given range, putting it in 'fragment'.
788 virtual bool CopyFragment(const wxRichTextRange
& range
, wxRichTextParagraphLayoutBox
& fragment
);
790 /// Apply the style sheet to the buffer, for example if the styles have changed.
791 virtual bool ApplyStyleSheet(wxRichTextStyleSheet
* styleSheet
);
794 void Copy(const wxRichTextParagraphLayoutBox
& obj
);
797 void operator= (const wxRichTextParagraphLayoutBox
& obj
) { Copy(obj
); }
800 virtual void UpdateRanges() { long end
; CalculateRange(0, end
); }
803 virtual wxString
GetText() const;
805 /// Set default style for new content. Setting it to a default attribute
806 /// makes new content take on the 'basic' style.
807 virtual bool SetDefaultStyle(const wxTextAttr
& style
);
809 /// Get default style
810 virtual const wxTextAttr
& GetDefaultStyle() const { return m_defaultAttributes
; }
812 /// Set basic (overall) style
813 virtual void SetBasicStyle(const wxTextAttr
& style
) { m_attributes
= style
; }
815 /// Get basic (overall) style
816 virtual const wxTextAttr
& GetBasicStyle() const { return m_attributes
; }
818 /// Invalidate the buffer. With no argument, invalidates whole buffer.
819 void Invalidate(const wxRichTextRange
& invalidRange
= wxRICHTEXT_ALL
);
821 /// Get invalid range, rounding to entire paragraphs if argument is true.
822 wxRichTextRange
GetInvalidRange(bool wholeParagraphs
= false) const;
825 wxRichTextCtrl
* m_ctrl
;
826 wxTextAttr m_defaultAttributes
;
828 /// The invalidated range that will need full layout
829 wxRichTextRange m_invalidRange
;
831 // Is the last paragraph partial or complete?
832 bool m_partialParagraph
;
836 * wxRichTextLine class declaration
837 * This object represents a line in a paragraph, and stores
838 * offsets from the start of the paragraph representing the
839 * start and end positions of the line.
842 class WXDLLIMPEXP_RICHTEXT wxRichTextLine
847 wxRichTextLine(wxRichTextParagraph
* parent
);
848 wxRichTextLine(const wxRichTextLine
& obj
) { Init( NULL
); Copy(obj
); }
849 virtual ~wxRichTextLine() {}
856 void SetRange(const wxRichTextRange
& range
) { m_range
= range
; }
857 void SetRange(long from
, long to
) { m_range
= wxRichTextRange(from
, to
); }
859 /// Get the parent paragraph
860 wxRichTextParagraph
* GetParent() { return m_parent
; }
863 const wxRichTextRange
& GetRange() const { return m_range
; }
864 wxRichTextRange
& GetRange() { return m_range
; }
866 /// Get the absolute range
867 wxRichTextRange
GetAbsoluteRange() const;
869 /// Get/set the line size as calculated by Layout.
870 virtual wxSize
GetSize() const { return m_size
; }
871 virtual void SetSize(const wxSize
& sz
) { m_size
= sz
; }
873 /// Get/set the object position relative to the parent
874 virtual wxPoint
GetPosition() const { return m_pos
; }
875 virtual void SetPosition(const wxPoint
& pos
) { m_pos
= pos
; }
877 /// Get the absolute object position
878 virtual wxPoint
GetAbsolutePosition() const;
880 /// Get the rectangle enclosing the line
881 virtual wxRect
GetRect() const { return wxRect(GetAbsolutePosition(), GetSize()); }
883 /// Set/get stored descent
884 void SetDescent(int descent
) { m_descent
= descent
; }
885 int GetDescent() const { return m_descent
; }
887 #if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING
888 wxArrayInt
& GetObjectSizes() { return m_objectSizes
; }
889 const wxArrayInt
& GetObjectSizes() const { return m_objectSizes
; }
895 void Init(wxRichTextParagraph
* parent
);
898 void Copy(const wxRichTextLine
& obj
);
901 virtual wxRichTextLine
* Clone() const { return new wxRichTextLine(*this); }
905 /// The range of the line (start position to end position)
906 /// This is relative to the parent paragraph.
907 wxRichTextRange m_range
;
909 /// Size and position measured relative to top of paragraph
913 /// Maximum descent for this line (location of text baseline)
917 wxRichTextParagraph
* m_parent
;
919 #if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING
920 wxArrayInt m_objectSizes
;
924 WX_DECLARE_LIST_WITH_DECL( wxRichTextLine
, wxRichTextLineList
, class WXDLLIMPEXP_RICHTEXT
);
927 * wxRichTextParagraph class declaration
928 * This object represents a single paragraph (or in a straight text editor, a line).
931 class WXDLLIMPEXP_RICHTEXT wxRichTextParagraph
: public wxRichTextBox
933 DECLARE_DYNAMIC_CLASS(wxRichTextParagraph
)
937 wxRichTextParagraph(wxRichTextObject
* parent
= NULL
, wxTextAttr
* style
= NULL
);
938 wxRichTextParagraph(const wxString
& text
, wxRichTextObject
* parent
= NULL
, wxTextAttr
* paraStyle
= NULL
, wxTextAttr
* charStyle
= NULL
);
939 virtual ~wxRichTextParagraph();
940 wxRichTextParagraph(const wxRichTextParagraph
& obj
): wxRichTextBox() { Copy(obj
); }
945 virtual bool Draw(wxDC
& dc
, const wxRichTextRange
& range
, const wxRichTextRange
& selectionRange
, const wxRect
& rect
, int descent
, int style
);
948 virtual bool Layout(wxDC
& dc
, const wxRect
& rect
, int style
);
950 /// Get/set the object size for the given range. Returns false if the range
951 /// is invalid for this object.
952 virtual bool GetRangeSize(const wxRichTextRange
& range
, wxSize
& size
, int& descent
, wxDC
& dc
, int flags
, wxPoint position
= wxPoint(0,0), wxArrayInt
* partialExtents
= NULL
) const;
954 /// Finds the absolute position and row height for the given character position
955 virtual bool FindPosition(wxDC
& dc
, long index
, wxPoint
& pt
, int* height
, bool forceLineStart
);
957 /// Hit-testing: returns a flag indicating hit test details, plus
958 /// information about position
959 virtual int HitTest(wxDC
& dc
, const wxPoint
& pt
, long& textPosition
);
962 virtual void CalculateRange(long start
, long& end
);
966 /// Get the cached lines
967 wxRichTextLineList
& GetLines() { return m_cachedLines
; }
972 void Copy(const wxRichTextParagraph
& obj
);
975 virtual wxRichTextObject
* Clone() const { return new wxRichTextParagraph(*this); }
977 /// Clear the cached lines
982 /// Apply paragraph styles such as centering to the wrapped lines
983 virtual void ApplyParagraphStyle(const wxTextAttr
& attr
, const wxRect
& rect
);
985 /// Insert text at the given position
986 virtual bool InsertText(long pos
, const wxString
& text
);
988 /// Split an object at this position if necessary, and return
989 /// the previous object, or NULL if inserting at beginning.
990 virtual wxRichTextObject
* SplitAt(long pos
, wxRichTextObject
** previousObject
= NULL
);
992 /// Move content to a list from this point
993 virtual void MoveToList(wxRichTextObject
* obj
, wxList
& list
);
995 /// Add content back from list
996 virtual void MoveFromList(wxList
& list
);
998 /// Get the plain text searching from the start or end of the range.
999 /// The resulting string may be shorter than the range given.
1000 bool GetContiguousPlainText(wxString
& text
, const wxRichTextRange
& range
, bool fromStart
= true);
1002 /// Find a suitable wrap position. wrapPosition is the last position in the line to the left
1004 bool FindWrapPosition(const wxRichTextRange
& range
, wxDC
& dc
, int availableSpace
, long& wrapPosition
, wxArrayInt
* partialExtents
);
1006 /// Find the object at the given position
1007 wxRichTextObject
* FindObjectAtPosition(long position
);
1009 /// Get the bullet text for this paragraph.
1010 wxString
GetBulletText();
1012 /// Allocate or reuse a line object
1013 wxRichTextLine
* AllocateLine(int pos
);
1015 /// Clear remaining unused line objects, if any
1016 bool ClearUnusedLines(int lineCount
);
1018 /// Get combined attributes of the base style, paragraph style and character style. We use this to dynamically
1019 /// retrieve the actual style.
1020 wxTextAttr
GetCombinedAttributes(const wxTextAttr
& contentStyle
) const;
1022 /// Get combined attributes of the base style and paragraph style.
1023 wxTextAttr
GetCombinedAttributes() const;
1025 /// Get the first position from pos that has a line break character.
1026 long GetFirstLineBreakPosition(long pos
);
1028 /// Create default tabstop array
1029 static void InitDefaultTabs();
1031 /// Clear default tabstop array
1032 static void ClearDefaultTabs();
1034 /// Get default tabstop array
1035 static const wxArrayInt
& GetDefaultTabs() { return sm_defaultTabs
; }
1038 /// The lines that make up the wrapped paragraph
1039 wxRichTextLineList m_cachedLines
;
1041 /// Default tabstops
1042 static wxArrayInt sm_defaultTabs
;
1046 * wxRichTextPlainText class declaration
1047 * This object represents a single piece of text.
1050 class WXDLLIMPEXP_RICHTEXT wxRichTextPlainText
: public wxRichTextObject
1052 DECLARE_DYNAMIC_CLASS(wxRichTextPlainText
)
1056 wxRichTextPlainText(const wxString
& text
= wxEmptyString
, wxRichTextObject
* parent
= NULL
, wxTextAttr
* style
= NULL
);
1057 wxRichTextPlainText(const wxRichTextPlainText
& obj
): wxRichTextObject() { Copy(obj
); }
1062 virtual bool Draw(wxDC
& dc
, const wxRichTextRange
& range
, const wxRichTextRange
& selectionRange
, const wxRect
& rect
, int descent
, int style
);
1064 /// Lay the item out
1065 virtual bool Layout(wxDC
& dc
, const wxRect
& rect
, int style
);
1067 /// Get/set the object size for the given range. Returns false if the range
1068 /// is invalid for this object.
1069 virtual bool GetRangeSize(const wxRichTextRange
& range
, wxSize
& size
, int& descent
, wxDC
& dc
, int flags
, wxPoint position
= wxPoint(0,0), wxArrayInt
* partialExtents
= NULL
) const;
1071 /// Get any text in this object for the given range
1072 virtual wxString
GetTextForRange(const wxRichTextRange
& range
) const;
1074 /// Do a split, returning an object containing the second part, and setting
1075 /// the first part in 'this'.
1076 virtual wxRichTextObject
* DoSplit(long pos
);
1079 virtual void CalculateRange(long start
, long& end
);
1082 virtual bool DeleteRange(const wxRichTextRange
& range
);
1084 /// Returns true if the object is empty
1085 virtual bool IsEmpty() const { return m_text
.empty(); }
1087 /// Returns true if this object can merge itself with the given one.
1088 virtual bool CanMerge(wxRichTextObject
* object
) const;
1090 /// Returns true if this object merged itself with the given one.
1091 /// The calling code will then delete the given object.
1092 virtual bool Merge(wxRichTextObject
* object
);
1094 /// Dump to output stream for debugging
1095 virtual void Dump(wxTextOutputStream
& stream
);
1097 /// Get the first position from pos that has a line break character.
1098 long GetFirstLineBreakPosition(long pos
);
1103 const wxString
& GetText() const { return m_text
; }
1106 void SetText(const wxString
& text
) { m_text
= text
; }
1111 void Copy(const wxRichTextPlainText
& obj
);
1114 virtual wxRichTextObject
* Clone() const { return new wxRichTextPlainText(*this); }
1116 bool DrawTabbedString(wxDC
& dc
, const wxTextAttr
& attr
, const wxRect
& rect
, wxString
& str
, wxCoord
& x
, wxCoord
& y
, bool selected
);
1123 * wxRichTextImageBlock stores information about an image, in binary in-memory form
1126 class WXDLLIMPEXP_FWD_BASE wxDataInputStream
;
1127 class WXDLLIMPEXP_FWD_BASE wxDataOutputStream
;
1129 class WXDLLIMPEXP_RICHTEXT wxRichTextImageBlock
: public wxObject
1132 wxRichTextImageBlock();
1133 wxRichTextImageBlock(const wxRichTextImageBlock
& block
);
1134 virtual ~wxRichTextImageBlock();
1139 // Load the original image into a memory block.
1140 // If the image is not a JPEG, we must convert it into a JPEG
1141 // to conserve space.
1142 // If it's not a JPEG we can make use of 'image', already scaled, so we don't have to
1143 // load the image a 2nd time.
1144 virtual bool MakeImageBlock(const wxString
& filename
, wxBitmapType imageType
,
1145 wxImage
& image
, bool convertToJPEG
= true);
1147 // Make an image block from the wxImage in the given
1149 virtual bool MakeImageBlock(wxImage
& image
, wxBitmapType imageType
, int quality
= 80);
1152 bool Write(const wxString
& filename
);
1154 // Write data in hex to a stream
1155 bool WriteHex(wxOutputStream
& stream
);
1157 // Read data in hex from a stream
1158 bool ReadHex(wxInputStream
& stream
, int length
, wxBitmapType imageType
);
1160 // Copy from 'block'
1161 void Copy(const wxRichTextImageBlock
& block
);
1163 // Load a wxImage from the block
1164 bool Load(wxImage
& image
);
1167 void operator=(const wxRichTextImageBlock
& block
);
1171 unsigned char* GetData() const { return m_data
; }
1172 size_t GetDataSize() const { return m_dataSize
; }
1173 wxBitmapType
GetImageType() const { return m_imageType
; }
1175 void SetData(unsigned char* image
) { m_data
= image
; }
1176 void SetDataSize(size_t size
) { m_dataSize
= size
; }
1177 void SetImageType(wxBitmapType imageType
) { m_imageType
= imageType
; }
1179 bool Ok() const { return IsOk(); }
1180 bool IsOk() const { return GetData() != NULL
; }
1182 // Gets the extension for the block's type
1183 wxString
GetExtension() const;
1187 // Allocate and read from stream as a block of memory
1188 static unsigned char* ReadBlock(wxInputStream
& stream
, size_t size
);
1189 static unsigned char* ReadBlock(const wxString
& filename
, size_t size
);
1191 // Write memory block to stream
1192 static bool WriteBlock(wxOutputStream
& stream
, unsigned char* block
, size_t size
);
1194 // Write memory block to file
1195 static bool WriteBlock(const wxString
& filename
, unsigned char* block
, size_t size
);
1198 // Size in bytes of the image stored.
1199 // This is in the raw, original form such as a JPEG file.
1200 unsigned char* m_data
;
1202 wxBitmapType m_imageType
;
1207 * wxRichTextImage class declaration
1208 * This object represents an image.
1211 class WXDLLIMPEXP_RICHTEXT wxRichTextImage
: public wxRichTextObject
1213 DECLARE_DYNAMIC_CLASS(wxRichTextImage
)
1217 wxRichTextImage(wxRichTextObject
* parent
= NULL
): wxRichTextObject(parent
) { }
1218 wxRichTextImage(const wxImage
& image
, wxRichTextObject
* parent
= NULL
, wxTextAttr
* charStyle
= NULL
);
1219 wxRichTextImage(const wxRichTextImageBlock
& imageBlock
, wxRichTextObject
* parent
= NULL
, wxTextAttr
* charStyle
= NULL
);
1220 wxRichTextImage(const wxRichTextImage
& obj
): wxRichTextObject() { Copy(obj
); }
1225 virtual bool Draw(wxDC
& dc
, const wxRichTextRange
& range
, const wxRichTextRange
& selectionRange
, const wxRect
& rect
, int descent
, int style
);
1227 /// Lay the item out
1228 virtual bool Layout(wxDC
& dc
, const wxRect
& rect
, int style
);
1230 /// Get the object size for the given range. Returns false if the range
1231 /// is invalid for this object.
1232 virtual bool GetRangeSize(const wxRichTextRange
& range
, wxSize
& size
, int& descent
, wxDC
& dc
, int flags
, wxPoint position
= wxPoint(0,0), wxArrayInt
* partialExtents
= NULL
) const;
1234 /// Returns true if the object is empty
1235 virtual bool IsEmpty() const { return !m_image
.Ok(); }
1240 const wxImage
& GetImage() const { return m_image
; }
1243 void SetImage(const wxImage
& image
) { m_image
= image
; }
1245 /// Get the image block containing the raw data
1246 wxRichTextImageBlock
& GetImageBlock() { return m_imageBlock
; }
1251 void Copy(const wxRichTextImage
& obj
);
1254 virtual wxRichTextObject
* Clone() const { return new wxRichTextImage(*this); }
1256 /// Load wxImage from the block
1257 virtual bool LoadFromBlock();
1259 /// Make block from the wxImage
1260 virtual bool MakeBlock();
1263 // TODO: reduce the multiple representations of data
1266 wxRichTextImageBlock m_imageBlock
;
1271 * wxRichTextBuffer class declaration
1272 * This is a kind of box, used to represent the whole buffer
1275 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextCommand
;
1276 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextAction
;
1278 class WXDLLIMPEXP_RICHTEXT wxRichTextBuffer
: public wxRichTextParagraphLayoutBox
1280 DECLARE_DYNAMIC_CLASS(wxRichTextBuffer
)
1284 wxRichTextBuffer() { Init(); }
1285 wxRichTextBuffer(const wxRichTextBuffer
& obj
): wxRichTextParagraphLayoutBox() { Init(); Copy(obj
); }
1286 virtual ~wxRichTextBuffer() ;
1290 /// Gets the command processor
1291 wxCommandProcessor
* GetCommandProcessor() const { return m_commandProcessor
; }
1293 /// Set style sheet, if any.
1294 void SetStyleSheet(wxRichTextStyleSheet
* styleSheet
) { m_styleSheet
= styleSheet
; }
1295 virtual wxRichTextStyleSheet
* GetStyleSheet() const { return m_styleSheet
; }
1297 /// Set style sheet and notify of the change
1298 bool SetStyleSheetAndNotify(wxRichTextStyleSheet
* sheet
);
1300 /// Push style sheet to top of stack
1301 bool PushStyleSheet(wxRichTextStyleSheet
* styleSheet
);
1303 /// Pop style sheet from top of stack
1304 wxRichTextStyleSheet
* PopStyleSheet();
1306 /// Set/get table storing fonts
1307 wxRichTextFontTable
& GetFontTable() { return m_fontTable
; }
1308 const wxRichTextFontTable
& GetFontTable() const { return m_fontTable
; }
1309 void SetFontTable(const wxRichTextFontTable
& table
) { m_fontTable
= table
; }
1316 /// Clears the buffer, adds an empty paragraph, and clears the command processor.
1317 virtual void ResetAndClearCommands();
1320 virtual bool LoadFile(const wxString
& filename
, wxRichTextFileType type
= wxRICHTEXT_TYPE_ANY
);
1323 virtual bool SaveFile(const wxString
& filename
, wxRichTextFileType type
= wxRICHTEXT_TYPE_ANY
);
1325 /// Load from a stream
1326 virtual bool LoadFile(wxInputStream
& stream
, wxRichTextFileType type
= wxRICHTEXT_TYPE_ANY
);
1328 /// Save to a stream
1329 virtual bool SaveFile(wxOutputStream
& stream
, wxRichTextFileType type
= wxRICHTEXT_TYPE_ANY
);
1331 /// Set the handler flags, controlling loading and saving
1332 void SetHandlerFlags(int flags
) { m_handlerFlags
= flags
; }
1334 /// Get the handler flags, controlling loading and saving
1335 int GetHandlerFlags() const { return m_handlerFlags
; }
1337 /// Convenience function to add a paragraph of text
1338 virtual wxRichTextRange
AddParagraph(const wxString
& text
, wxTextAttr
* paraStyle
= NULL
) { Modify(); return wxRichTextParagraphLayoutBox::AddParagraph(text
, paraStyle
); }
1340 /// Begin collapsing undo/redo commands. Note that this may not work properly
1341 /// if combining commands that delete or insert content, changing ranges for
1342 /// subsequent actions.
1343 virtual bool BeginBatchUndo(const wxString
& cmdName
);
1345 /// End collapsing undo/redo commands
1346 virtual bool EndBatchUndo();
1348 /// Collapsing commands?
1349 virtual bool BatchingUndo() const { return m_batchedCommandDepth
> 0; }
1351 /// Submit immediately, or delay according to whether collapsing is on
1352 virtual bool SubmitAction(wxRichTextAction
* action
);
1354 /// Get collapsed command
1355 virtual wxRichTextCommand
* GetBatchedCommand() const { return m_batchedCommand
; }
1357 /// Begin suppressing undo/redo commands. The way undo is suppressed may be implemented
1358 /// differently by each command. If not dealt with by a command implementation, then
1359 /// it will be implemented automatically by not storing the command in the undo history
1360 /// when the action is submitted to the command processor.
1361 virtual bool BeginSuppressUndo();
1363 /// End suppressing undo/redo commands.
1364 virtual bool EndSuppressUndo();
1366 /// Collapsing commands?
1367 virtual bool SuppressingUndo() const { return m_suppressUndo
> 0; }
1369 /// Copy the range to the clipboard
1370 virtual bool CopyToClipboard(const wxRichTextRange
& range
);
1372 /// Paste the clipboard content to the buffer
1373 virtual bool PasteFromClipboard(long position
);
1375 /// Can we paste from the clipboard?
1376 virtual bool CanPasteFromClipboard() const;
1378 /// Begin using a style
1379 virtual bool BeginStyle(const wxTextAttr
& style
);
1382 virtual bool EndStyle();
1385 virtual bool EndAllStyles();
1387 /// Clear the style stack
1388 virtual void ClearStyleStack();
1390 /// Get the size of the style stack, for example to check correct nesting
1391 virtual size_t GetStyleStackSize() const { return m_attributeStack
.GetCount(); }
1393 /// Begin using bold
1397 bool EndBold() { return EndStyle(); }
1399 /// Begin using italic
1402 /// End using italic
1403 bool EndItalic() { return EndStyle(); }
1405 /// Begin using underline
1406 bool BeginUnderline();
1408 /// End using underline
1409 bool EndUnderline() { return EndStyle(); }
1411 /// Begin using point size
1412 bool BeginFontSize(int pointSize
);
1414 /// End using point size
1415 bool EndFontSize() { return EndStyle(); }
1417 /// Begin using this font
1418 bool BeginFont(const wxFont
& font
);
1420 /// End using a font
1421 bool EndFont() { return EndStyle(); }
1423 /// Begin using this colour
1424 bool BeginTextColour(const wxColour
& colour
);
1426 /// End using a colour
1427 bool EndTextColour() { return EndStyle(); }
1429 /// Begin using alignment
1430 bool BeginAlignment(wxTextAttrAlignment alignment
);
1433 bool EndAlignment() { return EndStyle(); }
1435 /// Begin left indent
1436 bool BeginLeftIndent(int leftIndent
, int leftSubIndent
= 0);
1439 bool EndLeftIndent() { return EndStyle(); }
1441 /// Begin right indent
1442 bool BeginRightIndent(int rightIndent
);
1444 /// End right indent
1445 bool EndRightIndent() { return EndStyle(); }
1447 /// Begin paragraph spacing
1448 bool BeginParagraphSpacing(int before
, int after
);
1450 /// End paragraph spacing
1451 bool EndParagraphSpacing() { return EndStyle(); }
1453 /// Begin line spacing
1454 bool BeginLineSpacing(int lineSpacing
);
1456 /// End line spacing
1457 bool EndLineSpacing() { return EndStyle(); }
1459 /// Begin numbered bullet
1460 bool BeginNumberedBullet(int bulletNumber
, int leftIndent
, int leftSubIndent
, int bulletStyle
= wxTEXT_ATTR_BULLET_STYLE_ARABIC
|wxTEXT_ATTR_BULLET_STYLE_PERIOD
);
1462 /// End numbered bullet
1463 bool EndNumberedBullet() { return EndStyle(); }
1465 /// Begin symbol bullet
1466 bool BeginSymbolBullet(const wxString
& symbol
, int leftIndent
, int leftSubIndent
, int bulletStyle
= wxTEXT_ATTR_BULLET_STYLE_SYMBOL
);
1468 /// End symbol bullet
1469 bool EndSymbolBullet() { return EndStyle(); }
1471 /// Begin standard bullet
1472 bool BeginStandardBullet(const wxString
& bulletName
, int leftIndent
, int leftSubIndent
, int bulletStyle
= wxTEXT_ATTR_BULLET_STYLE_STANDARD
);
1474 /// End standard bullet
1475 bool EndStandardBullet() { return EndStyle(); }
1477 /// Begin named character style
1478 bool BeginCharacterStyle(const wxString
& characterStyle
);
1480 /// End named character style
1481 bool EndCharacterStyle() { return EndStyle(); }
1483 /// Begin named paragraph style
1484 bool BeginParagraphStyle(const wxString
& paragraphStyle
);
1486 /// End named character style
1487 bool EndParagraphStyle() { return EndStyle(); }
1489 /// Begin named list style
1490 bool BeginListStyle(const wxString
& listStyle
, int level
= 1, int number
= 1);
1492 /// End named character style
1493 bool EndListStyle() { return EndStyle(); }
1496 bool BeginURL(const wxString
& url
, const wxString
& characterStyle
= wxEmptyString
);
1499 bool EndURL() { return EndStyle(); }
1503 /// Add an event handler
1504 bool AddEventHandler(wxEvtHandler
* handler
);
1506 /// Remove an event handler
1507 bool RemoveEventHandler(wxEvtHandler
* handler
, bool deleteHandler
= false);
1509 /// Clear event handlers
1510 void ClearEventHandlers();
1512 /// Send event to event handlers. If sendToAll is true, will send to all event handlers,
1513 /// otherwise will stop at the first successful one.
1514 bool SendEvent(wxEvent
& event
, bool sendToAll
= true);
1519 void Copy(const wxRichTextBuffer
& obj
);
1522 virtual wxRichTextObject
* Clone() const { return new wxRichTextBuffer(*this); }
1524 /// Submit command to insert paragraphs
1525 bool InsertParagraphsWithUndo(long pos
, const wxRichTextParagraphLayoutBox
& paragraphs
, wxRichTextCtrl
* ctrl
, int flags
= 0);
1527 /// Submit command to insert the given text
1528 bool InsertTextWithUndo(long pos
, const wxString
& text
, wxRichTextCtrl
* ctrl
, int flags
= 0);
1530 /// Submit command to insert a newline
1531 bool InsertNewlineWithUndo(long pos
, wxRichTextCtrl
* ctrl
, int flags
= 0);
1533 /// Submit command to insert the given image
1534 bool InsertImageWithUndo(long pos
, const wxRichTextImageBlock
& imageBlock
, wxRichTextCtrl
* ctrl
, int flags
= 0);
1536 /// Submit command to delete this range
1537 bool DeleteRangeWithUndo(const wxRichTextRange
& range
, wxRichTextCtrl
* ctrl
);
1540 void Modify(bool modify
= true) { m_modified
= modify
; }
1541 bool IsModified() const { return m_modified
; }
1543 /// Get the style that is appropriate for a new paragraph at this position.
1544 /// If the previous paragraph has a paragraph style name, look up the next-paragraph
1546 wxTextAttr
GetStyleForNewParagraph(long pos
, bool caretPosition
= false, bool lookUpNewParaStyle
=false) const;
1548 /// Dumps contents of buffer for debugging purposes
1549 virtual void Dump();
1550 virtual void Dump(wxTextOutputStream
& stream
) { wxRichTextParagraphLayoutBox::Dump(stream
); }
1552 /// Returns the file handlers
1553 static wxList
& GetHandlers() { return sm_handlers
; }
1555 /// Adds a handler to the end
1556 static void AddHandler(wxRichTextFileHandler
*handler
);
1558 /// Inserts a handler at the front
1559 static void InsertHandler(wxRichTextFileHandler
*handler
);
1561 /// Removes a handler
1562 static bool RemoveHandler(const wxString
& name
);
1564 /// Finds a handler by name
1565 static wxRichTextFileHandler
*FindHandler(const wxString
& name
);
1567 /// Finds a handler by extension and type
1568 static wxRichTextFileHandler
*FindHandler(const wxString
& extension
, wxRichTextFileType imageType
);
1570 /// Finds a handler by filename or, if supplied, type
1571 static wxRichTextFileHandler
*FindHandlerFilenameOrType(const wxString
& filename
,
1572 wxRichTextFileType imageType
);
1574 /// Finds a handler by type
1575 static wxRichTextFileHandler
*FindHandler(wxRichTextFileType imageType
);
1577 /// Gets a wildcard incorporating all visible handlers. If 'types' is present,
1578 /// will be filled with the file type corresponding to each filter. This can be
1579 /// used to determine the type to pass to LoadFile given a selected filter.
1580 static wxString
GetExtWildcard(bool combine
= false, bool save
= false, wxArrayInt
* types
= NULL
);
1582 /// Clean up handlers
1583 static void CleanUpHandlers();
1585 /// Initialise the standard handlers
1586 static void InitStandardHandlers();
1589 static wxRichTextRenderer
* GetRenderer() { return sm_renderer
; }
1591 /// Set renderer, deleting old one
1592 static void SetRenderer(wxRichTextRenderer
* renderer
);
1594 /// Minimum margin between bullet and paragraph in 10ths of a mm
1595 static int GetBulletRightMargin() { return sm_bulletRightMargin
; }
1596 static void SetBulletRightMargin(int margin
) { sm_bulletRightMargin
= margin
; }
1598 /// Factor to multiply by character height to get a reasonable bullet size
1599 static float GetBulletProportion() { return sm_bulletProportion
; }
1600 static void SetBulletProportion(float prop
) { sm_bulletProportion
= prop
; }
1602 /// Scale factor for calculating dimensions
1603 double GetScale() const { return m_scale
; }
1604 void SetScale(double scale
) { m_scale
= scale
; }
1608 /// Command processor
1609 wxCommandProcessor
* m_commandProcessor
;
1611 /// Table storing fonts
1612 wxRichTextFontTable m_fontTable
;
1614 /// Has been modified?
1617 /// Collapsed command stack
1618 int m_batchedCommandDepth
;
1620 /// Name for collapsed command
1621 wxString m_batchedCommandsName
;
1623 /// Current collapsed command accumulating actions
1624 wxRichTextCommand
* m_batchedCommand
;
1626 /// Whether to suppress undo
1629 /// Style sheet, if any
1630 wxRichTextStyleSheet
* m_styleSheet
;
1632 /// List of event handlers that will be notified of events
1633 wxList m_eventHandlers
;
1635 /// Stack of attributes for convenience functions
1636 wxList m_attributeStack
;
1638 /// Flags to be passed to handlers
1642 static wxList sm_handlers
;
1645 static wxRichTextRenderer
* sm_renderer
;
1647 /// Minimum margin between bullet and paragraph in 10ths of a mm
1648 static int sm_bulletRightMargin
;
1650 /// Factor to multiply by character height to get a reasonable bullet size
1651 static float sm_bulletProportion
;
1653 /// Scaling factor in use: needed to calculate correct dimensions when printing
1658 * The command identifiers
1662 enum wxRichTextCommandId
1666 wxRICHTEXT_CHANGE_STYLE
1670 * Command classes for undo/redo
1674 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextAction
;
1675 class WXDLLIMPEXP_RICHTEXT wxRichTextCommand
: public wxCommand
1678 // Ctor for one action
1679 wxRichTextCommand(const wxString
& name
, wxRichTextCommandId id
, wxRichTextBuffer
* buffer
,
1680 wxRichTextCtrl
* ctrl
, bool ignoreFirstTime
= false);
1682 // Ctor for multiple actions
1683 wxRichTextCommand(const wxString
& name
);
1685 virtual ~wxRichTextCommand();
1690 void AddAction(wxRichTextAction
* action
);
1691 void ClearActions();
1693 wxList
& GetActions() { return m_actions
; }
1701 * wxRichTextAction class declaration
1702 * There can be more than one action in a command.
1705 class WXDLLIMPEXP_RICHTEXT wxRichTextAction
: public wxObject
1708 wxRichTextAction(wxRichTextCommand
* cmd
, const wxString
& name
, wxRichTextCommandId id
, wxRichTextBuffer
* buffer
,
1709 wxRichTextCtrl
* ctrl
, bool ignoreFirstTime
= false);
1711 virtual ~wxRichTextAction();
1716 /// Update the control appearance
1717 void UpdateAppearance(long caretPosition
, bool sendUpdateEvent
= false,
1718 wxArrayInt
* optimizationLineCharPositions
= NULL
, wxArrayInt
* optimizationLineYPositions
= NULL
, bool isDoCmd
= true);
1720 /// Replace the buffer paragraphs with the given fragment.
1721 void ApplyParagraphs(const wxRichTextParagraphLayoutBox
& fragment
);
1723 /// Get the fragments
1724 wxRichTextParagraphLayoutBox
& GetNewParagraphs() { return m_newParagraphs
; }
1725 wxRichTextParagraphLayoutBox
& GetOldParagraphs() { return m_oldParagraphs
; }
1727 /// Calculate arrays for refresh optimization
1728 void CalculateRefreshOptimizations(wxArrayInt
& optimizationLineCharPositions
, wxArrayInt
& optimizationLineYPositions
);
1730 /// Set/get the position used for e.g. insertion
1731 void SetPosition(long pos
) { m_position
= pos
; }
1732 long GetPosition() const { return m_position
; }
1734 /// Set/get the range for e.g. deletion
1735 void SetRange(const wxRichTextRange
& range
) { m_range
= range
; }
1736 const wxRichTextRange
& GetRange() const { return m_range
; }
1739 const wxString
& GetName() const { return m_name
; }
1746 wxRichTextBuffer
* m_buffer
;
1749 wxRichTextCtrl
* m_ctrl
;
1751 // Stores the new paragraphs
1752 wxRichTextParagraphLayoutBox m_newParagraphs
;
1754 // Stores the old paragraphs
1755 wxRichTextParagraphLayoutBox m_oldParagraphs
;
1757 // The affected range
1758 wxRichTextRange m_range
;
1760 // The insertion point for this command
1763 // Ignore 1st 'Do' operation because we already did it
1766 // The command identifier
1767 wxRichTextCommandId m_cmdId
;
1774 // Include style sheet when loading and saving
1775 #define wxRICHTEXT_HANDLER_INCLUDE_STYLESHEET 0x0001
1777 // Save images to memory file system in HTML handler
1778 #define wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_MEMORY 0x0010
1780 // Save images to files in HTML handler
1781 #define wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_FILES 0x0020
1783 // Save images as inline base64 data in HTML handler
1784 #define wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_BASE64 0x0040
1786 // Don't write header and footer (or BODY), so we can include the fragment
1787 // in a larger document
1788 #define wxRICHTEXT_HANDLER_NO_HEADER_FOOTER 0x0080
1790 // Convert the more common face names to names that will work on the current platform
1791 // in a larger document
1792 #define wxRICHTEXT_HANDLER_CONVERT_FACENAMES 0x0100
1795 * wxRichTextFileHandler
1796 * Base class for file handlers
1799 class WXDLLIMPEXP_RICHTEXT wxRichTextFileHandler
: public wxObject
1801 DECLARE_CLASS(wxRichTextFileHandler
)
1803 wxRichTextFileHandler(const wxString
& name
= wxEmptyString
, const wxString
& ext
= wxEmptyString
, int type
= 0)
1804 : m_name(name
), m_extension(ext
), m_type(type
), m_flags(0), m_visible(true)
1808 bool LoadFile(wxRichTextBuffer
*buffer
, wxInputStream
& stream
)
1809 { return DoLoadFile(buffer
, stream
); }
1810 bool SaveFile(wxRichTextBuffer
*buffer
, wxOutputStream
& stream
)
1811 { return DoSaveFile(buffer
, stream
); }
1814 #if wxUSE_FFILE && wxUSE_STREAMS
1815 virtual bool LoadFile(wxRichTextBuffer
*buffer
, const wxString
& filename
);
1816 virtual bool SaveFile(wxRichTextBuffer
*buffer
, const wxString
& filename
);
1817 #endif // wxUSE_STREAMS && wxUSE_STREAMS
1819 /// Can we handle this filename (if using files)? By default, checks the extension.
1820 virtual bool CanHandle(const wxString
& filename
) const;
1822 /// Can we save using this handler?
1823 virtual bool CanSave() const { return false; }
1825 /// Can we load using this handler?
1826 virtual bool CanLoad() const { return false; }
1828 /// Should this handler be visible to the user?
1829 virtual bool IsVisible() const { return m_visible
; }
1830 virtual void SetVisible(bool visible
) { m_visible
= visible
; }
1832 /// The name of the nandler
1833 void SetName(const wxString
& name
) { m_name
= name
; }
1834 wxString
GetName() const { return m_name
; }
1836 /// The default extension to recognise
1837 void SetExtension(const wxString
& ext
) { m_extension
= ext
; }
1838 wxString
GetExtension() const { return m_extension
; }
1840 /// The handler type
1841 void SetType(int type
) { m_type
= type
; }
1842 int GetType() const { return m_type
; }
1844 /// Flags controlling how loading and saving is done
1845 void SetFlags(int flags
) { m_flags
= flags
; }
1846 int GetFlags() const { return m_flags
; }
1848 /// Encoding to use when saving a file. If empty, a suitable encoding is chosen
1849 void SetEncoding(const wxString
& encoding
) { m_encoding
= encoding
; }
1850 const wxString
& GetEncoding() const { return m_encoding
; }
1855 virtual bool DoLoadFile(wxRichTextBuffer
*buffer
, wxInputStream
& stream
) = 0;
1856 virtual bool DoSaveFile(wxRichTextBuffer
*buffer
, wxOutputStream
& stream
) = 0;
1860 wxString m_encoding
;
1861 wxString m_extension
;
1868 * wxRichTextPlainTextHandler
1869 * Plain text handler
1872 class WXDLLIMPEXP_RICHTEXT wxRichTextPlainTextHandler
: public wxRichTextFileHandler
1874 DECLARE_CLASS(wxRichTextPlainTextHandler
)
1876 wxRichTextPlainTextHandler(const wxString
& name
= wxT("Text"),
1877 const wxString
& ext
= wxT("txt"),
1878 wxRichTextFileType type
= wxRICHTEXT_TYPE_TEXT
)
1879 : wxRichTextFileHandler(name
, ext
, type
)
1882 /// Can we save using this handler?
1883 virtual bool CanSave() const { return true; }
1885 /// Can we load using this handler?
1886 virtual bool CanLoad() const { return true; }
1891 virtual bool DoLoadFile(wxRichTextBuffer
*buffer
, wxInputStream
& stream
);
1892 virtual bool DoSaveFile(wxRichTextBuffer
*buffer
, wxOutputStream
& stream
);
1900 * The data object for a wxRichTextBuffer
1903 class WXDLLIMPEXP_RICHTEXT wxRichTextBufferDataObject
: public wxDataObjectSimple
1906 // ctor doesn't copy the pointer, so it shouldn't go away while this object
1908 wxRichTextBufferDataObject(wxRichTextBuffer
* richTextBuffer
= (wxRichTextBuffer
*) NULL
);
1909 virtual ~wxRichTextBufferDataObject();
1911 // after a call to this function, the buffer is owned by the caller and it
1912 // is responsible for deleting it
1913 wxRichTextBuffer
* GetRichTextBuffer();
1915 // Returns the id for the new data format
1916 static const wxChar
* GetRichTextBufferFormatId() { return ms_richTextBufferFormatId
; }
1918 // base class pure virtuals
1920 virtual wxDataFormat
GetPreferredFormat(Direction dir
) const;
1921 virtual size_t GetDataSize() const;
1922 virtual bool GetDataHere(void *pBuf
) const;
1923 virtual bool SetData(size_t len
, const void *buf
);
1927 virtual size_t GetDataSize(const wxDataFormat
&) const { return GetDataSize(); }
1928 virtual bool GetDataHere(const wxDataFormat
&, void *buf
) const { return GetDataHere(buf
); }
1929 virtual bool SetData(const wxDataFormat
&, size_t len
, const void *buf
) { return SetData(len
, buf
); }
1932 wxDataFormat m_formatRichTextBuffer
; // our custom format
1933 wxRichTextBuffer
* m_richTextBuffer
; // our data
1934 static const wxChar
* ms_richTextBufferFormatId
; // our format id
1940 * wxRichTextRenderer isolates common drawing functionality
1943 class WXDLLIMPEXP_RICHTEXT wxRichTextRenderer
: public wxObject
1946 wxRichTextRenderer() {}
1947 virtual ~wxRichTextRenderer() {}
1949 /// Draw a standard bullet, as specified by the value of GetBulletName
1950 virtual bool DrawStandardBullet(wxRichTextParagraph
* paragraph
, wxDC
& dc
, const wxTextAttr
& attr
, const wxRect
& rect
) = 0;
1952 /// Draw a bullet that can be described by text, such as numbered or symbol bullets
1953 virtual bool DrawTextBullet(wxRichTextParagraph
* paragraph
, wxDC
& dc
, const wxTextAttr
& attr
, const wxRect
& rect
, const wxString
& text
) = 0;
1955 /// Draw a bitmap bullet, where the bullet bitmap is specified by the value of GetBulletName
1956 virtual bool DrawBitmapBullet(wxRichTextParagraph
* paragraph
, wxDC
& dc
, const wxTextAttr
& attr
, const wxRect
& rect
) = 0;
1958 /// Enumerate the standard bullet names currently supported
1959 virtual bool EnumerateStandardBulletNames(wxArrayString
& bulletNames
) = 0;
1963 * wxRichTextStdRenderer: standard renderer
1966 class WXDLLIMPEXP_RICHTEXT wxRichTextStdRenderer
: public wxRichTextRenderer
1969 wxRichTextStdRenderer() {}
1971 /// Draw a standard bullet, as specified by the value of GetBulletName
1972 virtual bool DrawStandardBullet(wxRichTextParagraph
* paragraph
, wxDC
& dc
, const wxTextAttr
& attr
, const wxRect
& rect
);
1974 /// Draw a bullet that can be described by text, such as numbered or symbol bullets
1975 virtual bool DrawTextBullet(wxRichTextParagraph
* paragraph
, wxDC
& dc
, const wxTextAttr
& attr
, const wxRect
& rect
, const wxString
& text
);
1977 /// Draw a bitmap bullet, where the bullet bitmap is specified by the value of GetBulletName
1978 virtual bool DrawBitmapBullet(wxRichTextParagraph
* paragraph
, wxDC
& dc
, const wxTextAttr
& attr
, const wxRect
& rect
);
1980 /// Enumerate the standard bullet names currently supported
1981 virtual bool EnumerateStandardBulletNames(wxArrayString
& bulletNames
);
1989 inline bool wxRichTextHasStyle(int flags
, int style
)
1991 return ((flags
& style
) == style
);
1994 /// Compare two attribute objects
1995 WXDLLIMPEXP_RICHTEXT
bool wxTextAttrEq(const wxTextAttr
& attr1
, const wxTextAttr
& attr2
);
1996 WXDLLIMPEXP_RICHTEXT
bool wxTextAttrEq(const wxTextAttr
& attr1
, const wxTextAttr
& attr2
);
1998 /// Compare two attribute objects, but take into account the flags
1999 /// specifying attributes of interest.
2000 WXDLLIMPEXP_RICHTEXT
bool wxTextAttrEqPartial(const wxTextAttr
& attr1
, const wxTextAttr
& attr2
, int flags
);
2002 /// Apply one style to another
2003 WXDLLIMPEXP_RICHTEXT
bool wxRichTextApplyStyle(wxTextAttr
& destStyle
, const wxTextAttr
& style
, wxTextAttr
* compareWith
= NULL
);
2005 // Remove attributes
2006 WXDLLIMPEXP_RICHTEXT
bool wxRichTextRemoveStyle(wxTextAttr
& destStyle
, const wxTextAttr
& style
);
2008 /// Combine two bitlists
2009 WXDLLIMPEXP_RICHTEXT
bool wxRichTextCombineBitlists(int& valueA
, int valueB
, int& flagsA
, int flagsB
);
2011 /// Compare two bitlists
2012 WXDLLIMPEXP_RICHTEXT
bool wxRichTextBitlistsEqPartial(int valueA
, int valueB
, int flags
);
2014 /// Split into paragraph and character styles
2015 WXDLLIMPEXP_RICHTEXT
bool wxRichTextSplitParaCharStyles(const wxTextAttr
& style
, wxTextAttr
& parStyle
, wxTextAttr
& charStyle
);
2018 WXDLLIMPEXP_RICHTEXT
bool wxRichTextTabsEq(const wxArrayInt
& tabs1
, const wxArrayInt
& tabs2
);
2020 /// Convert a decimal to Roman numerals
2021 WXDLLIMPEXP_RICHTEXT wxString
wxRichTextDecimalToRoman(long n
);
2023 WXDLLIMPEXP_RICHTEXT
void wxRichTextModuleInit();
2029 // _WX_RICHTEXTBUFFER_H_