include/wx/richtext/richtextbuffer.h

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