interface/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 /**
  13     The line break character that can be embedded in content.
  14  */
  15
  16 extern WXDLLIMPEXP_RICHTEXT const wxChar wxRichTextLineBreakChar;
  17
  18 /**
  19     File types in wxRichText context.
  20  */
  21 enum wxRichTextFileType
  22 {
  23     wxRICHTEXT_TYPE_ANY = 0,
  24     wxRICHTEXT_TYPE_TEXT,
  25     wxRICHTEXT_TYPE_XML,
  26     wxRICHTEXT_TYPE_HTML,
  27     wxRICHTEXT_TYPE_RTF,
  28     wxRICHTEXT_TYPE_PDF
  29 };
  30
  31 /**
  32     Flags determining the available space, passed to Layout.
  33  */
  34
  35 #define wxRICHTEXT_FIXED_WIDTH      0x01
  36 #define wxRICHTEXT_FIXED_HEIGHT     0x02
  37 #define wxRICHTEXT_VARIABLE_WIDTH   0x04
  38 #define wxRICHTEXT_VARIABLE_HEIGHT  0x08
  39
  40 // Only lay out the part of the buffer that lies within
  41 // the rect passed to Layout.
  42 #define wxRICHTEXT_LAYOUT_SPECIFIED_RECT 0x10
  43
  44 /**
  45     Flags to pass to Draw
  46  */
  47
  48 // Ignore paragraph cache optimization, e.g. for printing purposes
  49 // where one line may be drawn higher (on the next page) compared
  50 // with the previous line
  51 #define wxRICHTEXT_DRAW_IGNORE_CACHE    0x01
  52 #define wxRICHTEXT_DRAW_SELECTED        0x02
  53 #define wxRICHTEXT_DRAW_PRINT           0x04
  54 #define wxRICHTEXT_DRAW_GUIDELINES      0x08
  55
  56 /**
  57     Flags returned from hit-testing, or passed to hit-test function.
  58  */
  59 enum wxRichTextHitTestFlags
  60 {
  61     // The point was not on this object
  62     wxRICHTEXT_HITTEST_NONE =    0x01,
  63
  64     // The point was before the position returned from HitTest
  65     wxRICHTEXT_HITTEST_BEFORE =  0x02,
  66
  67     // The point was after the position returned from HitTest
  68     wxRICHTEXT_HITTEST_AFTER =   0x04,
  69
  70     // The point was on the position returned from HitTest
  71     wxRICHTEXT_HITTEST_ON =      0x08,
  72
  73     // The point was on space outside content
  74     wxRICHTEXT_HITTEST_OUTSIDE = 0x10,
  75
  76     // Only do hit-testing at the current level (don't traverse into top-level objects)
  77     wxRICHTEXT_HITTEST_NO_NESTED_OBJECTS = 0x20,
  78
  79     // Ignore floating objects
  80     wxRICHTEXT_HITTEST_NO_FLOATING_OBJECTS = 0x40
  81 };
  82
  83 /**
  84     Flags for GetRangeSize.
  85  */
  86
  87 #define wxRICHTEXT_FORMATTED        0x01
  88 #define wxRICHTEXT_UNFORMATTED      0x02
  89 #define wxRICHTEXT_CACHE_SIZE       0x04
  90 #define wxRICHTEXT_HEIGHT_ONLY      0x08
  91
  92 /**
  93     Flags for SetStyle/SetListStyle.
  94  */
  95
  96 #define wxRICHTEXT_SETSTYLE_NONE            0x00
  97
  98 // Specifies that this operation should be undoable
  99 #define wxRICHTEXT_SETSTYLE_WITH_UNDO       0x01
 100
 101 // Specifies that the style should not be applied if the
 102 // combined style at this point is already the style in question.
 103 #define wxRICHTEXT_SETSTYLE_OPTIMIZE        0x02
 104
 105 // Specifies that the style should only be applied to paragraphs,
 106 // and not the content. This allows content styling to be
 107 // preserved independently from that of e.g. a named paragraph style.
 108 #define wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY 0x04
 109
 110 // Specifies that the style should only be applied to characters,
 111 // and not the paragraph. This allows content styling to be
 112 // preserved independently from that of e.g. a named paragraph style.
 113 #define wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY 0x08
 114
 115 // For SetListStyle only: specifies starting from the given number, otherwise
 116 // deduces number from existing attributes
 117 #define wxRICHTEXT_SETSTYLE_RENUMBER        0x10
 118
 119 // For SetListStyle only: specifies the list level for all paragraphs, otherwise
 120 // the current indentation will be used
 121 #define wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL   0x20
 122
 123 // Resets the existing style before applying the new style
 124 #define wxRICHTEXT_SETSTYLE_RESET           0x40
 125
 126 // Removes the given style instead of applying it
 127 #define wxRICHTEXT_SETSTYLE_REMOVE          0x80
 128
 129 /**
 130     Flags for SetProperties.
 131  */
 132
 133 #define wxRICHTEXT_SETPROPERTIES_NONE            0x00
 134
 135 // Specifies that this operation should be undoable
 136 #define wxRICHTEXT_SETPROPERTIES_WITH_UNDO       0x01
 137
 138 // Specifies that the properties should only be applied to paragraphs,
 139 // and not the content.
 140 #define wxRICHTEXT_SETPROPERTIES_PARAGRAPHS_ONLY 0x02
 141
 142 // Specifies that the properties should only be applied to characters,
 143 // and not the paragraph.
 144 #define wxRICHTEXT_SETPROPERTIES_CHARACTERS_ONLY 0x04
 145
 146 // Resets the existing properties before applying the new properties.
 147 #define wxRICHTEXT_SETPROPERTIES_RESET           0x08
 148
 149 // Removes the given properties instead of applying them.
 150 #define wxRICHTEXT_SETPROPERTIES_REMOVE          0x10
 151
 152 /**
 153     Flags for object insertion.
 154  */
 155
 156 #define wxRICHTEXT_INSERT_NONE                              0x00
 157 #define wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE     0x01
 158 #define wxRICHTEXT_INSERT_INTERACTIVE                       0x02
 159
 160 // A special flag telling the buffer to keep the first paragraph style
 161 // as-is, when deleting a paragraph marker. In future we might pass a
 162 // flag to InsertFragment and DeleteRange to indicate the appropriate mode.
 163 #define wxTEXT_ATTR_KEEP_FIRST_PARA_STYLE   0x10000000
 164
 165 /**
 166     Default superscript/subscript font multiplication factor.
 167  */
 168
 169 #define wxSCRIPT_MUL_FACTOR             1.5
 170
 171 /**
 172     The type for wxTextAttrDimension flags.
 173  */
 174 typedef unsigned short wxTextAttrDimensionFlags;
 175
 176 /**
 177     Miscellaneous text box flags
 178  */
 179 enum wxTextBoxAttrFlags
 180 {
 181     wxTEXT_BOX_ATTR_FLOAT                   = 0x00000001,
 182     wxTEXT_BOX_ATTR_CLEAR                   = 0x00000002,
 183     wxTEXT_BOX_ATTR_COLLAPSE_BORDERS        = 0x00000004,
 184     wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT      = 0x00000008
 185 };
 186
 187 /**
 188     Whether a value is present, used in dimension flags.
 189  */
 190 enum wxTextAttrValueFlags
 191 {
 192     wxTEXT_ATTR_VALUE_VALID               = 0x1000,
 193     wxTEXT_ATTR_VALUE_VALID_MASK          = 0x1000
 194 };
 195
 196 /**
 197     Units, included in the dimension value.
 198  */
 199 enum wxTextAttrUnits
 200 {
 201     wxTEXT_ATTR_UNITS_TENTHS_MM             = 0x0001,
 202     wxTEXT_ATTR_UNITS_PIXELS                = 0x0002,
 203     wxTEXT_ATTR_UNITS_PERCENTAGE            = 0x0004,
 204     wxTEXT_ATTR_UNITS_POINTS                = 0x0008,
 205
 206     wxTEXT_ATTR_UNITS_MASK                  = 0x000F
 207 };
 208
 209 /**
 210     Position alternatives, included in the dimension flags.
 211  */
 212 enum wxTextBoxAttrPosition
 213 {
 214     wxTEXT_BOX_ATTR_POSITION_STATIC         = 0x0000, // Default is static, i.e. as per normal layout
 215     wxTEXT_BOX_ATTR_POSITION_RELATIVE       = 0x0010, // Relative to the relevant edge
 216     wxTEXT_BOX_ATTR_POSITION_ABSOLUTE       = 0x0020,
 217
 218     wxTEXT_BOX_ATTR_POSITION_MASK           = 0x00F0
 219 };
 220
 221 /**
 222     @class wxTextAttrDimension
 223
 224     A class representing a rich text dimension, including units and position.
 225
 226     @library{wxrichtext}
 227     @category{richtext}
 228
 229     @see wxRichTextAttr, wxRichTextCtrl,  wxTextAttrDimensions
 230 */
 231
 232 class WXDLLIMPEXP_RICHTEXT wxTextAttrDimension
 233 {
 234 public:
 235     /**
 236         Default constructor.
 237     */
 238     wxTextAttrDimension() { Reset(); }
 239     /**
 240         Constructor taking value and units flag.
 241     */
 242     wxTextAttrDimension(int value, wxTextAttrUnits units = wxTEXT_ATTR_UNITS_TENTHS_MM) { m_value = value; m_flags = units|wxTEXT_ATTR_VALUE_VALID; }
 243
 244     /**
 245         Resets the dimension value and flags.
 246     */
 247     void Reset() { m_value = 0; m_flags = 0; }
 248
 249     /**
 250         Partial equality test.
 251     */
 252     bool EqPartial(const wxTextAttrDimension& dim) const;
 253
 254     /** Apply the dimension, but not those identical to @a compareWith if present.
 255     */
 256     bool Apply(const wxTextAttrDimension& dim, const wxTextAttrDimension* compareWith = NULL);
 257
 258     /** Collects the attributes that are common to a range of content, building up a note of
 259         which attributes are absent in some objects and which clash in some objects.
 260     */
 261     void CollectCommonAttributes(const wxTextAttrDimension& attr, wxTextAttrDimension& clashingAttr, wxTextAttrDimension& absentAttr);
 262
 263     /**
 264         Equality operator.
 265     */
 266     bool operator==(const wxTextAttrDimension& dim) const { return m_value == dim.m_value && m_flags == dim.m_flags; }
 267
 268     /**
 269         Returns the integer value of the dimension.
 270     */
 271     int GetValue() const { return m_value; }
 272
 273     /**
 274         Returns the floating-pointing value of the dimension in mm.
 275
 276     */
 277     float GetValueMM() const { return float(m_value) / 10.0; }
 278
 279     /**
 280         Sets the value of the dimension in mm.
 281     */
 282     void SetValueMM(float value) { m_value = (int) ((value * 10.0) + 0.5); m_flags |= wxTEXT_ATTR_VALUE_VALID; }
 283
 284     /**
 285         Sets the integer value of the dimension.
 286     */
 287     void SetValue(int value) { m_value = value; m_flags |= wxTEXT_ATTR_VALUE_VALID; }
 288
 289     /**
 290         Sets the integer value of the dimension, passing dimension flags.
 291     */
 292     void SetValue(int value, wxTextAttrDimensionFlags flags) { SetValue(value); m_flags = flags; }
 293
 294     /**
 295         Sets the integer value and units.
 296     */
 297     void SetValue(int value, wxTextAttrUnits units) { m_value = value; m_flags = units | wxTEXT_ATTR_VALUE_VALID; }
 298
 299     /**
 300         Sets the dimension.
 301     */
 302     void SetValue(const wxTextAttrDimension& dim) { (*this) = dim; }
 303
 304     /**
 305         Gets the units of the dimension.
 306     */
 307     wxTextAttrUnits GetUnits() const { return (wxTextAttrUnits) (m_flags & wxTEXT_ATTR_UNITS_MASK); }
 308
 309     /**
 310         Sets the units of the dimension.
 311     */
 312     void SetUnits(wxTextAttrUnits units) { m_flags &= ~wxTEXT_ATTR_UNITS_MASK; m_flags |= units; }
 313
 314     /**
 315         Gets the position flags.
 316     */
 317     wxTextBoxAttrPosition GetPosition() const { return (wxTextBoxAttrPosition) (m_flags & wxTEXT_BOX_ATTR_POSITION_MASK); }
 318
 319     /**
 320         Sets the position flags.
 321     */
 322     void SetPosition(wxTextBoxAttrPosition pos) { m_flags &= ~wxTEXT_BOX_ATTR_POSITION_MASK; m_flags |= pos; }
 323
 324     /**
 325         Returns @true if the dimension is valid.
 326     */
 327     bool IsValid() const { return (m_flags & wxTEXT_ATTR_VALUE_VALID) != 0; }
 328
 329     /**
 330         Sets the valid flag.
 331     */
 332     void SetValid(bool b) { m_flags &= ~wxTEXT_ATTR_VALUE_VALID_MASK; m_flags |= (b ? wxTEXT_ATTR_VALUE_VALID : 0); }
 333
 334     /**
 335         Gets the dimension flags.
 336     */
 337     wxTextAttrDimensionFlags GetFlags() const { return m_flags; }
 338
 339     /**
 340         Sets the dimension flags.
 341     */
 342     void SetFlags(wxTextAttrDimensionFlags flags) { m_flags = flags; }
 343
 344     int                         m_value;
 345     wxTextAttrDimensionFlags    m_flags;
 346 };
 347
 348 /**
 349     @class wxTextAttrDimensions
 350     A class for left, right, top and bottom dimensions.
 351
 352     @library{wxrichtext}
 353     @category{richtext}
 354
 355     @see wxRichTextAttr, wxRichTextCtrl, wxTextAttrDimension
 356 */
 357
 358 class WXDLLIMPEXP_RICHTEXT wxTextAttrDimensions
 359 {
 360 public:
 361     /**
 362         Default constructor.
 363     */
 364     wxTextAttrDimensions() {}
 365
 366     /**
 367         Resets the value and flags for all dimensions.
 368     */
 369     void Reset() { m_left.Reset(); m_top.Reset(); m_right.Reset(); m_bottom.Reset(); }
 370
 371     /**
 372         Equality operator.
 373     */
 374     bool operator==(const wxTextAttrDimensions& dims) const { return m_left == dims.m_left && m_top == dims.m_top && m_right == dims.m_right && m_bottom == dims.m_bottom; }
 375
 376     /**
 377         Partial equality test.
 378
 379     */
 380     bool EqPartial(const wxTextAttrDimensions& dims) const;
 381
 382     /**
 383         Apply border to 'this', but not if the same as @a compareWith.
 384
 385     */
 386     bool Apply(const wxTextAttrDimensions& dims, const wxTextAttrDimensions* compareWith = NULL);
 387
 388     /**
 389         Collects the attributes that are common to a range of content, building up a note of
 390         which attributes are absent in some objects and which clash in some objects.
 391
 392     */
 393     void CollectCommonAttributes(const wxTextAttrDimensions& attr, wxTextAttrDimensions& clashingAttr, wxTextAttrDimensions& absentAttr);
 394
 395     /**
 396         Remove specified attributes from this object.
 397     */
 398     bool RemoveStyle(const wxTextAttrDimensions& attr);
 399
 400     /**
 401         Gets the left dimension.
 402     */
 403     const wxTextAttrDimension& GetLeft() const { return m_left; }
 404     wxTextAttrDimension& GetLeft() { return m_left; }
 405
 406     /**
 407         Gets the right dimension.
 408
 409     */
 410     const wxTextAttrDimension& GetRight() const { return m_right; }
 411     wxTextAttrDimension& GetRight() { return m_right; }
 412
 413     /**
 414         Gets the top dimension.
 415
 416     */
 417     const wxTextAttrDimension& GetTop() const { return m_top; }
 418     wxTextAttrDimension& GetTop() { return m_top; }
 419
 420     /**
 421         Gets the bottom dimension.
 422
 423     */
 424     const wxTextAttrDimension& GetBottom() const { return m_bottom; }
 425     wxTextAttrDimension& GetBottom() { return m_bottom; }
 426
 427     /**
 428         Are all dimensions valid?
 429
 430     */
 431     bool IsValid() const { return m_left.IsValid() && m_top.IsValid() && m_right.IsValid() && m_bottom.IsValid(); }
 432
 433     wxTextAttrDimension         m_left;
 434     wxTextAttrDimension         m_top;
 435     wxTextAttrDimension         m_right;
 436     wxTextAttrDimension         m_bottom;
 437 };
 438
 439 /**
 440     @class wxTextAttrSize
 441     A class for representing width and height.
 442
 443     @library{wxrichtext}
 444     @category{richtext}
 445
 446     @see wxRichTextAttr, wxRichTextCtrl, wxTextAttrDimension
 447 */
 448
 449 class WXDLLIMPEXP_RICHTEXT wxTextAttrSize
 450 {
 451 public:
 452     /**
 453         Default constructor.
 454     */
 455     wxTextAttrSize() {}
 456
 457     /**
 458         Resets the width and height dimensions.
 459     */
 460     void Reset() { m_width.Reset(); m_height.Reset(); }
 461
 462     /**
 463         Equality operator.
 464     */
 465     bool operator==(const wxTextAttrSize& size) const { return m_width == size.m_width && m_height == size.m_height ; }
 466
 467     /**
 468         Partial equality test.
 469     */
 470     bool EqPartial(const wxTextAttrSize& dims) const;
 471
 472     /**
 473         Apply border to this object, but not if the same as @a compareWith.
 474     */
 475     bool Apply(const wxTextAttrSize& dims, const wxTextAttrSize* compareWith = NULL);
 476
 477     /**
 478         Collects the attributes that are common to a range of content, building up a note of
 479         which attributes are absent in some objects and which clash in some objects.
 480     */
 481     void CollectCommonAttributes(const wxTextAttrSize& attr, wxTextAttrSize& clashingAttr, wxTextAttrSize& absentAttr);
 482
 483     /**
 484         Removes the specified attributes from this object.
 485     */
 486     bool RemoveStyle(const wxTextAttrSize& attr);
 487
 488     /**
 489         Returns the width.
 490     */
 491     wxTextAttrDimension& GetWidth() { return m_width; }
 492     const wxTextAttrDimension& GetWidth() const { return m_width; }
 493
 494     /**
 495         Sets the width.
 496     */
 497     void SetWidth(int value, wxTextAttrDimensionFlags flags) { m_width.SetValue(value, flags); }
 498
 499     /**
 500         Sets the width.
 501     */
 502     void SetWidth(int value, wxTextAttrUnits units) { m_width.SetValue(value, units); }
 503
 504     /**
 505         Sets the width.
 506     */
 507     void SetWidth(const wxTextAttrDimension& dim) { m_width.SetValue(dim); }
 508
 509     /**
 510         Gets the height.
 511     */
 512     wxTextAttrDimension& GetHeight() { return m_height; }
 513     const wxTextAttrDimension& GetHeight() const { return m_height; }
 514
 515     /**
 516         Sets the height.
 517     */
 518     void SetHeight(int value, wxTextAttrDimensionFlags flags) { m_height.SetValue(value, flags); }
 519
 520     /**
 521         Sets the height.
 522     */
 523     void SetHeight(int value, wxTextAttrUnits units) { m_height.SetValue(value, units); }
 524
 525     /**
 526         Sets the height.
 527     */
 528     void SetHeight(const wxTextAttrDimension& dim) { m_height.SetValue(dim); }
 529
 530     /**
 531         Is the size valid?
 532     */
 533     bool IsValid() const { return m_width.IsValid() && m_height.IsValid(); }
 534
 535     wxTextAttrDimension         m_width;
 536     wxTextAttrDimension         m_height;
 537 };
 538
 539 /**
 540     @class wxTextAttrDimensionConverter
 541     A class to make it easier to convert dimensions.
 542
 543     @library{wxrichtext}
 544     @category{richtext}
 545
 546     @see wxRichTextAttr, wxRichTextCtrl, wxTextAttrDimension
 547 */
 548
 549 class WXDLLIMPEXP_RICHTEXT wxTextAttrDimensionConverter
 550 {
 551 public:
 552     /**
 553         Constructor.
 554     */
 555     wxTextAttrDimensionConverter(wxDC& dc, double scale = 1.0, const wxSize& parentSize = wxDefaultSize);
 556     /**
 557         Constructor.
 558     */
 559     wxTextAttrDimensionConverter(int ppi, double scale = 1.0, const wxSize& parentSize = wxDefaultSize);
 560
 561     /**
 562         Gets the pixel size for the given dimension.
 563     */
 564     int GetPixels(const wxTextAttrDimension& dim, int direction = wxHORIZONTAL) const;
 565     /**
 566         Gets the mm size for the given dimension.
 567     */
 568     int GetTenthsMM(const wxTextAttrDimension& dim) const;
 569
 570     /**
 571         Converts tenths of a mm to pixels.
 572     */
 573     int ConvertTenthsMMToPixels(int units) const;
 574     /**
 575         Converts pixels to tenths of a mm.
 576     */
 577     int ConvertPixelsToTenthsMM(int pixels) const;
 578
 579     int     m_ppi;
 580     double  m_scale;
 581     wxSize  m_parentSize;
 582 };
 583
 584 /**
 585     Border styles, used with wxTextAttrBorder.
 586  */
 587 enum wxTextAttrBorderStyle
 588 {
 589     wxTEXT_BOX_ATTR_BORDER_NONE             = 0,
 590     wxTEXT_BOX_ATTR_BORDER_SOLID            = 1,
 591     wxTEXT_BOX_ATTR_BORDER_DOTTED           = 2,
 592     wxTEXT_BOX_ATTR_BORDER_DASHED           = 3,
 593     wxTEXT_BOX_ATTR_BORDER_DOUBLE           = 4,
 594     wxTEXT_BOX_ATTR_BORDER_GROOVE           = 5,
 595     wxTEXT_BOX_ATTR_BORDER_RIDGE            = 6,
 596     wxTEXT_BOX_ATTR_BORDER_INSET            = 7,
 597     wxTEXT_BOX_ATTR_BORDER_OUTSET           = 8
 598 };
 599
 600 /**
 601     Border style presence flags, used with wxTextAttrBorder.
 602  */
 603 enum wxTextAttrBorderFlags
 604 {
 605     wxTEXT_BOX_ATTR_BORDER_STYLE            = 0x0001,
 606     wxTEXT_BOX_ATTR_BORDER_COLOUR           = 0x0002
 607 };
 608
 609 /**
 610     Border width symbols for qualitative widths, used with wxTextAttrBorder.
 611  */
 612 enum wxTextAttrBorderWidth
 613 {
 614     wxTEXT_BOX_ATTR_BORDER_THIN             = -1,
 615     wxTEXT_BOX_ATTR_BORDER_MEDIUM           = -2,
 616     wxTEXT_BOX_ATTR_BORDER_THICK            = -3
 617 };
 618
 619 /**
 620     Float styles.
 621  */
 622 enum wxTextBoxAttrFloatStyle
 623 {
 624     wxTEXT_BOX_ATTR_FLOAT_NONE              = 0,
 625     wxTEXT_BOX_ATTR_FLOAT_LEFT              = 1,
 626     wxTEXT_BOX_ATTR_FLOAT_RIGHT             = 2
 627 };
 628
 629 /**
 630     Clear styles.
 631  */
 632 enum wxTextBoxAttrClearStyle
 633 {
 634     wxTEXT_BOX_ATTR_CLEAR_NONE              = 0,
 635     wxTEXT_BOX_ATTR_CLEAR_LEFT              = 1,
 636     wxTEXT_BOX_ATTR_CLEAR_RIGHT             = 2,
 637     wxTEXT_BOX_ATTR_CLEAR_BOTH              = 3
 638 };
 639
 640 /**
 641     Collapse mode styles. TODO: can they be switched on per side?
 642  */
 643 enum wxTextBoxAttrCollapseMode
 644 {
 645     wxTEXT_BOX_ATTR_COLLAPSE_NONE           = 0,
 646     wxTEXT_BOX_ATTR_COLLAPSE_FULL           = 1
 647 };
 648
 649 /**
 650     Vertical alignment values.
 651  */
 652 enum wxTextBoxAttrVerticalAlignment
 653 {
 654     wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_NONE =       0,
 655     wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_TOP  =       1,
 656     wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_CENTRE =     2,
 657     wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_BOTTOM  =    3
 658 };
 659
 660 /**
 661     @class wxTextAttrBorder
 662     A class representing a rich text object border.
 663
 664     @library{wxrichtext}
 665     @category{richtext}
 666
 667     @see wxRichTextAttr, wxRichTextCtrl, wxRichTextAttrBorders
 668 */
 669
 670 class WXDLLIMPEXP_RICHTEXT wxTextAttrBorder
 671 {
 672 public:
 673     /**
 674         Default constructor.
 675     */
 676     wxTextAttrBorder() { Reset(); }
 677
 678     /**
 679         Equality operator.
 680     */
 681     bool operator==(const wxTextAttrBorder& border) const
 682     {
 683         return m_flags == border.m_flags && m_borderStyle == border.m_borderStyle &&
 684                m_borderColour == border.m_borderColour && m_borderWidth == border.m_borderWidth;
 685     }
 686
 687     /**
 688         Resets the border style, colour, width and flags.
 689     */
 690     void Reset() { m_borderStyle = 0; m_borderColour = 0; m_flags = 0; m_borderWidth.Reset(); }
 691
 692     /**
 693         Partial equality test.
 694     */
 695     bool EqPartial(const wxTextAttrBorder& border) const;
 696
 697     /**
 698         Applies the border to this object, but not if the same as @a compareWith.
 699
 700     */
 701     bool Apply(const wxTextAttrBorder& border, const wxTextAttrBorder* compareWith = NULL);
 702
 703     /**
 704         Removes the specified attributes from this object.
 705     */
 706     bool RemoveStyle(const wxTextAttrBorder& attr);
 707
 708     /**
 709         Collects the attributes that are common to a range of content, building up a note of
 710         which attributes are absent in some objects and which clash in some objects.
 711     */
 712     void CollectCommonAttributes(const wxTextAttrBorder& attr, wxTextAttrBorder& clashingAttr, wxTextAttrBorder& absentAttr);
 713
 714     /**
 715         Sets the border style.
 716     */
 717     void SetStyle(int style) { m_borderStyle = style; m_flags |= wxTEXT_BOX_ATTR_BORDER_STYLE; }
 718
 719     /**
 720         Gets the border style.
 721
 722     */
 723     int GetStyle() const { return m_borderStyle; }
 724
 725     /**
 726         Sets the border colour.
 727     */
 728     void SetColour(unsigned long colour) { m_borderColour = colour; m_flags |= wxTEXT_BOX_ATTR_BORDER_COLOUR; }
 729
 730     /**
 731         Sets the border colour.
 732     */
 733     void SetColour(const wxColour& colour) { m_borderColour = colour.GetRGB(); m_flags |= wxTEXT_BOX_ATTR_BORDER_COLOUR; }
 734
 735     /**
 736         Gets the colour as a long.
 737     */
 738     unsigned long GetColourLong() const { return m_borderColour; }
 739
 740     /**
 741         Gets the colour.
 742     */
 743     wxColour GetColour() const { return wxColour(m_borderColour); }
 744
 745     /**
 746         Gets the border width.
 747     */
 748     wxTextAttrDimension& GetWidth() { return m_borderWidth; }
 749     const wxTextAttrDimension& GetWidth() const { return m_borderWidth; }
 750
 751     /**
 752         Sets the border width.
 753     */
 754     void SetWidth(const wxTextAttrDimension& width) { m_borderWidth = width; }
 755     /**
 756         Sets the border width.
 757     */
 758     void SetWidth(int value, wxTextAttrUnits units = wxTEXT_ATTR_UNITS_TENTHS_MM) { SetWidth(wxTextAttrDimension(value, units)); }
 759
 760     /**
 761         True if the border has a valid style.
 762     */
 763     bool HasStyle() const { return (m_flags & wxTEXT_BOX_ATTR_BORDER_STYLE) != 0; }
 764
 765     /**
 766         True if the border has a valid colour.
 767     */
 768     bool HasColour() const { return (m_flags & wxTEXT_BOX_ATTR_BORDER_COLOUR) != 0; }
 769
 770     /**
 771         True if the border has a valid width.
 772     */
 773     bool HasWidth() const { return m_borderWidth.IsValid(); }
 774
 775     /**
 776         True if the border is valid.
 777     */
 778     bool IsValid() const { return HasWidth(); }
 779
 780     /**
 781         Set the valid flag for this border.
 782     */
 783     void MakeValid() { m_borderWidth.SetValid(true); }
 784
 785     /**
 786         Returns the border flags.
 787     */
 788     int GetFlags() const { return m_flags; }
 789
 790     /**
 791         Sets the border flags.
 792     */
 793     void SetFlags(int flags) { m_flags = flags; }
 794
 795     /**
 796         Adds a border flag.
 797     */
 798     void AddFlag(int flag) { m_flags |= flag; }
 799
 800     /**
 801         Removes a border flag.
 802     */
 803     void RemoveFlag(int flag) { m_flags &= ~flag; }
 804
 805     int                         m_borderStyle;
 806     unsigned long               m_borderColour;
 807     wxTextAttrDimension         m_borderWidth;
 808     int                         m_flags;
 809 };
 810
 811 /**
 812     @class wxTextAttrBorders
 813     A class representing a rich text object's borders.
 814
 815     @library{wxrichtext}
 816     @category{richtext}
 817
 818     @see wxRichTextAttr, wxRichTextCtrl, wxRichTextAttrBorder
 819 */
 820
 821 class WXDLLIMPEXP_RICHTEXT wxTextAttrBorders
 822 {
 823 public:
 824     /**
 825         Default constructor.
 826     */
 827     wxTextAttrBorders() { }
 828
 829     /**
 830         Equality operator.
 831     */
 832     bool operator==(const wxTextAttrBorders& borders) const
 833     {
 834         return m_left == borders.m_left && m_right == borders.m_right &&
 835                m_top == borders.m_top && m_bottom == borders.m_bottom;
 836     }
 837
 838     /**
 839         Sets the style of all borders.
 840     */
 841     void SetStyle(int style);
 842
 843     /**
 844         Sets colour of all borders.
 845     */
 846     void SetColour(unsigned long colour);
 847
 848     /**
 849         Sets the colour for all borders.
 850     */
 851     void SetColour(const wxColour& colour);
 852
 853     /**
 854         Sets the width of all borders.
 855     */
 856     void SetWidth(const wxTextAttrDimension& width);
 857
 858     /**
 859         Sets the width of all borders.
 860     */
 861     void SetWidth(int value, wxTextAttrUnits units = wxTEXT_ATTR_UNITS_TENTHS_MM) { SetWidth(wxTextAttrDimension(value, units)); }
 862
 863     /**
 864         Resets all borders.
 865     */
 866     void Reset() { m_left.Reset(); m_right.Reset(); m_top.Reset(); m_bottom.Reset(); }
 867
 868     /**
 869         Partial equality test.
 870     */
 871     bool EqPartial(const wxTextAttrBorders& borders) const;
 872
 873     /**
 874         Applies border to this object, but not if the same as @a compareWith.
 875     */
 876     bool Apply(const wxTextAttrBorders& borders, const wxTextAttrBorders* compareWith = NULL);
 877
 878     /**
 879         Removes the specified attributes from this object.
 880     */
 881     bool RemoveStyle(const wxTextAttrBorders& attr);
 882
 883     /**
 884         Collects the attributes that are common to a range of content, building up a note of
 885         which attributes are absent in some objects and which clash in some objects.
 886     */
 887     void CollectCommonAttributes(const wxTextAttrBorders& attr, wxTextAttrBorders& clashingAttr, wxTextAttrBorders& absentAttr);
 888
 889     /**
 890         Returns @true if all borders are valid.
 891     */
 892     bool IsValid() const { return m_left.IsValid() || m_right.IsValid() || m_top.IsValid() || m_bottom.IsValid(); }
 893
 894     /**
 895         Returns the left border.
 896     */
 897     const wxTextAttrBorder& GetLeft() const { return m_left; }
 898     wxTextAttrBorder& GetLeft() { return m_left; }
 899
 900     /**
 901         Returns the right border.
 902     */
 903     const wxTextAttrBorder& GetRight() const { return m_right; }
 904     wxTextAttrBorder& GetRight() { return m_right; }
 905
 906     /**
 907         Returns the top border.
 908     */
 909     const wxTextAttrBorder& GetTop() const { return m_top; }
 910     wxTextAttrBorder& GetTop() { return m_top; }
 911
 912     /**
 913         Returns the bottom border.
 914     */
 915     const wxTextAttrBorder& GetBottom() const { return m_bottom; }
 916     wxTextAttrBorder& GetBottom() { return m_bottom; }
 917
 918     wxTextAttrBorder m_left, m_right, m_top, m_bottom;
 919
 920 };
 921
 922 /**
 923     @class wxTextBoxAttr
 924     A class representing the box attributes of a rich text object.
 925
 926     @library{wxrichtext}
 927     @category{richtext}
 928
 929     @see wxRichTextAttr, wxRichTextCtrl
 930 */
 931
 932 class WXDLLIMPEXP_RICHTEXT wxTextBoxAttr
 933 {
 934 public:
 935     /**
 936         Default constructor.
 937     */
 938     wxTextBoxAttr() { Init(); }
 939
 940     /**
 941         Copy constructor.
 942     */
 943     wxTextBoxAttr(const wxTextBoxAttr& attr) { Init(); (*this) = attr; }
 944
 945     /**
 946         Initialises this object.
 947     */
 948     void Init() { Reset(); }
 949
 950     /**
 951         Resets this object.
 952     */
 953     void Reset();
 954
 955     // Copy. Unnecessary since we let it do a binary copy
 956     //void Copy(const wxTextBoxAttr& attr);
 957
 958     // Assignment
 959     //void operator= (const wxTextBoxAttr& attr);
 960
 961     /**
 962         Equality test.
 963     */
 964     bool operator== (const wxTextBoxAttr& attr) const;
 965
 966     /**
 967         Partial equality test, ignoring unset attributes.
 968
 969     */
 970     bool EqPartial(const wxTextBoxAttr& attr) const;
 971
 972     /**
 973         Merges the given attributes. If @a compareWith is non-NULL, then it will be used
 974         to mask out those attributes that are the same in style and @a compareWith, for
 975         situations where we don't want to explicitly set inherited attributes.
 976     */
 977     bool Apply(const wxTextBoxAttr& style, const wxTextBoxAttr* compareWith = NULL);
 978
 979     /**
 980         Collects the attributes that are common to a range of content, building up a note of
 981         which attributes are absent in some objects and which clash in some objects.
 982     */
 983     void CollectCommonAttributes(const wxTextBoxAttr& attr, wxTextBoxAttr& clashingAttr, wxTextBoxAttr& absentAttr);
 984
 985     /**
 986         Removes the specified attributes from this object.
 987     */
 988     bool RemoveStyle(const wxTextBoxAttr& attr);
 989
 990     /**
 991         Sets the flags.
 992     */
 993     void SetFlags(int flags) { m_flags = flags; }
 994
 995     /**
 996         Returns the flags.
 997     */
 998     int GetFlags() const { return m_flags; }
 999
1000     /**
1001         Is this flag present?
1002     */
1003     bool HasFlag(wxTextBoxAttrFlags flag) const { return (m_flags & flag) != 0; }
1004
1005     /**
1006         Removes this flag.
1007     */
1008     void RemoveFlag(wxTextBoxAttrFlags flag) { m_flags &= ~flag; }
1009
1010     /**
1011         Adds this flag.
1012     */
1013     void AddFlag(wxTextBoxAttrFlags flag) { m_flags |= flag; }
1014
1015     /**
1016         Returns @true if no attributes are set.
1017     */
1018     bool IsDefault() const;
1019
1020     /**
1021         Returns the float mode.
1022     */
1023     wxTextBoxAttrFloatStyle GetFloatMode() const { return m_floatMode; }
1024
1025     /**
1026         Sets the float mode.
1027     */
1028     void SetFloatMode(wxTextBoxAttrFloatStyle mode) { m_floatMode = mode; m_flags |= wxTEXT_BOX_ATTR_FLOAT; }
1029
1030     /**
1031         Returns @true if float mode is active.
1032     */
1033     bool HasFloatMode() const { return HasFlag(wxTEXT_BOX_ATTR_FLOAT); }
1034
1035     /**
1036         Returns @true if this object is floating.
1037     */
1038     bool IsFloating() const { return HasFloatMode() && GetFloatMode() != wxTEXT_BOX_ATTR_FLOAT_NONE; }
1039
1040     /**
1041         Returns the clear mode - whether to wrap text after object. Currently unimplemented.
1042     */
1043     wxTextBoxAttrClearStyle GetClearMode() const { return m_clearMode; }
1044
1045     /**
1046         Set the clear mode. Currently unimplemented.
1047     */
1048     void SetClearMode(wxTextBoxAttrClearStyle mode) { m_clearMode = mode; m_flags |= wxTEXT_BOX_ATTR_CLEAR; }
1049
1050     /**
1051         Returns @true if we have a clear flag.
1052     */
1053     bool HasClearMode() const { return HasFlag(wxTEXT_BOX_ATTR_CLEAR); }
1054
1055     /**
1056         Returns the collapse mode - whether to collapse borders. Currently unimplemented.
1057     */
1058     wxTextBoxAttrCollapseMode GetCollapseBorders() const { return m_collapseMode; }
1059
1060     /**
1061         Sets the collapse mode - whether to collapse borders. Currently unimplemented.
1062     */
1063     void SetCollapseBorders(wxTextBoxAttrCollapseMode collapse) { m_collapseMode = collapse; m_flags |= wxTEXT_BOX_ATTR_COLLAPSE_BORDERS; }
1064
1065     /**
1066         Returns @true if the collapse borders flag is present.
1067     */
1068     bool HasCollapseBorders() const { return HasFlag(wxTEXT_BOX_ATTR_COLLAPSE_BORDERS); }
1069
1070     /**
1071         Returns the vertical alignment.
1072     */
1073     wxTextBoxAttrVerticalAlignment GetVerticalAlignment() const { return m_verticalAlignment; }
1074
1075     /**
1076         Sets the vertical alignment.
1077     */
1078     void SetVerticalAlignment(wxTextBoxAttrVerticalAlignment verticalAlignment) { m_verticalAlignment = verticalAlignment; m_flags |= wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT; }
1079
1080     /**
1081         Returns @true if a vertical alignment flag is present.
1082     */
1083     bool HasVerticalAlignment() const { return HasFlag(wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT); }
1084
1085     /**
1086         Returns the margin values.
1087     */
1088     wxTextAttrDimensions& GetMargins() { return m_margins; }
1089     const wxTextAttrDimensions& GetMargins() const { return m_margins; }
1090
1091     /**
1092         Returns the left margin.
1093     */
1094     wxTextAttrDimension& GetLeftMargin() { return m_margins.m_left; }
1095     const wxTextAttrDimension& GetLeftMargin() const { return m_margins.m_left; }
1096
1097     /**
1098         Returns the right margin.
1099     */
1100     wxTextAttrDimension& GetRightMargin() { return m_margins.m_right; }
1101     const wxTextAttrDimension& GetRightMargin() const { return m_margins.m_right; }
1102
1103     /**
1104         Returns the top margin.
1105     */
1106     wxTextAttrDimension& GetTopMargin() { return m_margins.m_top; }
1107     const wxTextAttrDimension& GetTopMargin() const { return m_margins.m_top; }
1108
1109     /**
1110         Returns the bottom margin.
1111     */
1112     wxTextAttrDimension& GetBottomMargin() { return m_margins.m_bottom; }
1113     const wxTextAttrDimension& GetBottomMargin() const { return m_margins.m_bottom; }
1114
1115     /**
1116         Returns the position.
1117     */
1118     wxTextAttrDimensions& GetPosition() { return m_position; }
1119     const wxTextAttrDimensions& GetPosition() const { return m_position; }
1120
1121     /**
1122         Returns the left position.
1123     */
1124     wxTextAttrDimension& GetLeft() { return m_position.m_left; }
1125     const wxTextAttrDimension& GetLeft() const { return m_position.m_left; }
1126
1127     /**
1128         Returns the right position.
1129     */
1130     wxTextAttrDimension& GetRight() { return m_position.m_right; }
1131     const wxTextAttrDimension& GetRight() const { return m_position.m_right; }
1132
1133     /**
1134         Returns the top position.
1135     */
1136     wxTextAttrDimension& GetTop() { return m_position.m_top; }
1137     const wxTextAttrDimension& GetTop() const { return m_position.m_top; }
1138
1139     /**
1140         Returns the bottom position.
1141     */
1142     wxTextAttrDimension& GetBottom() { return m_position.m_bottom; }
1143     const wxTextAttrDimension& GetBottom() const { return m_position.m_bottom; }
1144
1145     /**
1146         Returns the padding values.
1147     */
1148     wxTextAttrDimensions& GetPadding() { return m_padding; }
1149     const wxTextAttrDimensions& GetPadding() const { return m_padding; }
1150
1151     /**
1152         Returns the left padding value.
1153     */
1154     wxTextAttrDimension& GetLeftPadding() { return m_padding.m_left; }
1155     const wxTextAttrDimension& GetLeftPadding() const { return m_padding.m_left; }
1156
1157     /**
1158         Returns the right padding value.
1159     */
1160     wxTextAttrDimension& GetRightPadding() { return m_padding.m_right; }
1161     const wxTextAttrDimension& GetRightPadding() const { return m_padding.m_right; }
1162
1163     /**
1164         Returns the top padding value.
1165     */
1166     wxTextAttrDimension& GetTopPadding() { return m_padding.m_top; }
1167     const wxTextAttrDimension& GetTopPadding() const { return m_padding.m_top; }
1168
1169     /**
1170         Returns the bottom padding value.
1171     */
1172     wxTextAttrDimension& GetBottomPadding() { return m_padding.m_bottom; }
1173     const wxTextAttrDimension& GetBottomPadding() const { return m_padding.m_bottom; }
1174
1175     /**
1176         Returns the borders.
1177     */
1178     wxTextAttrBorders& GetBorder() { return m_border; }
1179     const wxTextAttrBorders& GetBorder() const { return m_border; }
1180
1181     /**
1182         Returns the left border.
1183     */
1184     wxTextAttrBorder& GetLeftBorder() { return m_border.m_left; }
1185     const wxTextAttrBorder& GetLeftBorder() const { return m_border.m_left; }
1186
1187     /**
1188         Returns the top border.
1189     */
1190     wxTextAttrBorder& GetTopBorder() { return m_border.m_top; }
1191     const wxTextAttrBorder& GetTopBorder() const { return m_border.m_top; }
1192
1193     /**
1194         Returns the right border.
1195     */
1196     wxTextAttrBorder& GetRightBorder() { return m_border.m_right; }
1197     const wxTextAttrBorder& GetRightBorder() const { return m_border.m_right; }
1198
1199     /**
1200         Returns the bottom border.
1201     */
1202     wxTextAttrBorder& GetBottomBorder() { return m_border.m_bottom; }
1203     const wxTextAttrBorder& GetBottomBorder() const { return m_border.m_bottom; }
1204
1205     /**
1206         Returns the outline.
1207     */
1208     wxTextAttrBorders& GetOutline() { return m_outline; }
1209     const wxTextAttrBorders& GetOutline() const { return m_outline; }
1210
1211     /**
1212         Returns the left outline.
1213     */
1214     wxTextAttrBorder& GetLeftOutline() { return m_outline.m_left; }
1215     const wxTextAttrBorder& GetLeftOutline() const { return m_outline.m_left; }
1216
1217     /**
1218         Returns the top outline.
1219     */
1220     wxTextAttrBorder& GetTopOutline() { return m_outline.m_top; }
1221     const wxTextAttrBorder& GetTopOutline() const { return m_outline.m_top; }
1222
1223     /**
1224         Returns the right outline.
1225     */
1226     wxTextAttrBorder& GetRightOutline() { return m_outline.m_right; }
1227     const wxTextAttrBorder& GetRightOutline() const { return m_outline.m_right; }
1228
1229     /**
1230         Returns the bottom outline.
1231     */
1232     wxTextAttrBorder& GetBottomOutline() { return m_outline.m_bottom; }
1233     const wxTextAttrBorder& GetBottomOutline() const { return m_outline.m_bottom; }
1234
1235     /**
1236         Returns the object size.
1237     */
1238     wxTextAttrSize& GetSize() { return m_size; }
1239     const wxTextAttrSize& GetSize() const { return m_size; }
1240
1241     /**
1242         Returns the object minimum size.
1243     */
1244
1245     wxTextAttrSize& GetMinSize() { return m_minSize; }
1246     const wxTextAttrSize& GetMinSize() const { return m_minSize; }
1247
1248     /**
1249         Returns the object maximum size.
1250     */
1251
1252     wxTextAttrSize& GetMaxSize() { return m_maxSize; }
1253     const wxTextAttrSize& GetMaxSize() const { return m_maxSize; }
1254
1255     /**
1256         Sets the object size.
1257     */
1258     void SetSize(const wxTextAttrSize& sz) { m_size = sz; }
1259
1260     /**
1261         Sets the object minimum size.
1262     */
1263     void SetMinSize(const wxTextAttrSize& sz) { m_minSize = sz; }
1264
1265     /**
1266         Sets the object maximum size.
1267     */
1268     void SetMaxSize(const wxTextAttrSize& sz) { m_maxSize = sz; }
1269
1270     /**
1271         Returns the object width.
1272     */
1273     wxTextAttrDimension& GetWidth() { return m_size.m_width; }
1274     const wxTextAttrDimension& GetWidth() const { return m_size.m_width; }
1275
1276     /**
1277         Returns the object height.
1278     */
1279     wxTextAttrDimension& GetHeight() { return m_size.m_height; }
1280     const wxTextAttrDimension& GetHeight() const { return m_size.m_height; }
1281
1282     /**
1283         Returns the box style name.
1284     */
1285     const wxString& GetBoxStyleName() const { return m_boxStyleName; }
1286
1287     /**
1288         Sets the box style name.
1289     */
1290     void SetBoxStyleName(const wxString& name) { m_boxStyleName = name; AddFlag(wxTEXT_BOX_ATTR_BOX_STYLE_NAME); }
1291
1292     /**
1293         Returns @true if the box style name is present.
1294     */
1295     bool HasBoxStyleName() const { return HasFlag(wxTEXT_BOX_ATTR_BOX_STYLE_NAME); }
1296
1297 public:
1298
1299     int                             m_flags;
1300
1301     wxTextAttrDimensions            m_margins;
1302     wxTextAttrDimensions            m_padding;
1303     wxTextAttrDimensions            m_position;
1304
1305     wxTextAttrSize                  m_size;
1306     wxTextAttrSize                  m_minSize;
1307     wxTextAttrSize                  m_maxSize;
1308
1309     wxTextAttrBorders               m_border;
1310     wxTextAttrBorders               m_outline;
1311
1312     wxTextBoxAttrFloatStyle         m_floatMode;
1313     wxTextBoxAttrClearStyle         m_clearMode;
1314     wxTextBoxAttrCollapseMode       m_collapseMode;
1315     wxTextBoxAttrVerticalAlignment  m_verticalAlignment;
1316     wxString                        m_boxStyleName;
1317 };
1318
1319 /**
1320     @class wxRichTextAttr
1321     A class representing enhanced attributes for rich text objects.
1322     This adds a wxTextBoxAttr member to the basic wxTextAttr class.
1323
1324     @library{wxrichtext}
1325     @category{richtext}
1326
1327     @see wxRichTextAttr, wxTextBoxAttr, wxRichTextCtrl
1328 */
1329
1330 class WXDLLIMPEXP_RICHTEXT wxRichTextAttr: public wxTextAttr
1331 {
1332 public:
1333     /**
1334         Constructor taking a wxTextAttr.
1335     */
1336     wxRichTextAttr(const wxTextAttr& attr) { wxTextAttr::Copy(attr); }
1337
1338     /**
1339         Copy constructor.
1340     */
1341     wxRichTextAttr(const wxRichTextAttr& attr): wxTextAttr() { Copy(attr); }
1342
1343     /**
1344         Default constructor.
1345     */
1346     wxRichTextAttr() {}
1347
1348     /**
1349         Copy function.
1350     */
1351     void Copy(const wxRichTextAttr& attr);
1352
1353     /**
1354         Assignment operator.
1355     */
1356     void operator=(const wxRichTextAttr& attr) { Copy(attr); }
1357
1358     /**
1359         Assignment operator.
1360     */
1361     void operator=(const wxTextAttr& attr) { wxTextAttr::Copy(attr); }
1362
1363     /**
1364         Equality test.
1365     */
1366     bool operator==(const wxRichTextAttr& attr) const;
1367
1368     /**
1369         Partial equality test taking comparison object into account.
1370     */
1371     bool EqPartial(const wxRichTextAttr& attr) const;
1372
1373     /**
1374         Merges the given attributes. If @a compareWith
1375         is non-NULL, then it will be used to mask out those attributes that are the same in style
1376         and @a compareWith, for situations where we don't want to explicitly set inherited attributes.
1377     */
1378     bool Apply(const wxRichTextAttr& style, const wxRichTextAttr* compareWith = NULL);
1379
1380     /**
1381         Collects the attributes that are common to a range of content, building up a note of
1382         which attributes are absent in some objects and which clash in some objects.
1383     */
1384     void CollectCommonAttributes(const wxRichTextAttr& attr, wxRichTextAttr& clashingAttr, wxRichTextAttr& absentAttr);
1385
1386     /**
1387         Removes the specified attributes from this object.
1388     */
1389     bool RemoveStyle(const wxRichTextAttr& attr);
1390
1391     /**
1392         Returns the text box attributes.
1393     */
1394     wxTextBoxAttr& GetTextBoxAttr() { return m_textBoxAttr; }
1395     const wxTextBoxAttr& GetTextBoxAttr() const { return m_textBoxAttr; }
1396
1397     /**
1398         Set the text box attributes.
1399     */
1400     void SetTextBoxAttr(const wxTextBoxAttr& attr) { m_textBoxAttr = attr; }
1401
1402     wxTextBoxAttr    m_textBoxAttr;
1403 };
1404
1405 WX_DECLARE_USER_EXPORTED_OBJARRAY(wxVariant, wxRichTextVariantArray, WXDLLIMPEXP_RICHTEXT);
1406
1407 /**
1408     @class wxRichTextProperties
1409     A simple property class using wxVariants. This is used to give each rich text object the
1410     ability to store custom properties that can be used by the application.
1411
1412     @library{wxrichtext}
1413     @category{richtext}
1414
1415     @see wxRichTextBuffer, wxRichTextObject, wxRichTextCtrl
1416 */
1417
1418 class WXDLLIMPEXP_RICHTEXT wxRichTextProperties: public wxObject
1419 {
1420 DECLARE_DYNAMIC_CLASS(wxRichTextProperties)
1421 public:
1422
1423     /**
1424         Default constructor.
1425     */
1426     wxRichTextProperties() {}
1427
1428     /**
1429         Copy constructor.
1430     */
1431     wxRichTextProperties(const wxRichTextProperties& props): wxObject() { Copy(props); }
1432
1433     /**
1434         Assignment operator.
1435     */
1436     void operator=(const wxRichTextProperties& props) { Copy(props); }
1437
1438     /**
1439         Equality operator.
1440     */
1441     bool operator==(const wxRichTextProperties& props) const;
1442
1443     /**
1444         Copies from @a props.
1445     */
1446     void Copy(const wxRichTextProperties& props) { m_properties = props.m_properties; }
1447
1448     /**
1449         Returns the variant at the given index.
1450     */
1451     const wxVariant& operator[](size_t idx) const { return m_properties[idx]; }
1452
1453     /**
1454         Returns the variant at the given index.
1455     */
1456     wxVariant& operator[](size_t idx) { return m_properties[idx]; }
1457
1458     /**
1459         Clears the properties.
1460     */
1461     void Clear() { m_properties.Clear(); }
1462
1463     /**
1464         Returns the array of variants implementing the properties.
1465     */
1466     const wxRichTextVariantArray& GetProperties() const { return m_properties; }
1467
1468     /**
1469         Returns the array of variants implementing the properties.
1470     */
1471     wxRichTextVariantArray& GetProperties() { return m_properties; }
1472
1473     /**
1474         Sets the array of variants.
1475     */
1476     void SetProperties(const wxRichTextVariantArray& props) { m_properties = props; }
1477
1478     /**
1479         Returns all the property names.
1480     */
1481     wxArrayString GetPropertyNames() const;
1482
1483     /**
1484         Returns a count of the properties.
1485     */
1486     size_t GetCount() const { return m_properties.GetCount(); }
1487
1488     /**
1489         Returns @true if the given property is found.
1490     */
1491     bool HasProperty(const wxString& name) const { return Find(name) != -1; }
1492
1493     /**
1494         Finds the given property.
1495     */
1496     int Find(const wxString& name) const;
1497
1498     /**
1499         Removes the given property.
1500     */
1501     bool Remove(const wxString& name);
1502
1503     /**
1504         Gets the property variant by name.
1505     */
1506     const wxVariant& GetProperty(const wxString& name) const;
1507
1508     /**
1509         Finds or creates a property with the given name, returning a pointer to the variant.
1510     */
1511     wxVariant* FindOrCreateProperty(const wxString& name);
1512
1513     /**
1514         Gets the value of the named property as a string.
1515     */
1516     wxString GetPropertyString(const wxString& name) const;
1517
1518     /**
1519         Gets the value of the named property as a long integer.
1520     */
1521     long GetPropertyLong(const wxString& name) const;
1522
1523     /**
1524         Gets the value of the named property as a boolean.
1525     */
1526     bool GetPropertyBool(const wxString& name) const;
1527
1528     /**
1529         Gets the value of the named property as a double.
1530     */
1531     double GetPropertyDouble(const wxString& name) const;
1532
1533     /**
1534         Sets the property by passing a variant which contains a name and value.
1535     */
1536     void SetProperty(const wxVariant& variant);
1537
1538     /**
1539         Sets a property by name and variant.
1540     */
1541     void SetProperty(const wxString& name, const wxVariant& variant);
1542
1543     /**
1544         Sets a property by name and string value.
1545     */
1546     void SetProperty(const wxString& name, const wxString& value);
1547
1548     /**
1549         Sets  property by name and long integer value.
1550     */
1551     void SetProperty(const wxString& name, long value);
1552
1553     /**
1554         Sets  property by name and double value.
1555     */
1556     void SetProperty(const wxString& name, double value);
1557
1558     /**
1559         Sets  property by name and boolean value.
1560     */
1561     void SetProperty(const wxString& name, bool value);
1562
1563     /**
1564         Removes the given properties from these properties.
1565     */
1566     void RemoveProperties(const wxRichTextProperties& properties);
1567
1568     /**
1569         Merges the given properties with these properties.
1570     */
1571     void MergeProperties(const wxRichTextProperties& properties);
1572
1573 protected:
1574     wxRichTextVariantArray  m_properties;
1575 };
1576
1577
1578 /**
1579     @class wxRichTextFontTable
1580     Manages quick access to a pool of fonts for rendering rich text.
1581
1582     @library{wxrichtext}
1583     @category{richtext}
1584
1585     @see wxRichTextBuffer, wxRichTextCtrl
1586 */
1587
1588 class WXDLLIMPEXP_RICHTEXT wxRichTextFontTable: public wxObject
1589 {
1590 public:
1591     /**
1592         Default constructor.
1593     */
1594     wxRichTextFontTable();
1595
1596     /**
1597         Copy constructor.
1598     */
1599     wxRichTextFontTable(const wxRichTextFontTable& table);
1600     virtual ~wxRichTextFontTable();
1601
1602     /**
1603         Returns @true if the font table is valid.
1604     */
1605     bool IsOk() const { return m_refData != NULL; }
1606
1607     /**
1608         Finds a font for the given attribute object.
1609     */
1610     wxFont FindFont(const wxRichTextAttr& fontSpec);
1611
1612     /**
1613         Clears the font table.
1614     */
1615     void Clear();
1616
1617     /**
1618         Assignment operator.
1619     */
1620     void operator= (const wxRichTextFontTable& table);
1621
1622     /**
1623         Equality operator.
1624     */
1625     bool operator == (const wxRichTextFontTable& table) const;
1626
1627     /**
1628         Inequality operator.
1629     */
1630     bool operator != (const wxRichTextFontTable& table) const { return !(*this == table); }
1631
1632 protected:
1633
1634     DECLARE_DYNAMIC_CLASS(wxRichTextFontTable)
1635 };
1636
1637 /**
1638     @class wxRichTextRange
1639
1640     This stores beginning and end positions for a range of data.
1641
1642     @library{wxrichtext}
1643     @category{richtext}
1644
1645     @see wxRichTextBuffer, wxRichTextCtrl
1646 */
1647
1648 class WXDLLIMPEXP_RICHTEXT wxRichTextRange
1649 {
1650 public:
1651 // Constructors
1652
1653     /**
1654         Default constructor.
1655     */
1656     wxRichTextRange() { m_start = 0; m_end = 0; }
1657
1658     /**
1659         Constructor taking start and end positions.
1660     */
1661     wxRichTextRange(long start, long end) { m_start = start; m_end = end; }
1662
1663     /**
1664         Copy constructor.
1665     */
1666     wxRichTextRange(const wxRichTextRange& range) { m_start = range.m_start; m_end = range.m_end; }
1667     ~wxRichTextRange() {}
1668
1669     /**
1670         Assigns @a range to this range.
1671     */
1672     void operator =(const wxRichTextRange& range) { m_start = range.m_start; m_end = range.m_end; }
1673
1674     /**
1675         Equality operator. Returns @true if @a range is the same as this range.
1676     */
1677     bool operator ==(const wxRichTextRange& range) const { return (m_start == range.m_start && m_end == range.m_end); }
1678
1679     /**
1680         Inequality operator.
1681     */
1682     bool operator !=(const wxRichTextRange& range) const { return (m_start != range.m_start || m_end != range.m_end); }
1683
1684     /**
1685         Subtracts a range from this range.
1686     */
1687     wxRichTextRange operator -(const wxRichTextRange& range) const { return wxRichTextRange(m_start - range.m_start, m_end - range.m_end); }
1688
1689     /**
1690         Adds a range to this range.
1691     */
1692     wxRichTextRange operator +(const wxRichTextRange& range) const { return wxRichTextRange(m_start + range.m_start, m_end + range.m_end); }
1693
1694     /**
1695         Sets the range start and end positions.
1696     */
1697     void SetRange(long start, long end) { m_start = start; m_end = end; }
1698
1699     /**
1700         Sets the start position.
1701     */
1702     void SetStart(long start) { m_start = start; }
1703
1704     /**
1705         Returns the start position.
1706     */
1707     long GetStart() const { return m_start; }
1708
1709     /**
1710         Sets the end position.
1711     */
1712     void SetEnd(long end) { m_end = end; }
1713
1714     /**
1715         Gets the end position.
1716     */
1717     long GetEnd() const { return m_end; }
1718
1719     /**
1720         Returns true if this range is completely outside @a range.
1721     */
1722     bool IsOutside(const wxRichTextRange& range) const { return range.m_start > m_end || range.m_end < m_start; }
1723
1724     /**
1725         Returns true if this range is completely within @a range.
1726     */
1727     bool IsWithin(const wxRichTextRange& range) const { return m_start >= range.m_start && m_end <= range.m_end; }
1728
1729     /**
1730         Returns true if @a pos was within the range. Does not match if the range is empty.
1731     */
1732     bool Contains(long pos) const { return pos >= m_start && pos <= m_end ; }
1733
1734     /**
1735         Limit this range to be within @a range.
1736     */
1737     bool LimitTo(const wxRichTextRange& range) ;
1738
1739     /**
1740         Gets the length of the range.
1741     */
1742     long GetLength() const { return m_end - m_start + 1; }
1743
1744     /**
1745         Swaps the start and end.
1746     */
1747     void Swap() { long tmp = m_start; m_start = m_end; m_end = tmp; }
1748
1749     /**
1750         Converts the API-standard range, whose end is one past the last character in
1751         the range, to the internal form, which uses the first and last character
1752         positions of the range. In other words, one is subtracted from the end position.
1753         (n, n) is the range of a single character.
1754     */
1755     wxRichTextRange ToInternal() const { return wxRichTextRange(m_start, m_end-1); }
1756
1757     /**
1758         Converts the internal range, which uses the first and last character positions
1759         of the range, to the API-standard range, whose end is one past the last
1760         character in the range. In other words, one is added to the end position.
1761         (n, n+1) is the range of a single character.
1762     */
1763     wxRichTextRange FromInternal() const { return wxRichTextRange(m_start, m_end+1); }
1764
1765 protected:
1766     long m_start;
1767     long m_end;
1768 };
1769
1770 WX_DECLARE_USER_EXPORTED_OBJARRAY(wxRichTextRange, wxRichTextRangeArray, WXDLLIMPEXP_RICHTEXT);
1771
1772 #define wxRICHTEXT_ALL  wxRichTextRange(-2, -2)
1773 #define wxRICHTEXT_NONE  wxRichTextRange(-1, -1)
1774
1775 #define wxRICHTEXT_NO_SELECTION wxRichTextRange(-2, -2)
1776
1777 /**
1778     @class wxRichTextSelection
1779
1780     Stores selection information. The selection does not have to be contiguous, though currently non-contiguous
1781     selections are only supported for a range of table cells (a geometric block of cells can consist
1782     of a set of non-contiguous positions).
1783
1784     The selection consists of an array of ranges, and the container that is the context for the selection. It
1785     follows that a single selection object can only represent ranges with the same parent container.
1786
1787     @library{wxrichtext}
1788     @category{richtext}
1789
1790     @see wxRichTextBuffer, wxRichTextCtrl
1791 */
1792
1793 class WXDLLIMPEXP_RICHTEXT wxRichTextSelection
1794 {
1795 public:
1796     /**
1797         Copy constructor.
1798     */
1799     wxRichTextSelection(const wxRichTextSelection& sel) { Copy(sel); }
1800
1801     /**
1802         Creates a selection from a range and a container.
1803     */
1804     wxRichTextSelection(const wxRichTextRange& range, wxRichTextParagraphLayoutBox* container) { m_ranges.Add(range); m_container = container; }
1805
1806     /**
1807         Default constructor.
1808     */
1809     wxRichTextSelection() { Reset(); }
1810
1811     /**
1812         Resets the selection.
1813     */
1814     void Reset() { m_ranges.Clear(); m_container = NULL; }
1815
1816     /**
1817         Sets the selection.
1818     */
1819
1820     void Set(const wxRichTextRange& range, wxRichTextParagraphLayoutBox* container)
1821     { m_ranges.Clear(); m_ranges.Add(range); m_container = container; }
1822
1823     /**
1824         Adds a range to the selection.
1825     */
1826     void Add(const wxRichTextRange& range)
1827     { m_ranges.Add(range); }
1828
1829     /**
1830         Sets the selections from an array of ranges and a container object.
1831     */
1832     void Set(const wxRichTextRangeArray& ranges, wxRichTextParagraphLayoutBox* container)
1833     { m_ranges = ranges; m_container = container; }
1834
1835     /**
1836         Copies from @a sel.
1837     */
1838     void Copy(const wxRichTextSelection& sel)
1839     { m_ranges = sel.m_ranges; m_container = sel.m_container; }
1840
1841     /**
1842         Assignment operator.
1843     */
1844     void operator=(const wxRichTextSelection& sel) { Copy(sel); }
1845
1846     /**
1847         Equality operator.
1848     */
1849     bool operator==(const wxRichTextSelection& sel) const;
1850
1851     /**
1852         Index operator.
1853     */
1854     wxRichTextRange operator[](size_t i) const { return GetRange(i); }
1855
1856     /**
1857         Returns the selection ranges.
1858     */
1859     wxRichTextRangeArray& GetRanges() { return m_ranges; }
1860
1861     /**
1862         Returns the selection ranges.
1863     */
1864     const wxRichTextRangeArray& GetRanges() const { return m_ranges; }
1865
1866     /**
1867         Sets the selection ranges.
1868     */
1869     void SetRanges(const wxRichTextRangeArray& ranges) { m_ranges = ranges; }
1870
1871     /**
1872         Returns the number of ranges in the selection.
1873     */
1874     size_t GetCount() const { return m_ranges.GetCount(); }
1875
1876     /**
1877         Returns the range at the given index.
1878
1879     */
1880     wxRichTextRange GetRange(size_t i) const { return m_ranges[i]; }
1881
1882     /**
1883         Returns the first range if there is one, otherwise wxRICHTEXT_NO_SELECTION.
1884     */
1885     wxRichTextRange GetRange() const { return (m_ranges.GetCount() > 0) ? (m_ranges[0]) : wxRICHTEXT_NO_SELECTION; }
1886
1887     /**
1888         Sets a single range.
1889     */
1890     void SetRange(const wxRichTextRange& range) { m_ranges.Clear(); m_ranges.Add(range); }
1891
1892     /**
1893         Returns the container for which the selection is valid.
1894     */
1895     wxRichTextParagraphLayoutBox* GetContainer() const { return m_container; }
1896
1897     /**
1898         Sets the container for which the selection is valid.
1899     */
1900     void SetContainer(wxRichTextParagraphLayoutBox* container) { m_container = container; }
1901
1902     /**
1903         Returns @true if the selection is valid.
1904     */
1905     bool IsValid() const { return m_ranges.GetCount() > 0 && GetContainer(); }
1906
1907     /**
1908         Returns the selection appropriate to the specified object, if any; returns an empty array if none
1909         at the level of the object's container.
1910     */
1911     wxRichTextRangeArray GetSelectionForObject(wxRichTextObject* obj) const;
1912
1913     /**
1914         Returns @true if the given position is within the selection.
1915     */
1916     bool WithinSelection(long pos, wxRichTextObject* obj) const;
1917
1918     /**
1919         Returns @true if the given position is within the selection.
1920
1921     */
1922     bool WithinSelection(long pos) const { return WithinSelection(pos, m_ranges); }
1923
1924     /**
1925         Returns @true if the given position is within the selection range.
1926     */
1927     static bool WithinSelection(long pos, const wxRichTextRangeArray& ranges);
1928
1929     /**
1930         Returns @true if the given range is within the selection range.
1931     */
1932     static bool WithinSelection(const wxRichTextRange& range, const wxRichTextRangeArray& ranges);
1933
1934     wxRichTextRangeArray            m_ranges;
1935     wxRichTextParagraphLayoutBox*   m_container;
1936 };
1937
1938 /**
1939     @class wxRichTextObject
1940
1941     This is the base for drawable rich text objects.
1942
1943     @library{wxrichtext}
1944     @category{richtext}
1945
1946     @see wxRichTextBuffer, wxRichTextCtrl
1947 */
1948
1949 class WXDLLIMPEXP_RICHTEXT wxRichTextObject: public wxObject
1950 {
1951     DECLARE_CLASS(wxRichTextObject)
1952 public:
1953     /**
1954         Constructor, taking an optional parent pointer.
1955     */
1956     wxRichTextObject(wxRichTextObject* parent = NULL);
1957
1958     virtual ~wxRichTextObject();
1959
1960 // Overridables
1961
1962     /**
1963         Draw the item, within the given range. Some objects may ignore the range (for
1964         example paragraphs) while others must obey it (lines, to implement wrapping)
1965     */
1966     virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style) = 0;
1967
1968     /**
1969         Lay the item out at the specified position with the given size constraint.
1970         Layout must set the cached size. @rect is the available space for the object,
1971         and @a parentRect is the container that is used to determine a relative size
1972         or position (for example if a text box must be 50% of the parent text box).
1973     */
1974     virtual bool Layout(wxDC& dc, const wxRect& rect, const wxRect& parentRect, int style) = 0;
1975
1976     /**
1977         Hit-testing: returns a flag indicating hit test details, plus
1978         information about position. @a contextObj is returned to specify what object
1979         position is relevant to, since otherwise there's an ambiguity.
1980         @ obj might not be a child of @a contextObj, since we may be referring to the container itself
1981         if we have no hit on a child - for example if we click outside an object.
1982
1983         The function puts the position in @a textPosition if one is found.
1984         @a pt is in logical units (a zero y position is at the beginning of the buffer).
1985
1986         @return One of the ::wxRichTextHitTestFlags values.
1987     */
1988
1989     virtual int HitTest(wxDC& dc, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags = 0);
1990
1991     /**
1992         Finds the absolute position and row height for the given character position.
1993     */
1994     virtual bool FindPosition(wxDC& WXUNUSED(dc), long WXUNUSED(index), wxPoint& WXUNUSED(pt), int* WXUNUSED(height), bool WXUNUSED(forceLineStart)) { return false; }
1995
1996     /**
1997         Returns the best size, i.e. the ideal starting size for this object irrespective
1998         of available space. For a short text string, it will be the size that exactly encloses
1999         the text. For a longer string, it might use the parent width for example.
2000     */
2001     virtual wxSize GetBestSize() const { return m_size; }
2002
2003     /**
2004         Returns the object size for the given range. Returns @false if the range
2005         is invalid for this object.
2006     */
2007
2008     virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const  = 0;
2009
2010     /**
2011         Do a split from @a pos, returning an object containing the second part, and setting
2012         the first part in 'this'.
2013     */
2014     virtual wxRichTextObject* DoSplit(long WXUNUSED(pos)) { return NULL; }
2015
2016     /**
2017         Calculates the range of the object. By default, guess that the object is 1 unit long.
2018     */
2019     virtual void CalculateRange(long start, long& end) { end = start ; m_range.SetRange(start, end); }
2020
2021     /**
2022         Deletes the given range.
2023     */
2024     virtual bool DeleteRange(const wxRichTextRange& WXUNUSED(range)) { return false; }
2025
2026     /**
2027         Returns @true if the object is empty.
2028     */
2029     virtual bool IsEmpty() const { return false; }
2030
2031     /**
2032         Returns @true if this class of object is floatable.
2033     */
2034     virtual bool IsFloatable() const { return false; }
2035
2036     /**
2037         Returns @true if this object is currently floating.
2038     */
2039     virtual bool IsFloating() const { return GetAttributes().GetTextBoxAttr().IsFloating(); }
2040
2041     /**
2042         Returns the floating direction.
2043     */
2044     virtual int GetFloatDirection() const { return GetAttributes().GetTextBoxAttr().GetFloatMode(); }
2045
2046     /**
2047         Returns any text in this object for the given range.
2048     */
2049     virtual wxString GetTextForRange(const wxRichTextRange& WXUNUSED(range)) const { return wxEmptyString; }
2050
2051     /**
2052         Returns @true if this object can merge itself with the given one.
2053     */
2054     virtual bool CanMerge(wxRichTextObject* WXUNUSED(object)) const { return false; }
2055
2056     /**
2057         Returns @true if this object merged itself with the given one.
2058         The calling code will then delete the given object.
2059     */
2060     virtual bool Merge(wxRichTextObject* WXUNUSED(object)) { return false; }
2061
2062     /**
2063         Dump object data to the given output stream for debugging.
2064     */
2065     virtual void Dump(wxTextOutputStream& stream);
2066
2067     /**
2068         Returns @true if we can edit the object's properties via a GUI.
2069     */
2070     virtual bool CanEditProperties() const { return false; }
2071
2072     /**
2073         Edits the object's properties via a GUI.
2074     */
2075     virtual bool EditProperties(wxWindow* WXUNUSED(parent), wxRichTextBuffer* WXUNUSED(buffer)) { return false; }
2076
2077     /**
2078         Returns the label to be used for the properties context menu item.
2079     */
2080     virtual wxString GetPropertiesMenuLabel() const { return wxEmptyString; }
2081
2082     /**
2083         Returns @true if objects of this class can accept the focus, i.e. a call to SetFocusObject
2084         is possible. For example, containers supporting text, such as a text box object, can accept the focus,
2085         but a table can't (set the focus to individual cells instead).
2086     */
2087     virtual bool AcceptsFocus() const { return false; }
2088
2089 #if wxUSE_XML
2090     /**
2091         Imports this object from XML.
2092     */
2093     virtual bool ImportFromXML(wxRichTextBuffer* buffer, wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse);
2094 #endif
2095
2096 #if wxRICHTEXT_HAVE_DIRECT_OUTPUT
2097     /**
2098         Exports this object directly to the given stream, bypassing the creation of a wxXmlNode hierarchy.
2099         This method is considerably faster than creating a tree first. However, both versions of ExportXML must be
2100         implemented so that if the tree method is made efficient in the future, we can deprecate the
2101         more verbose direct output method. Compiled only if wxRICHTEXT_HAVE_DIRECT_OUTPUT is defined (on by default).
2102     */
2103     virtual bool ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler);
2104 #endif
2105
2106 #if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
2107     /**
2108         Exports this object to the given parent node, usually creating at least one child node.
2109         This method is less efficient than the direct-to-stream method but is retained to allow for
2110         switching to this method if we make it more efficient. Compiled only if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT is defined
2111         (on by default).
2112     */
2113     virtual bool ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler);
2114 #endif
2115
2116     /**
2117         Returns @true if this object takes note of paragraph attributes (text and image objects don't).
2118     */
2119     virtual bool UsesParagraphAttributes() const { return true; }
2120
2121     /**
2122         Returns the XML node name of this object. This must be overridden for wxXmlNode-base XML export to work.
2123     */
2124     virtual wxString GetXMLNodeName() const { return wxT("unknown"); }
2125
2126     /**
2127         Invalidates the object at the given range. With no argument, invalidates the whole object.
2128     */
2129     virtual void Invalidate(const wxRichTextRange& invalidRange = wxRICHTEXT_ALL);
2130
2131     /**
2132         Returns @true if this object can handle the selections of its children, fOr example a table.
2133         Required for composite selection handling to work.
2134     */
2135     virtual bool HandlesChildSelections() const { return false; }
2136
2137     /**
2138         Returns a selection object specifying the selections between start and end character positions.
2139         For example, a table would deduce what cells (of range length 1) are selected when dragging across the table.
2140     */
2141     virtual wxRichTextSelection GetSelection(long WXUNUSED(start), long WXUNUSED(end)) const { return wxRichTextSelection(); }
2142
2143 // Accessors
2144
2145     /**
2146         Gets the cached object size as calculated by Layout.
2147     */
2148     virtual wxSize GetCachedSize() const { return m_size; }
2149
2150     /**
2151         Sets the cached object size as calculated by Layout.
2152     */
2153     virtual void SetCachedSize(const wxSize& sz) { m_size = sz; }
2154
2155     /**
2156         Gets the maximum object size as calculated by Layout. This allows
2157         us to fit an object to its contents or allocate extra space if required.
2158     */
2159     virtual wxSize GetMaxSize() const { return m_maxSize; }
2160
2161     /**
2162         Sets the maximum object size as calculated by Layout. This allows
2163         us to fit an object to its contents or allocate extra space if required.
2164     */
2165     virtual void SetMaxSize(const wxSize& sz) { m_maxSize = sz; }
2166
2167     /**
2168         Gets the minimum object size as calculated by Layout. This allows
2169         us to constrain an object to its absolute minimum size if necessary.
2170     */
2171     virtual wxSize GetMinSize() const { return m_minSize; }
2172
2173     /**
2174         Sets the minimum object size as calculated by Layout. This allows
2175         us to constrain an object to its absolute minimum size if necessary.
2176     */
2177     virtual void SetMinSize(const wxSize& sz) { m_minSize = sz; }
2178
2179     /**
2180         Gets the 'natural' size for an object. For an image, it would be the
2181         image size.
2182     */
2183     virtual wxTextAttrSize GetNaturalSize() const { return wxTextAttrSize(); }
2184
2185     /**
2186         Returns the object position in pixels.
2187     */
2188     virtual wxPoint GetPosition() const { return m_pos; }
2189
2190     /**
2191         Sets the object position in pixels.
2192     */
2193     virtual void SetPosition(const wxPoint& pos) { m_pos = pos; }
2194
2195     /**
2196         Returns the absolute object position, by traversing up the child/parent hierarchy.
2197         TODO: may not be needed, if all object positions are in fact relative to the
2198         top of the coordinate space.
2199     */
2200     virtual wxPoint GetAbsolutePosition() const;
2201
2202     /**
2203         Returns the rectangle enclosing the object.
2204     */
2205     virtual wxRect GetRect() const { return wxRect(GetPosition(), GetCachedSize()); }
2206
2207     /**
2208         Sets the object's range within its container.
2209     */
2210     void SetRange(const wxRichTextRange& range) { m_range = range; }
2211
2212     /**
2213         Returns the object's range.
2214     */
2215     const wxRichTextRange& GetRange() const { return m_range; }
2216
2217     /**
2218         Returns the object's range.
2219     */
2220     wxRichTextRange& GetRange() { return m_range; }
2221
2222     /**
2223         Set the object's own range, for a top-level object with its own position space.
2224     */
2225     void SetOwnRange(const wxRichTextRange& range) { m_ownRange = range; }
2226
2227     /**
2228         Returns the object's own range (valid if top-level).
2229     */
2230     const wxRichTextRange& GetOwnRange() const { return m_ownRange; }
2231
2232     /**
2233         Returns the object's own range (valid if top-level).
2234     */
2235     wxRichTextRange& GetOwnRange() { return m_ownRange; }
2236
2237     /**
2238         Returns the object's own range only if a top-level object.
2239     */
2240     wxRichTextRange GetOwnRangeIfTopLevel() const { return IsTopLevel() ? m_ownRange : m_range; }
2241
2242     /**
2243         Returns @true if this object this composite.
2244     */
2245     virtual bool IsComposite() const { return false; }
2246
2247     /**
2248         Returns a pointer to the parent object.
2249     */
2250     virtual wxRichTextObject* GetParent() const { return m_parent; }
2251
2252     /**
2253         Sets the pointer to the parent object.
2254     */
2255     virtual void SetParent(wxRichTextObject* parent) { m_parent = parent; }
2256
2257     /**
2258         Returns the top-level container of this object.
2259         May return itself if it's a container; use GetParentContainer to return
2260         a different container.
2261     */
2262     virtual wxRichTextParagraphLayoutBox* GetContainer() const;
2263
2264     /**
2265         Returns the top-level container of this object.
2266         Returns a different container than itself, unless there's no parent, in which case it will return NULL.
2267     */
2268     virtual wxRichTextParagraphLayoutBox* GetParentContainer() const { return GetParent() ? GetParent()->GetContainer() : GetContainer(); }
2269
2270     /**
2271         Set the margin around the object, in pixels.
2272     */
2273     virtual void SetMargins(int margin);
2274
2275     /**
2276         Set the margin around the object, in pixels.
2277     */
2278     virtual void SetMargins(int leftMargin, int rightMargin, int topMargin, int bottomMargin);
2279
2280     /**
2281         Returns the left margin of the object, in pixels.
2282     */
2283     virtual int GetLeftMargin() const;
2284
2285     /**
2286         Returns the right margin of the object, in pixels.
2287     */
2288     virtual int GetRightMargin() const;
2289
2290     /**
2291         Returns the top margin of the object, in pixels.
2292     */
2293     virtual int GetTopMargin() const;
2294
2295     /**
2296         Returns the bottom margin of the object, in pixels.
2297     */
2298     virtual int GetBottomMargin() const;
2299
2300     /**
2301         Calculates the available content space in the given rectangle, given the
2302         margins, border and padding specified in the object's attributes.
2303     */
2304     virtual wxRect GetAvailableContentArea(wxDC& dc, const wxRect& outerRect) const;
2305
2306     /**
2307         Lays out the object first with a given amount of space, and then if no width was specified in attr,
2308         lays out the object again using the minimum size. @a availableParentSpace is the maximum space
2309         for the object, whereas @a availableContainerSpace is the container with which relative positions and
2310         sizes should be computed. For example, a text box whose space has already been constrained
2311         in a previous layout pass to @a availableParentSpace, but should have a width of 50% of @a availableContainerSpace.
2312         (If these two rects were the same, a 2nd pass could see the object getting too small.)
2313     */
2314     virtual bool LayoutToBestSize(wxDC& dc, wxRichTextBuffer* buffer,
2315                     const wxRichTextAttr& parentAttr, const wxRichTextAttr& attr,
2316                     const wxRect& availableParentSpace, const wxRect& availableContainerSpace, int style);
2317
2318     /**
2319         Sets the object's attributes.
2320     */
2321     void SetAttributes(const wxRichTextAttr& attr) { m_attributes = attr; }
2322
2323     /**
2324         Returns the object's attributes.
2325     */
2326     const wxRichTextAttr& GetAttributes() const { return m_attributes; }
2327
2328     /**
2329         Returns the object's attributes.
2330     */
2331     wxRichTextAttr& GetAttributes() { return m_attributes; }
2332
2333     /**
2334         Sets the object's properties.
2335     */
2336     wxRichTextProperties& GetProperties() { return m_properties; }
2337
2338     /**
2339         Returns the object's properties.
2340     */
2341     const wxRichTextProperties& GetProperties() const { return m_properties; }
2342
2343     /**
2344         Returns the object's properties.
2345     */
2346     void SetProperties(const wxRichTextProperties& props) { m_properties = props; }
2347
2348     /**
2349         Sets the stored descent value.
2350     */
2351     void SetDescent(int descent) { m_descent = descent; }
2352
2353     /**
2354         Returns the stored descent value.
2355     */
2356     int GetDescent() const { return m_descent; }
2357
2358     /**
2359         Returns the containing buffer.
2360     */
2361     wxRichTextBuffer* GetBuffer() const;
2362
2363     /**
2364         Sets the identifying name for this object as a property using the "name" key.
2365     */
2366     void SetName(const wxString& name) { m_properties.SetProperty(wxT("name"), name); }
2367
2368     /**
2369         Returns the identifying name for this object from the properties, using the "name" key.
2370     */
2371     wxString GetName() const { return m_properties.GetPropertyString(wxT("name")); }
2372
2373     /**
2374         Returns @true if this object is top-level, i.e. contains its own paragraphs, such as a text box.
2375     */
2376     virtual bool IsTopLevel() const { return false; }
2377
2378     /**
2379         Returns @true if the object will be shown, @false otherwise.
2380     */
2381     bool IsShown() const { return m_show; }
2382
2383 // Operations
2384
2385     /**
2386         Call to show or hide this object. This function does not cause the content to be
2387         laid out or redrawn.
2388     */
2389     virtual void Show(bool show) { m_show = show; }
2390
2391     /**
2392         Clones the object.
2393     */
2394     virtual wxRichTextObject* Clone() const { return NULL; }
2395
2396     /**
2397         Copies the object.
2398     */
2399     void Copy(const wxRichTextObject& obj);
2400
2401     /**
2402         Reference-counting allows us to use the same object in multiple
2403         lists (not yet used).
2404     */
2405
2406     void Reference() { m_refCount ++; }
2407
2408     /**
2409         Reference-counting allows us to use the same object in multiple
2410         lists (not yet used).
2411     */
2412     void Dereference();
2413
2414     /**
2415         Moves the object recursively, by adding the offset from old to new.
2416     */
2417     virtual void Move(const wxPoint& pt);
2418
2419     /**
2420         Converts units in tenths of a millimetre to device units.
2421     */
2422     int ConvertTenthsMMToPixels(wxDC& dc, int units) const;
2423
2424     /**
2425         Converts units in tenths of a millimetre to device units.
2426     */
2427     static int ConvertTenthsMMToPixels(int ppi, int units, double scale = 1.0);
2428
2429     /**
2430         Convert units in pixels to tenths of a millimetre.
2431     */
2432     int ConvertPixelsToTenthsMM(wxDC& dc, int pixels) const;
2433
2434     /**
2435         Convert units in pixels to tenths of a millimetre.
2436     */
2437     static int ConvertPixelsToTenthsMM(int ppi, int pixels, double scale = 1.0);
2438
2439     /**
2440         Draws the borders and background for the given rectangle and attributes.
2441         @a boxRect is taken to be the outer margin box, not the box around the content.
2442     */
2443     static bool DrawBoxAttributes(wxDC& dc, wxRichTextBuffer* buffer, const wxRichTextAttr& attr, const wxRect& boxRect, int flags = 0);
2444
2445     /**
2446         Draws a border.
2447     */
2448     static bool DrawBorder(wxDC& dc, wxRichTextBuffer* buffer, const wxTextAttrBorders& attr, const wxRect& rect, int flags = 0);
2449
2450     /**
2451         Returns the various rectangles of the box model in pixels. You can either specify @a contentRect (inner)
2452         or @a marginRect (outer), and the other must be the default rectangle (no width or height).
2453         Note that the outline doesn't affect the position of the rectangle, it's drawn in whatever space
2454         is available.
2455     */
2456     static bool GetBoxRects(wxDC& dc, wxRichTextBuffer* buffer, const wxRichTextAttr& attr, wxRect& marginRect, wxRect& borderRect, wxRect& contentRect, wxRect& paddingRect, wxRect& outlineRect);
2457
2458     /**
2459         Returns the total margin for the object in pixels, taking into account margin, padding and border size.
2460     */
2461     static bool GetTotalMargin(wxDC& dc, wxRichTextBuffer* buffer, const wxRichTextAttr& attr, int& leftMargin, int& rightMargin,
2462         int& topMargin, int& bottomMargin);
2463
2464     /**
2465         Returns the rectangle which the child has available to it given restrictions specified in the
2466         child attribute, e.g. 50% width of the parent, 400 pixels, x position 20% of the parent, etc.
2467         availableContainerSpace might be a parent that the cell has to compute its width relative to.
2468         E.g. a cell that's 50% of its parent.
2469     */
2470     static wxRect AdjustAvailableSpace(wxDC& dc, wxRichTextBuffer* buffer, const wxRichTextAttr& parentAttr, const wxRichTextAttr& childAttr,
2471         const wxRect& availableParentSpace, const wxRect& availableContainerSpace);
2472
2473 protected:
2474     wxSize                  m_size;
2475     wxSize                  m_maxSize;
2476     wxSize                  m_minSize;
2477     wxPoint                 m_pos;
2478     int                     m_descent; // Descent for this object (if any)
2479     int                     m_refCount;
2480     bool                    m_show;
2481     wxRichTextObject*       m_parent;
2482
2483     // The range of this object (start position to end position)
2484     wxRichTextRange         m_range;
2485
2486     // The internal range of this object, if it's a top-level object with its own range space
2487     wxRichTextRange         m_ownRange;
2488
2489     // Attributes
2490     wxRichTextAttr          m_attributes;
2491
2492     // Properties
2493     wxRichTextProperties    m_properties;
2494 };
2495
2496 WX_DECLARE_LIST_WITH_DECL( wxRichTextObject, wxRichTextObjectList, class WXDLLIMPEXP_RICHTEXT );
2497
2498 /**
2499     @class wxRichTextCompositeObject
2500
2501     Objects of this class can contain other objects.
2502
2503     @library{wxrichtext}
2504     @category{richtext}
2505
2506     @see wxRichTextObject, wxRichTextBuffer, wxRichTextCtrl
2507 */
2508
2509 class WXDLLIMPEXP_RICHTEXT wxRichTextCompositeObject: public wxRichTextObject
2510 {
2511     DECLARE_CLASS(wxRichTextCompositeObject)
2512 public:
2513 // Constructors
2514
2515     wxRichTextCompositeObject(wxRichTextObject* parent = NULL);
2516     virtual ~wxRichTextCompositeObject();
2517
2518 // Overridables
2519
2520     virtual int HitTest(wxDC& dc, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags = 0);
2521
2522     virtual bool FindPosition(wxDC& dc, long index, wxPoint& pt, int* height, bool forceLineStart);
2523
2524     virtual void CalculateRange(long start, long& end);
2525
2526     virtual bool DeleteRange(const wxRichTextRange& range);
2527
2528     virtual wxString GetTextForRange(const wxRichTextRange& range) const;
2529
2530     virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
2531
2532     virtual void Dump(wxTextOutputStream& stream);
2533
2534     virtual void Invalidate(const wxRichTextRange& invalidRange = wxRICHTEXT_ALL);
2535
2536 // Accessors
2537
2538     /**
2539         Returns the children.
2540     */
2541     wxRichTextObjectList& GetChildren() { return m_children; }
2542     /**
2543         Returns the children.
2544     */
2545     const wxRichTextObjectList& GetChildren() const { return m_children; }
2546
2547     /**
2548         Returns the number of children.
2549     */
2550     size_t GetChildCount() const ;
2551
2552     /**
2553         Returns the nth child.
2554     */
2555     wxRichTextObject* GetChild(size_t n) const ;
2556
2557     /**
2558         Returns @true if this object is composite.
2559     */
2560     virtual bool IsComposite() const { return true; }
2561
2562     /**
2563         Returns true if the buffer is empty.
2564     */
2565     virtual bool IsEmpty() const { return GetChildCount() == 0; }
2566
2567     /**
2568         Returns the child object at the given character position.
2569     */
2570     virtual wxRichTextObject* GetChildAtPosition(long pos) const;
2571
2572 // Operations
2573
2574     void Copy(const wxRichTextCompositeObject& obj);
2575
2576     void operator= (const wxRichTextCompositeObject& obj) { Copy(obj); }
2577
2578     /**
2579         Appends a child, returning the position.
2580     */
2581     size_t AppendChild(wxRichTextObject* child) ;
2582
2583     /**
2584         Inserts the child in front of the given object, or at the beginning.
2585     */
2586     bool InsertChild(wxRichTextObject* child, wxRichTextObject* inFrontOf) ;
2587
2588     /**
2589         Removes and optionally deletes the specified child.
2590     */
2591     bool RemoveChild(wxRichTextObject* child, bool deleteChild = false) ;
2592
2593     /**
2594         Deletes all the children.
2595     */
2596     bool DeleteChildren() ;
2597
2598     /**
2599         Recursively merges all pieces that can be merged.
2600     */
2601     bool Defragment(const wxRichTextRange& range = wxRICHTEXT_ALL);
2602
2603     /**
2604         Moves the object recursively, by adding the offset from old to new.
2605     */
2606     virtual void Move(const wxPoint& pt);
2607
2608 protected:
2609     wxRichTextObjectList    m_children;
2610 };
2611
2612 /**
2613     @class wxRichTextParagraphBox
2614
2615     This class knows how to lay out paragraphs.
2616
2617     @library{wxrichtext}
2618     @category{richtext}
2619
2620     @see wxRichTextCompositeObject, wxRichTextObject, wxRichTextBuffer, wxRichTextCtrl
2621 */
2622
2623 class WXDLLIMPEXP_RICHTEXT wxRichTextParagraphLayoutBox: public wxRichTextCompositeObject
2624 {
2625     DECLARE_DYNAMIC_CLASS(wxRichTextParagraphLayoutBox)
2626 public:
2627 // Constructors
2628
2629     wxRichTextParagraphLayoutBox(wxRichTextObject* parent = NULL);
2630     wxRichTextParagraphLayoutBox(const wxRichTextParagraphLayoutBox& obj): wxRichTextCompositeObject() { Init(); Copy(obj); }
2631     ~wxRichTextParagraphLayoutBox();
2632
2633 // Overridables
2634
2635     virtual int HitTest(wxDC& dc, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags = 0);
2636
2637     virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
2638
2639     virtual bool Layout(wxDC& dc, const wxRect& rect, const wxRect& parentRect, int style);
2640
2641     virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
2642
2643     virtual bool DeleteRange(const wxRichTextRange& range);
2644
2645     virtual wxString GetTextForRange(const wxRichTextRange& range) const;
2646
2647 #if wxUSE_XML
2648     virtual bool ImportFromXML(wxRichTextBuffer* buffer, wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse);
2649 #endif
2650
2651 #if wxRICHTEXT_HAVE_DIRECT_OUTPUT
2652     virtual bool ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler);
2653 #endif
2654
2655 #if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
2656     virtual bool ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler);
2657 #endif
2658
2659     virtual wxString GetXMLNodeName() const { return wxT("paragraphlayout"); }
2660
2661     virtual bool AcceptsFocus() const { return true; }
2662
2663 // Accessors
2664
2665     /**
2666         Associates a control with the buffer, for operations that for example require refreshing the window.
2667     */
2668     void SetRichTextCtrl(wxRichTextCtrl* ctrl) { m_ctrl = ctrl; }
2669
2670     /**
2671         Returns the associated control.
2672     */
2673     wxRichTextCtrl* GetRichTextCtrl() const { return m_ctrl; }
2674
2675     /**
2676         Sets a flag indicating whether the last paragraph is partial or complete.
2677     */
2678     void SetPartialParagraph(bool partialPara) { m_partialParagraph = partialPara; }
2679
2680     /**
2681         Returns a flag indicating whether the last paragraph is partial or complete.
2682     */
2683     bool GetPartialParagraph() const { return m_partialParagraph; }
2684
2685     /**
2686         Returns the style sheet associated with the overall buffer.
2687     */
2688     virtual wxRichTextStyleSheet* GetStyleSheet() const;
2689
2690     virtual bool IsTopLevel() const { return true; }
2691
2692 // Operations
2693
2694     /**
2695         Submits a command to insert paragraphs.
2696     */
2697     bool InsertParagraphsWithUndo(wxRichTextBuffer* buffer, long pos, const wxRichTextParagraphLayoutBox& paragraphs, wxRichTextCtrl* ctrl, int flags = 0);
2698
2699     /**
2700         Submits a command to insert the given text.
2701     */
2702     bool InsertTextWithUndo(wxRichTextBuffer* buffer, long pos, const wxString& text, wxRichTextCtrl* ctrl, int flags = 0);
2703
2704     /**
2705         Submits a command to insert the given text.
2706     */
2707     bool InsertNewlineWithUndo(wxRichTextBuffer* buffer, long pos, wxRichTextCtrl* ctrl, int flags = 0);
2708
2709     /**
2710         Submits a command to insert the given image.
2711     */
2712     bool InsertImageWithUndo(wxRichTextBuffer* buffer, long pos, const wxRichTextImageBlock& imageBlock,
2713                                                         wxRichTextCtrl* ctrl, int flags,
2714                                                         const wxRichTextAttr& textAttr);
2715
2716     /**
2717         Returns the style that is appropriate for a new paragraph at this position.
2718         If the previous paragraph has a paragraph style name, looks up the next-paragraph
2719         style.
2720     */
2721     wxRichTextAttr GetStyleForNewParagraph(wxRichTextBuffer* buffer, long pos, bool caretPosition = false, bool lookUpNewParaStyle=false) const;
2722
2723     /**
2724         Inserts an object.
2725     */
2726     wxRichTextObject* InsertObjectWithUndo(wxRichTextBuffer* buffer, long pos, wxRichTextObject *object, wxRichTextCtrl* ctrl, int flags = 0);
2727
2728     /**
2729         Submits a command to delete this range.
2730     */
2731     bool DeleteRangeWithUndo(const wxRichTextRange& range, wxRichTextCtrl* ctrl, wxRichTextBuffer* buffer);
2732
2733     /**
2734         Draws the floating objects in this buffer.
2735     */
2736     void DrawFloats(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
2737
2738     /**
2739         Moves an anchored object to another paragraph.
2740     */
2741     void MoveAnchoredObjectToParagraph(wxRichTextParagraph* from, wxRichTextParagraph* to, wxRichTextObject* obj);
2742
2743     /**
2744         Initializes the object.
2745     */
2746     void Init();
2747
2748     /**
2749         Clears all the children.
2750     */
2751     virtual void Clear();
2752
2753     /**
2754         Clears and initializes with one blank paragraph.
2755     */
2756     virtual void Reset();
2757
2758     /**
2759         Convenience function to add a paragraph of text.
2760     */
2761     virtual wxRichTextRange AddParagraph(const wxString& text, wxRichTextAttr* paraStyle = NULL);
2762
2763     /**
2764         Convenience function to add an image.
2765     */
2766     virtual wxRichTextRange AddImage(const wxImage& image, wxRichTextAttr* paraStyle = NULL);
2767
2768     /**
2769         Adds multiple paragraphs, based on newlines.
2770     */
2771     virtual wxRichTextRange AddParagraphs(const wxString& text, wxRichTextAttr* paraStyle = NULL);
2772
2773     /**
2774         Returns the line at the given position. If @a caretPosition is true, the position is
2775         a caret position, which is normally a smaller number.
2776     */
2777     virtual wxRichTextLine* GetLineAtPosition(long pos, bool caretPosition = false) const;
2778
2779     /**
2780         Returns the line at the given y pixel position, or the last line.
2781     */
2782     virtual wxRichTextLine* GetLineAtYPosition(int y) const;
2783
2784     /**
2785         Returns the paragraph at the given character or caret position.
2786     */
2787     virtual wxRichTextParagraph* GetParagraphAtPosition(long pos, bool caretPosition = false) const;
2788
2789     /**
2790         Returns the line size at the given position.
2791     */
2792     virtual wxSize GetLineSizeAtPosition(long pos, bool caretPosition = false) const;
2793
2794     /**
2795         Given a position, returns the number of the visible line (potentially many to a paragraph),
2796         starting from zero at the start of the buffer. We also have to pass a bool (@a startOfLine)
2797         that indicates whether the caret is being shown at the end of the previous line or at the start
2798         of the next, since the caret can be shown at two visible positions for the same underlying
2799         position.
2800     */
2801     virtual long GetVisibleLineNumber(long pos, bool caretPosition = false, bool startOfLine = false) const;
2802
2803     /**
2804         Given a line number, returns the corresponding wxRichTextLine object.
2805     */
2806     virtual wxRichTextLine* GetLineForVisibleLineNumber(long lineNumber) const;
2807
2808     /**
2809         Returns the leaf object in a paragraph at this position.
2810     */
2811     virtual wxRichTextObject* GetLeafObjectAtPosition(long position) const;
2812
2813     /**
2814         Returns the paragraph by number.
2815     */
2816     virtual wxRichTextParagraph* GetParagraphAtLine(long paragraphNumber) const;
2817
2818     /**
2819         Returns the paragraph for a given line.
2820     */
2821     virtual wxRichTextParagraph* GetParagraphForLine(wxRichTextLine* line) const;
2822
2823     /**
2824         Returns the length of the paragraph.
2825     */
2826     virtual int GetParagraphLength(long paragraphNumber) const;
2827
2828     /**
2829         Returns the number of paragraphs.
2830     */
2831     virtual int GetParagraphCount() const { return static_cast<int>(GetChildCount()); }
2832
2833     /**
2834         Returns the number of visible lines.
2835     */
2836     virtual int GetLineCount() const;
2837
2838     /**
2839         Returns the text of the paragraph.
2840     */
2841     virtual wxString GetParagraphText(long paragraphNumber) const;
2842
2843     /**
2844         Converts zero-based line column and paragraph number to a position.
2845     */
2846     virtual long XYToPosition(long x, long y) const;
2847
2848     /**
2849         Converts a zero-based position to line column and paragraph number.
2850     */
2851     virtual bool PositionToXY(long pos, long* x, long* y) const;
2852
2853     /**
2854         Sets the attributes for the given range. Pass flags to determine how the
2855         attributes are set.
2856
2857         The end point of range is specified as the last character position of the span
2858         of text. So, for example, to set the style for a character at position 5,
2859         use the range (5,5).
2860         This differs from the wxRichTextCtrl API, where you would specify (5,6).
2861
2862         @a flags may contain a bit list of the following values:
2863         - wxRICHTEXT_SETSTYLE_NONE: no style flag.
2864         - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this operation should be
2865           undoable.
2866         - wxRICHTEXT_SETSTYLE_OPTIMIZE: specifies that the style should not be applied
2867           if the combined style at this point is already the style in question.
2868         - wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY: specifies that the style should only be
2869           applied to paragraphs, and not the content.
2870           This allows content styling to be preserved independently from that
2871           of e.g. a named paragraph style.
2872         - wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY: specifies that the style should only be
2873           applied to characters, and not the paragraph.
2874           This allows content styling to be preserved independently from that
2875           of e.g. a named paragraph style.
2876         - wxRICHTEXT_SETSTYLE_RESET: resets (clears) the existing style before applying
2877           the new style.
2878         - wxRICHTEXT_SETSTYLE_REMOVE: removes the specified style.
2879           Only the style flags are used in this operation.
2880     */
2881     virtual bool SetStyle(const wxRichTextRange& range, const wxRichTextAttr& style, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
2882
2883     /**
2884         Sets the attributes for the given object only, for example the box attributes for a text box.
2885     */
2886     virtual void SetStyle(wxRichTextObject *obj, const wxRichTextAttr& textAttr, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
2887
2888     /**
2889         Returns the combined text attributes for this position.
2890
2891         This function gets the @e uncombined style - that is, the attributes associated
2892         with the paragraph or character content, and not necessarily the combined
2893         attributes you see on the screen. To get the combined attributes, use GetStyle().
2894         If you specify (any) paragraph attribute in @e style's flags, this function
2895         will fetch the paragraph attributes.
2896         Otherwise, it will return the character attributes.
2897     */
2898     virtual bool GetStyle(long position, wxRichTextAttr& style);
2899
2900     /**
2901         Returns the content (uncombined) attributes for this position.
2902     */
2903     virtual bool GetUncombinedStyle(long position, wxRichTextAttr& style);
2904
2905     /**
2906         Implementation helper for GetStyle. If combineStyles is true, combine base, paragraph and
2907         context attributes.
2908     */
2909     virtual bool DoGetStyle(long position, wxRichTextAttr& style, bool combineStyles = true);
2910
2911     /**
2912         This function gets a style representing the common, combined attributes in the
2913         given range.
2914         Attributes which have different values within the specified range will not be
2915         included the style flags.
2916
2917         The function is used to get the attributes to display in the formatting dialog:
2918         the user can edit the attributes common to the selection, and optionally specify the
2919         values of further attributes to be applied uniformly.
2920
2921         To apply the edited attributes, you can use SetStyle() specifying
2922         the wxRICHTEXT_SETSTYLE_OPTIMIZE flag, which will only apply attributes that
2923         are different from the @e combined attributes within the range.
2924         So, the user edits the effective, displayed attributes for the range,
2925         but his choice won't be applied unnecessarily to content. As an example,
2926         say the style for a paragraph specifies bold, but the paragraph text doesn't
2927         specify a weight.
2928         The combined style is bold, and this is what the user will see on-screen and
2929         in the formatting dialog. The user now specifies red text, in addition to bold.
2930         When applying with SetStyle(), the content font weight attributes won't be
2931         changed to bold because this is already specified by the paragraph.
2932         However the text colour attributes @e will be changed to show red.
2933     */
2934     virtual bool GetStyleForRange(const wxRichTextRange& range, wxRichTextAttr& style);
2935
2936     /**
2937         Combines @a style with @a currentStyle for the purpose of summarising the attributes of a range of
2938         content.
2939     */
2940     bool CollectStyle(wxRichTextAttr& currentStyle, const wxRichTextAttr& style, wxRichTextAttr& clashingAttr, wxRichTextAttr& absentAttr);
2941
2942     //@{
2943     /**
2944         Sets the list attributes for the given range, passing flags to determine how
2945         the attributes are set.
2946         Either the style definition or the name of the style definition (in the current
2947         sheet) can be passed.
2948
2949         @a flags is a bit list of the following:
2950         - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
2951         - wxRICHTEXT_SETSTYLE_RENUMBER: specifies that numbering should start from
2952           @a startFrom, otherwise existing attributes are used.
2953         - wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL: specifies that @a listLevel should be used
2954           as the level for all paragraphs, otherwise the current indentation will be used.
2955
2956         @see NumberList(), PromoteList(), ClearListStyle().
2957     */
2958     virtual bool SetListStyle(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
2959     virtual bool SetListStyle(const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
2960     //@}
2961
2962     /**
2963         Clears the list style from the given range, clearing list-related attributes
2964         and applying any named paragraph style associated with each paragraph.
2965
2966         @a flags is a bit list of the following:
2967         - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
2968
2969         @see SetListStyle(), PromoteList(), NumberList()
2970     */
2971     virtual bool ClearListStyle(const wxRichTextRange& range, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
2972
2973     //@{
2974     /**
2975         Numbers the paragraphs in the given range.
2976
2977         Pass flags to determine how the attributes are set.
2978         Either the style definition or the name of the style definition (in the current
2979         sheet) can be passed.
2980
2981         @a flags is a bit list of the following:
2982         - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
2983         - wxRICHTEXT_SETSTYLE_RENUMBER: specifies that numbering should start from
2984           @a startFrom, otherwise existing attributes are used.
2985         - wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL: specifies that @a listLevel should be used
2986           as the level for all paragraphs, otherwise the current indentation will be used.
2987
2988         @a def can be NULL to indicate that the existing list style should be used.
2989
2990         @see SetListStyle(), PromoteList(), ClearListStyle()
2991     */
2992     virtual bool NumberList(const wxRichTextRange& range, wxRichTextListStyleDefinition* def = NULL, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
2993     virtual bool NumberList(const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
2994     //@}
2995
2996     //@{
2997     /**
2998         Promotes the list items within the given range.
2999         A positive @a promoteBy produces a smaller indent, and a negative number
3000         produces a larger indent. Pass flags to determine how the attributes are set.
3001         Either the style definition or the name of the style definition (in the current
3002         sheet) can be passed.
3003
3004         @a flags is a bit list of the following:
3005         - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
3006         - wxRICHTEXT_SETSTYLE_RENUMBER: specifies that numbering should start from
3007           @a startFrom, otherwise existing attributes are used.
3008         - wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL: specifies that @a listLevel should be used
3009           as the level for all paragraphs, otherwise the current indentation will be used.
3010
3011         @see SetListStyle(), SetListStyle(), ClearListStyle()
3012     */
3013     virtual bool PromoteList(int promoteBy, const wxRichTextRange& range, wxRichTextListStyleDefinition* def = NULL, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int specifiedLevel = -1);
3014     virtual bool PromoteList(int promoteBy, const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int specifiedLevel = -1);
3015     //@}
3016
3017     /**
3018         Helper for NumberList and PromoteList, that does renumbering and promotion simultaneously
3019         @a def can be NULL/empty to indicate that the existing list style should be used.
3020     */
3021     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);
3022
3023     /**
3024         Fills in the attributes for numbering a paragraph after previousParagraph.
3025     */
3026     virtual bool FindNextParagraphNumber(wxRichTextParagraph* previousParagraph, wxRichTextAttr& attr) const;
3027
3028     /**
3029         Sets the properties for the given range, passing flags to determine how the
3030         attributes are set. You can merge properties or replace them.
3031
3032         The end point of range is specified as the last character position of the span
3033         of text, plus one. So, for example, to set the properties for a character at
3034         position 5, use the range (5,6).
3035
3036         @a flags may contain a bit list of the following values:
3037         - wxRICHTEXT_SETPROPERTIES_NONE: no flag.
3038         - wxRICHTEXT_SETPROPERTIES_WITH_UNDO: specifies that this operation should be
3039           undoable.
3040         - wxRICHTEXT_SETPROPERTIES_PARAGRAPHS_ONLY: specifies that the properties should only be
3041           applied to paragraphs, and not the content.
3042         - wxRICHTEXT_SETPROPERTIES_CHARACTERS_ONLY: specifies that the properties should only be
3043           applied to characters, and not the paragraph.
3044         - wxRICHTEXT_SETPROPERTIES_RESET: resets (clears) the existing properties before applying
3045           the new properties.
3046         - wxRICHTEXT_SETPROPERTIES_REMOVE: removes the specified properties.
3047     */
3048     virtual bool SetProperties(const wxRichTextRange& range, const wxRichTextProperties& properties, int flags = wxRICHTEXT_SETPROPERTIES_WITH_UNDO);
3049
3050     /**
3051         Test if this whole range has character attributes of the specified kind. If any
3052         of the attributes are different within the range, the test fails. You
3053         can use this to implement, for example, bold button updating. style must have
3054         flags indicating which attributes are of interest.
3055     */
3056     virtual bool HasCharacterAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const;
3057
3058     /**
3059         Test if this whole range has paragraph attributes of the specified kind. If any
3060         of the attributes are different within the range, the test fails. You
3061         can use this to implement, for example, centering button updating. style must have
3062         flags indicating which attributes are of interest.
3063     */
3064     virtual bool HasParagraphAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const;
3065
3066     virtual wxRichTextObject* Clone() const { return new wxRichTextParagraphLayoutBox(*this); }
3067
3068     /**
3069         Insert fragment into this box at the given position. If partialParagraph is true,
3070         it is assumed that the last (or only) paragraph is just a piece of data with no paragraph
3071         marker.
3072     */
3073     virtual bool InsertFragment(long position, wxRichTextParagraphLayoutBox& fragment);
3074
3075     /**
3076         Make a copy of the fragment corresponding to the given range, putting it in @a fragment.
3077     */
3078     virtual bool CopyFragment(const wxRichTextRange& range, wxRichTextParagraphLayoutBox& fragment);
3079
3080     /**
3081         Apply the style sheet to the buffer, for example if the styles have changed.
3082     */
3083     virtual bool ApplyStyleSheet(wxRichTextStyleSheet* styleSheet);
3084
3085     void Copy(const wxRichTextParagraphLayoutBox& obj);
3086
3087     void operator= (const wxRichTextParagraphLayoutBox& obj) { Copy(obj); }
3088
3089     /**
3090         Calculate ranges.
3091     */
3092     virtual void UpdateRanges();
3093
3094     /**
3095         Get all the text.
3096     */
3097     virtual wxString GetText() const;
3098
3099     /**
3100         Sets the default style, affecting the style currently being applied
3101         (for example, setting the default style to bold will cause subsequently
3102         inserted text to be bold).
3103
3104         This is not cumulative - setting the default style will replace the previous
3105         default style.
3106
3107         Setting it to a default attribute object makes new content take on the 'basic' style.
3108     */
3109     virtual bool SetDefaultStyle(const wxRichTextAttr& style);
3110
3111     /**
3112         Returns the current default style, affecting the style currently being applied
3113         (for example, setting the default style to bold will cause subsequently
3114         inserted text to be bold).
3115     */
3116     virtual const wxRichTextAttr& GetDefaultStyle() const { return m_defaultAttributes; }
3117
3118     /**
3119         Sets the basic (overall) style. This is the style of the whole
3120         buffer before further styles are applied, unlike the default style, which
3121         only affects the style currently being applied (for example, setting the default
3122         style to bold will cause subsequently inserted text to be bold).
3123     */
3124     virtual void SetBasicStyle(const wxRichTextAttr& style) { m_attributes = style; }
3125
3126     /**
3127         Returns the basic (overall) style.
3128
3129         This is the style of the whole buffer before further styles are applied,
3130         unlike the default style, which only affects the style currently being
3131         applied (for example, setting the default style to bold will cause
3132         subsequently inserted text to be bold).
3133     */
3134     virtual const wxRichTextAttr& GetBasicStyle() const { return m_attributes; }
3135
3136     /**
3137         Invalidates the buffer. With no argument, invalidates whole buffer.
3138     */
3139     virtual void Invalidate(const wxRichTextRange& invalidRange = wxRICHTEXT_ALL);
3140
3141     /**
3142         Do the (in)validation for this object only.
3143     */
3144     virtual void DoInvalidate(const wxRichTextRange& invalidRange);
3145
3146     /**
3147         Do the (in)validation both up and down the hierarchy.
3148     */
3149     virtual void InvalidateHierarchy(const wxRichTextRange& invalidRange = wxRICHTEXT_ALL);
3150
3151     /**
3152         Gather information about floating objects. If untilObj is non-NULL,
3153         will stop getting information if the current object is this, since we
3154         will collect the rest later.
3155     */
3156     virtual bool UpdateFloatingObjects(const wxRect& availableRect, wxRichTextObject* untilObj = NULL);
3157
3158     /**
3159         Get invalid range, rounding to entire paragraphs if argument is true.
3160     */
3161     wxRichTextRange GetInvalidRange(bool wholeParagraphs = false) const;
3162
3163     /**
3164         Returns @true if this object needs layout.
3165     */
3166     bool IsDirty() const { return m_invalidRange != wxRICHTEXT_NONE; }
3167
3168     /**
3169         Returns the wxRichTextFloatCollector of this object.
3170     */
3171     wxRichTextFloatCollector* GetFloatCollector() { return m_floatCollector; }
3172
3173     /**
3174         Returns the number of floating objects at this level.
3175     */
3176     int GetFloatingObjectCount() const;
3177
3178     /**
3179         Returns a list of floating objects.
3180     */
3181     bool GetFloatingObjects(wxRichTextObjectList& objects) const;
3182
3183 protected:
3184     wxRichTextCtrl* m_ctrl;
3185     wxRichTextAttr  m_defaultAttributes;
3186
3187     // The invalidated range that will need full layout
3188     wxRichTextRange m_invalidRange;
3189
3190     // Is the last paragraph partial or complete?
3191     bool            m_partialParagraph;
3192
3193     // The floating layout state
3194     wxRichTextFloatCollector* m_floatCollector;
3195 };
3196
3197 /**
3198     @class wxRichTextBox
3199
3200     This class implements a floating or inline text box, containing paragraphs.
3201
3202     @library{wxrichtext}
3203     @category{richtext}
3204
3205     @see wxRichTextParagraphLayoutBox, wxRichTextObject, wxRichTextBuffer, wxRichTextCtrl
3206 */
3207
3208 class WXDLLIMPEXP_RICHTEXT wxRichTextBox: public wxRichTextParagraphLayoutBox
3209 {
3210     DECLARE_DYNAMIC_CLASS(wxRichTextBox)
3211 public:
3212 // Constructors
3213
3214     /**
3215         Default constructor; optionally pass the parent object.
3216     */
3217
3218     wxRichTextBox(wxRichTextObject* parent = NULL);
3219
3220     /**
3221         Copy constructor.
3222     */
3223
3224     wxRichTextBox(const wxRichTextBox& obj): wxRichTextParagraphLayoutBox() { Copy(obj); }
3225
3226 // Overridables
3227
3228     virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
3229
3230     virtual wxString GetXMLNodeName() const { return wxT("textbox"); }
3231
3232     virtual bool CanEditProperties() const { return true; }
3233
3234     virtual bool EditProperties(wxWindow* parent, wxRichTextBuffer* buffer);
3235
3236     virtual wxString GetPropertiesMenuLabel() const { return _("&Box"); }
3237
3238 // Accessors
3239
3240 // Operations
3241
3242     virtual wxRichTextObject* Clone() const { return new wxRichTextBox(*this); }
3243
3244     void Copy(const wxRichTextBox& obj);
3245
3246 protected:
3247 };
3248
3249 /**
3250     @class wxRichTextLine
3251
3252     This object represents a line in a paragraph, and stores
3253     offsets from the start of the paragraph representing the
3254     start and end positions of the line.
3255
3256     @library{wxrichtext}
3257     @category{richtext}
3258
3259     @see wxRichTextBuffer, wxRichTextCtrl
3260 */
3261
3262 class WXDLLIMPEXP_RICHTEXT wxRichTextLine
3263 {
3264 public:
3265 // Constructors
3266
3267     wxRichTextLine(wxRichTextParagraph* parent);
3268     wxRichTextLine(const wxRichTextLine& obj) { Init( NULL); Copy(obj); }
3269     virtual ~wxRichTextLine() {}
3270
3271 // Overridables
3272
3273 // Accessors
3274
3275     /**
3276         Sets the range associated with this line.
3277     */
3278     void SetRange(const wxRichTextRange& range) { m_range = range; }
3279     /**
3280         Sets the range associated with this line.
3281     */
3282     void SetRange(long from, long to) { m_range = wxRichTextRange(from, to); }
3283
3284     /**
3285         Returns the parent paragraph.
3286     */
3287     wxRichTextParagraph* GetParent() { return m_parent; }
3288
3289     /**
3290         Returns the range.
3291     */
3292     const wxRichTextRange& GetRange() const { return m_range; }
3293     /**
3294         Returns the range.
3295     */
3296     wxRichTextRange& GetRange() { return m_range; }
3297
3298     /**
3299         Returns the absolute range.
3300     */
3301     wxRichTextRange GetAbsoluteRange() const;
3302
3303     /**
3304         Returns the line size as calculated by Layout.
3305     */
3306     virtual wxSize GetSize() const { return m_size; }
3307
3308     /**
3309         Sets the line size as calculated by Layout.
3310     */
3311     virtual void SetSize(const wxSize& sz) { m_size = sz; }
3312
3313     /**
3314         Returns the object position relative to the parent.
3315     */
3316     virtual wxPoint GetPosition() const { return m_pos; }
3317
3318     /**
3319         Sets the object position relative to the parent.
3320     */
3321     virtual void SetPosition(const wxPoint& pos) { m_pos = pos; }
3322
3323     /**
3324         Returns the absolute object position.
3325     */
3326     virtual wxPoint GetAbsolutePosition() const;
3327
3328     /**
3329         Returns the rectangle enclosing the line.
3330     */
3331     virtual wxRect GetRect() const { return wxRect(GetAbsolutePosition(), GetSize()); }
3332
3333     /**
3334         Sets the stored descent.
3335     */
3336     void SetDescent(int descent) { m_descent = descent; }
3337
3338     /**
3339         Returns the stored descent.
3340     */
3341     int GetDescent() const { return m_descent; }
3342
3343 #if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING
3344     wxArrayInt& GetObjectSizes() { return m_objectSizes; }
3345     const wxArrayInt& GetObjectSizes() const { return m_objectSizes; }
3346 #endif
3347
3348 // Operations
3349
3350     /**
3351         Initialises the object.
3352     */
3353     void Init(wxRichTextParagraph* parent);
3354
3355     /**
3356         Copies from @a obj.
3357     */
3358     void Copy(const wxRichTextLine& obj);
3359
3360     virtual wxRichTextLine* Clone() const { return new wxRichTextLine(*this); }
3361
3362 protected:
3363
3364     // The range of the line (start position to end position)
3365     // This is relative to the parent paragraph.
3366     wxRichTextRange     m_range;
3367
3368     // Size and position measured relative to top of paragraph
3369     wxPoint             m_pos;
3370     wxSize              m_size;
3371
3372     // Maximum descent for this line (location of text baseline)
3373     int                 m_descent;
3374
3375     // The parent object
3376     wxRichTextParagraph* m_parent;
3377
3378 #if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING
3379     wxArrayInt          m_objectSizes;
3380 #endif
3381 };
3382
3383 WX_DECLARE_LIST_WITH_DECL( wxRichTextLine, wxRichTextLineList , class WXDLLIMPEXP_RICHTEXT );
3384
3385 /**
3386     @class wxRichTextParagraph
3387
3388     This object represents a single paragraph containing various objects such as text content, images, and further paragraph layout objects.
3389
3390     @library{wxrichtext}
3391     @category{richtext}
3392
3393     @see wxRichTextBuffer, wxRichTextCtrl
3394 */
3395
3396 class WXDLLIMPEXP_RICHTEXT wxRichTextParagraph: public wxRichTextCompositeObject
3397 {
3398     DECLARE_DYNAMIC_CLASS(wxRichTextParagraph)
3399 public:
3400 // Constructors
3401
3402     /**
3403         Constructor taking a parent and style.
3404     */
3405     wxRichTextParagraph(wxRichTextObject* parent = NULL, wxRichTextAttr* style = NULL);
3406     /**
3407         Constructor taking a text string, a parent and paragraph and character attributes.
3408     */
3409     wxRichTextParagraph(const wxString& text, wxRichTextObject* parent = NULL, wxRichTextAttr* paraStyle = NULL, wxRichTextAttr* charStyle = NULL);
3410     virtual ~wxRichTextParagraph();
3411     wxRichTextParagraph(const wxRichTextParagraph& obj): wxRichTextCompositeObject() { Copy(obj); }
3412
3413 // Overridables
3414
3415     virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
3416
3417     virtual bool Layout(wxDC& dc, const wxRect& rect, const wxRect& parentRect, int style);
3418
3419     virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
3420
3421     virtual bool FindPosition(wxDC& dc, long index, wxPoint& pt, int* height, bool forceLineStart);
3422
3423     virtual int HitTest(wxDC& dc, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags = 0);
3424
3425     virtual void CalculateRange(long start, long& end);
3426
3427     virtual wxString GetXMLNodeName() const { return wxT("paragraph"); }
3428
3429 // Accessors
3430
3431     /**
3432         Returns the cached lines.
3433     */
3434     wxRichTextLineList& GetLines() { return m_cachedLines; }
3435
3436 // Operations
3437
3438     /**
3439         Copies the object.
3440     */
3441     void Copy(const wxRichTextParagraph& obj);
3442
3443     virtual wxRichTextObject* Clone() const { return new wxRichTextParagraph(*this); }
3444
3445     /**
3446         Clears the cached lines.
3447     */
3448     void ClearLines();
3449
3450 // Implementation
3451
3452     /**
3453         Applies paragraph styles such as centering to the wrapped lines.
3454     */
3455     virtual void ApplyParagraphStyle(wxRichTextLine* line, const wxRichTextAttr& attr, const wxRect& rect, wxDC& dc);
3456
3457     /**
3458         Inserts text at the given position.
3459     */
3460     virtual bool InsertText(long pos, const wxString& text);
3461
3462     /**
3463         Splits an object at this position if necessary, and returns
3464         the previous object, or NULL if inserting at the beginning.
3465     */
3466     virtual wxRichTextObject* SplitAt(long pos, wxRichTextObject** previousObject = NULL);
3467
3468     /**
3469         Moves content to a list from this point.
3470     */
3471     virtual void MoveToList(wxRichTextObject* obj, wxList& list);
3472
3473     /**
3474         Adds content back from a list.
3475     */
3476     virtual void MoveFromList(wxList& list);
3477
3478     /**
3479         Returns the plain text searching from the start or end of the range.
3480         The resulting string may be shorter than the range given.
3481     */
3482     bool GetContiguousPlainText(wxString& text, const wxRichTextRange& range, bool fromStart = true);
3483
3484     /**
3485         Finds a suitable wrap position. @a wrapPosition is the last position in the line to the left
3486         of the split.
3487     */
3488     bool FindWrapPosition(const wxRichTextRange& range, wxDC& dc, int availableSpace, long& wrapPosition, wxArrayInt* partialExtents);
3489
3490     /**
3491         Finds the object at the given position.
3492     */
3493     wxRichTextObject* FindObjectAtPosition(long position);
3494
3495     /**
3496         Returns the bullet text for this paragraph.
3497     */
3498     wxString GetBulletText();
3499
3500     /**
3501         Allocates or reuses a line object.
3502     */
3503     wxRichTextLine* AllocateLine(int pos);
3504
3505     /**
3506         Clears remaining unused line objects, if any.
3507     */
3508     bool ClearUnusedLines(int lineCount);
3509
3510     /**
3511         Returns combined attributes of the base style, paragraph style and character style. We use this to dynamically
3512         retrieve the actual style.
3513     */
3514     wxRichTextAttr GetCombinedAttributes(const wxRichTextAttr& contentStyle, bool includingBoxAttr = false) const;
3515
3516     /**
3517         Returns the combined attributes of the base style and paragraph style.
3518     */
3519     wxRichTextAttr GetCombinedAttributes(bool includingBoxAttr = false) const;
3520
3521     /**
3522         Returns the first position from pos that has a line break character.
3523     */
3524     long GetFirstLineBreakPosition(long pos);
3525
3526     /**
3527         Creates a default tabstop array.
3528     */
3529     static void InitDefaultTabs();
3530
3531     /**
3532         Clears the default tabstop array.
3533     */
3534     static void ClearDefaultTabs();
3535
3536     /**
3537         Returns the default tabstop array.
3538     */
3539     static const wxArrayInt& GetDefaultTabs() { return sm_defaultTabs; }
3540
3541     /**
3542         Lays out the floating objects.
3543     */
3544     void LayoutFloat(wxDC& dc, const wxRect& rect, int style, wxRichTextFloatCollector* floatCollector);
3545
3546 protected:
3547
3548     // The lines that make up the wrapped paragraph
3549     wxRichTextLineList m_cachedLines;
3550
3551     // Default tabstops
3552     static wxArrayInt  sm_defaultTabs;
3553
3554 friend class wxRichTextFloatCollector;
3555 };
3556
3557 /**
3558     @class wxRichTextPlainText
3559
3560     This object represents a single piece of text.
3561
3562     @library{wxrichtext}
3563     @category{richtext}
3564
3565     @see wxRichTextBuffer, wxRichTextCtrl
3566 */
3567
3568 class WXDLLIMPEXP_RICHTEXT wxRichTextPlainText: public wxRichTextObject
3569 {
3570     DECLARE_DYNAMIC_CLASS(wxRichTextPlainText)
3571 public:
3572 // Constructors
3573
3574     /**
3575         Constructor.
3576     */
3577     wxRichTextPlainText(const wxString& text = wxEmptyString, wxRichTextObject* parent = NULL, wxRichTextAttr* style = NULL);
3578
3579     /**
3580         Copy constructor.
3581     */
3582     wxRichTextPlainText(const wxRichTextPlainText& obj): wxRichTextObject() { Copy(obj); }
3583
3584 // Overridables
3585
3586     virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
3587
3588     virtual bool Layout(wxDC& dc, const wxRect& rect, const wxRect& parentRect, int style);
3589
3590     virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
3591
3592     virtual wxString GetTextForRange(const wxRichTextRange& range) const;
3593
3594     virtual wxRichTextObject* DoSplit(long pos);
3595
3596     virtual void CalculateRange(long start, long& end);
3597
3598     virtual bool DeleteRange(const wxRichTextRange& range);
3599
3600     virtual bool IsEmpty() const { return m_text.empty(); }
3601
3602     virtual bool CanMerge(wxRichTextObject* object) const;
3603
3604     virtual bool Merge(wxRichTextObject* object);
3605
3606     virtual void Dump(wxTextOutputStream& stream);
3607
3608     /**
3609         Get the first position from pos that has a line break character.
3610     */
3611     long GetFirstLineBreakPosition(long pos);
3612
3613     /// Does this object take note of paragraph attributes? Text and image objects don't.
3614     virtual bool UsesParagraphAttributes() const { return false; }
3615
3616 #if wxUSE_XML
3617     virtual bool ImportFromXML(wxRichTextBuffer* buffer, wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse);
3618 #endif
3619
3620 #if wxRICHTEXT_HAVE_DIRECT_OUTPUT
3621     virtual bool ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler);
3622 #endif
3623
3624 #if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
3625     virtual bool ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler);
3626 #endif
3627
3628     virtual wxString GetXMLNodeName() const { return wxT("text"); }
3629
3630 // Accessors
3631
3632     /**
3633         Returns the text.
3634     */
3635     const wxString& GetText() const { return m_text; }
3636
3637     /**
3638         Sets the text.
3639     */
3640     void SetText(const wxString& text) { m_text = text; }
3641
3642 // Operations
3643
3644     // Copies the text object,
3645     void Copy(const wxRichTextPlainText& obj);
3646
3647     // Clones the text object.
3648     virtual wxRichTextObject* Clone() const { return new wxRichTextPlainText(*this); }
3649
3650 private:
3651     bool DrawTabbedString(wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect, wxString& str, wxCoord& x, wxCoord& y, bool selected);
3652
3653 protected:
3654     wxString    m_text;
3655 };
3656
3657 /**
3658     @class wxRichTextImageBlock
3659
3660     This class stores information about an image, in binary in-memory form.
3661
3662     @library{wxrichtext}
3663     @category{richtext}
3664
3665     @see wxRichTextBuffer, wxRichTextCtrl
3666 */
3667
3668 class WXDLLIMPEXP_RICHTEXT wxRichTextImageBlock: public wxObject
3669 {
3670 public:
3671     /**
3672         Constructor.
3673     */
3674     wxRichTextImageBlock();
3675
3676     /**
3677         Copy constructor.
3678     */
3679     wxRichTextImageBlock(const wxRichTextImageBlock& block);
3680     virtual ~wxRichTextImageBlock();
3681
3682     /**
3683         Initialises the block.
3684     */
3685     void Init();
3686
3687     /**
3688         Clears the block.
3689     */
3690
3691     void Clear();
3692
3693     /**
3694         Load the original image into a memory block.
3695         If the image is not a JPEG, we must convert it into a JPEG
3696         to conserve space.
3697         If it's not a JPEG we can make use of @a image, already scaled, so we don't have to
3698         load the image a second time.
3699     */
3700     virtual bool MakeImageBlock(const wxString& filename, wxBitmapType imageType,
3701                                 wxImage& image, bool convertToJPEG = true);
3702
3703     /**
3704         Make an image block from the wxImage in the given
3705         format.
3706     */
3707     virtual bool MakeImageBlock(wxImage& image, wxBitmapType imageType, int quality = 80);
3708
3709     /**
3710         Uses a const wxImage for efficiency, but can't set quality (only relevant for JPEG)
3711     */
3712     virtual bool MakeImageBlockDefaultQuality(const wxImage& image, wxBitmapType imageType);
3713
3714     /**
3715         Makes the image block.
3716     */
3717     virtual bool DoMakeImageBlock(const wxImage& image, wxBitmapType imageType);
3718
3719     /**
3720         Writes the block to a file.
3721     */
3722     bool Write(const wxString& filename);
3723
3724     /**
3725         Writes the data in hex to a stream.
3726     */
3727     bool WriteHex(wxOutputStream& stream);
3728
3729     /**
3730         Reads the data in hex from a stream.
3731     */
3732     bool ReadHex(wxInputStream& stream, int length, wxBitmapType imageType);
3733
3734     /**
3735         Copy from @a block.
3736     */
3737     void Copy(const wxRichTextImageBlock& block);
3738
3739     // Load a wxImage from the block
3740     /**
3741     */
3742     bool Load(wxImage& image);
3743
3744 // Operators
3745
3746     /**
3747         Assignment operation.
3748     */
3749     void operator=(const wxRichTextImageBlock& block);
3750
3751 // Accessors
3752
3753     /**
3754         Returns the raw data.
3755     */
3756     unsigned char* GetData() const { return m_data; }
3757
3758     /**
3759         Returns the data size in bytes.
3760     */
3761     size_t GetDataSize() const { return m_dataSize; }
3762
3763     /**
3764         Returns the image type.
3765     */
3766     wxBitmapType GetImageType() const { return m_imageType; }
3767
3768     /**
3769     */
3770     void SetData(unsigned char* image) { m_data = image; }
3771
3772     /**
3773         Sets the data size.
3774     */
3775     void SetDataSize(size_t size) { m_dataSize = size; }
3776
3777     /**
3778         Sets the image type.
3779     */
3780     void SetImageType(wxBitmapType imageType) { m_imageType = imageType; }
3781
3782     /**
3783         Returns @true if the data is non-NULL.
3784     */
3785     bool IsOk() const { return GetData() != NULL; }
3786     bool Ok() const { return IsOk(); }
3787
3788     /**
3789         Gets the extension for the block's type.
3790     */
3791     wxString GetExtension() const;
3792
3793 /// Implementation
3794
3795     /**
3796         Allocates and reads from a stream as a block of memory.
3797     */
3798     static unsigned char* ReadBlock(wxInputStream& stream, size_t size);
3799
3800     /**
3801         Allocates and reads from a file as a block of memory.
3802     */
3803     static unsigned char* ReadBlock(const wxString& filename, size_t size);
3804
3805     /**
3806         Writes a memory block to stream.
3807     */
3808     static bool WriteBlock(wxOutputStream& stream, unsigned char* block, size_t size);
3809
3810     /**
3811         Writes a memory block to a file.
3812     */
3813     static bool WriteBlock(const wxString& filename, unsigned char* block, size_t size);
3814
3815 protected:
3816     // Size in bytes of the image stored.
3817     // This is in the raw, original form such as a JPEG file.
3818     unsigned char*      m_data;
3819     size_t              m_dataSize;
3820     wxBitmapType        m_imageType;
3821 };
3822
3823 /**
3824     @class wxRichTextImage
3825
3826     This class implements a graphic object.
3827
3828     @library{wxrichtext}
3829     @category{richtext}
3830
3831     @see wxRichTextBuffer, wxRichTextCtrl, wxRichTextImageBlock
3832 */
3833
3834 class WXDLLIMPEXP_RICHTEXT wxRichTextImage: public wxRichTextObject
3835 {
3836     DECLARE_DYNAMIC_CLASS(wxRichTextImage)
3837 public:
3838 // Constructors
3839
3840     /**
3841         Default constructor.
3842     */
3843     wxRichTextImage(wxRichTextObject* parent = NULL): wxRichTextObject(parent) { }
3844
3845     /**
3846         Creates a wxRichTextImage from a wxImage.
3847     */
3848     wxRichTextImage(const wxImage& image, wxRichTextObject* parent = NULL, wxRichTextAttr* charStyle = NULL);
3849
3850     /**
3851         Creates a wxRichTextImage from an image block.
3852     */
3853     wxRichTextImage(const wxRichTextImageBlock& imageBlock, wxRichTextObject* parent = NULL, wxRichTextAttr* charStyle = NULL);
3854
3855     /**
3856         Copy constructor.
3857     */
3858     wxRichTextImage(const wxRichTextImage& obj): wxRichTextObject(obj) { Copy(obj); }
3859
3860 // Overridables
3861
3862     virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
3863
3864     virtual bool Layout(wxDC& dc, const wxRect& rect, const wxRect& parentRect, int style);
3865
3866     virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
3867
3868     /**
3869         Returns the 'natural' size for this object - the image size.
3870     */
3871     virtual wxTextAttrSize GetNaturalSize() const;
3872
3873     virtual bool IsEmpty() const { return false; /* !m_imageBlock.IsOk(); */ }
3874
3875     virtual bool CanEditProperties() const { return true; }
3876
3877     virtual bool EditProperties(wxWindow* parent, wxRichTextBuffer* buffer);
3878
3879     virtual wxString GetPropertiesMenuLabel() const { return _("&Picture"); }
3880
3881     virtual bool UsesParagraphAttributes() const { return false; }
3882
3883 #if wxUSE_XML
3884     virtual bool ImportFromXML(wxRichTextBuffer* buffer, wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse);
3885 #endif
3886
3887 #if wxRICHTEXT_HAVE_DIRECT_OUTPUT
3888     virtual bool ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler);
3889 #endif
3890
3891 #if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
3892     virtual bool ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler);
3893 #endif
3894
3895     // Images can be floatable (optionally).
3896     virtual bool IsFloatable() const { return true; }
3897
3898     virtual wxString GetXMLNodeName() const { return wxT("image"); }
3899
3900 // Accessors
3901
3902     /**
3903         Returns the image cache (a scaled bitmap).
3904     */
3905     const wxBitmap& GetImageCache() const { return m_imageCache; }
3906
3907     /**
3908         Sets the image cache.
3909     */
3910     void SetImageCache(const wxBitmap& bitmap) { m_imageCache = bitmap; }
3911
3912     /**
3913         Resets the image cache.
3914     */
3915     void ResetImageCache() { m_imageCache = wxNullBitmap; }
3916
3917     /**
3918         Returns the image block containing the raw data.
3919     */
3920     wxRichTextImageBlock& GetImageBlock() { return m_imageBlock; }
3921
3922 // Operations
3923
3924     /**
3925         Copies the image object.
3926     */
3927     void Copy(const wxRichTextImage& obj);
3928
3929     /**
3930         Clones the image object.
3931     */
3932     virtual wxRichTextObject* Clone() const { return new wxRichTextImage(*this); }
3933
3934     /**
3935         Creates a cached image at the required size.
3936     */
3937     virtual bool LoadImageCache(wxDC& dc, bool resetCache = false);
3938
3939 protected:
3940     wxRichTextImageBlock    m_imageBlock;
3941     wxBitmap                m_imageCache;
3942 };
3943
3944 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextCommand;
3945 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextAction;
3946
3947 /**
3948     @class wxRichTextBuffer
3949
3950     This is a kind of paragraph layout box, used to represent the whole buffer.
3951
3952     @library{wxrichtext}
3953     @category{richtext}
3954
3955     @see wxRichTextParagraphLayoutBox, wxRichTextCtrl
3956 */
3957
3958 class WXDLLIMPEXP_RICHTEXT wxRichTextBuffer: public wxRichTextParagraphLayoutBox
3959 {
3960     DECLARE_DYNAMIC_CLASS(wxRichTextBuffer)
3961 public:
3962 // Constructors
3963
3964     /**
3965         Default constructor.
3966     */
3967     wxRichTextBuffer() { Init(); }
3968
3969     /**
3970         Copy constructor.
3971     */
3972     wxRichTextBuffer(const wxRichTextBuffer& obj): wxRichTextParagraphLayoutBox() { Init(); Copy(obj); }
3973
3974     virtual ~wxRichTextBuffer() ;
3975
3976 // Accessors
3977
3978     /**
3979         Returns the command processor.
3980         A text buffer always creates its own command processor when it is initialized.
3981     */
3982     wxCommandProcessor* GetCommandProcessor() const { return m_commandProcessor; }
3983
3984     /**
3985         Sets style sheet, if any. This will allow the application to use named character and paragraph
3986         styles found in the style sheet.
3987
3988         Neither the buffer nor the control owns the style sheet so must be deleted by the application.
3989     */
3990     void SetStyleSheet(wxRichTextStyleSheet* styleSheet) { m_styleSheet = styleSheet; }
3991
3992     /**
3993         Returns the style sheet.
3994     */
3995     virtual wxRichTextStyleSheet* GetStyleSheet() const { return m_styleSheet; }
3996
3997     /**
3998         Sets the style sheet and sends a notification of the change.
3999     */
4000     bool SetStyleSheetAndNotify(wxRichTextStyleSheet* sheet);
4001
4002     /**
4003         Pushes the style sheet to the top of the style sheet stack.
4004     */
4005     bool PushStyleSheet(wxRichTextStyleSheet* styleSheet);
4006
4007     /**
4008         Pops the style sheet from the top of the style sheet stack.
4009     */
4010     wxRichTextStyleSheet* PopStyleSheet();
4011
4012     /**
4013         Returns the table storing fonts, for quick access and font reuse.
4014     */
4015     wxRichTextFontTable& GetFontTable() { return m_fontTable; }
4016
4017     /**
4018         Returns the table storing fonts, for quick access and font reuse.
4019     */
4020     const wxRichTextFontTable& GetFontTable() const { return m_fontTable; }
4021
4022     /**
4023         Sets table storing fonts, for quick access and font reuse.
4024     */
4025     void SetFontTable(const wxRichTextFontTable& table) { m_fontTable = table; }
4026
4027 // Operations
4028
4029     /**
4030         Initialisation.
4031     */
4032     void Init();
4033
4034     /**
4035         Clears the buffer, adds an empty paragraph, and clears the command processor.
4036     */
4037     virtual void ResetAndClearCommands();
4038
4039     //@{
4040     /**
4041         Loads content from a stream or file.
4042         Not all handlers will implement file loading.
4043     */
4044     virtual bool LoadFile(const wxString& filename, wxRichTextFileType type = wxRICHTEXT_TYPE_ANY);
4045     virtual bool LoadFile(wxInputStream& stream, wxRichTextFileType type = wxRICHTEXT_TYPE_ANY);
4046     //@}
4047
4048     //@{
4049     /**
4050         Saves content to a stream or file.
4051         Not all handlers will implement file saving.
4052     */
4053     virtual bool SaveFile(const wxString& filename, wxRichTextFileType type = wxRICHTEXT_TYPE_ANY);
4054     virtual bool SaveFile(wxOutputStream& stream, wxRichTextFileType type = wxRICHTEXT_TYPE_ANY);
4055     //@}
4056
4057     /**
4058         Sets the handler flags, controlling loading and saving.
4059     */
4060     void SetHandlerFlags(int flags) { m_handlerFlags = flags; }
4061
4062     /**
4063         Gets the handler flags, controlling loading and saving.
4064     */
4065     int GetHandlerFlags() const { return m_handlerFlags; }
4066
4067     /**
4068         Convenience function to add a paragraph of text.
4069     */
4070     virtual wxRichTextRange AddParagraph(const wxString& text, wxRichTextAttr* paraStyle = NULL) { Modify(); return wxRichTextParagraphLayoutBox::AddParagraph(text, paraStyle); }
4071
4072     /**
4073         Begin collapsing undo/redo commands. Note that this may not work properly
4074         if combining commands that delete or insert content, changing ranges for
4075         subsequent actions.
4076
4077         @a cmdName should be the name of the combined command that will appear
4078         next to Undo and Redo in the edit menu.
4079     */
4080     virtual bool BeginBatchUndo(const wxString& cmdName);
4081
4082     /**
4083         End collapsing undo/redo commands.
4084     */
4085     virtual bool EndBatchUndo();
4086
4087     /**
4088         Returns @true if we are collapsing commands.
4089     */
4090     virtual bool BatchingUndo() const { return m_batchedCommandDepth > 0; }
4091
4092     /**
4093         Submit the action immediately, or delay according to whether collapsing is on.
4094     */
4095     virtual bool SubmitAction(wxRichTextAction* action);
4096
4097     /**
4098         Returns the collapsed command.
4099     */
4100     virtual wxRichTextCommand* GetBatchedCommand() const { return m_batchedCommand; }
4101
4102     /**
4103         Begin suppressing undo/redo commands. The way undo is suppressed may be implemented
4104         differently by each command. If not dealt with by a command implementation, then
4105         it will be implemented automatically by not storing the command in the undo history
4106         when the action is submitted to the command processor.
4107     */
4108     virtual bool BeginSuppressUndo();
4109
4110     /**
4111         End suppressing undo/redo commands.
4112     */
4113     virtual bool EndSuppressUndo();
4114
4115     /**
4116         Are we suppressing undo??
4117     */
4118     virtual bool SuppressingUndo() const { return m_suppressUndo > 0; }
4119
4120     /**
4121         Copy the range to the clipboard.
4122     */
4123     virtual bool CopyToClipboard(const wxRichTextRange& range);
4124
4125     /**
4126         Paste the clipboard content to the buffer.
4127     */
4128     virtual bool PasteFromClipboard(long position);
4129
4130     /**
4131         Returns @true if we can paste from the clipboard.
4132     */
4133     virtual bool CanPasteFromClipboard() const;
4134
4135     /**
4136         Begin using a style.
4137     */
4138     virtual bool BeginStyle(const wxRichTextAttr& style);
4139
4140     /**
4141         End the style.
4142     */
4143     virtual bool EndStyle();
4144
4145     /**
4146         End all styles.
4147     */
4148     virtual bool EndAllStyles();
4149
4150     /**
4151         Clears the style stack.
4152     */
4153     virtual void ClearStyleStack();
4154
4155     /**
4156         Returns the size of the style stack, for example to check correct nesting.
4157     */
4158     virtual size_t GetStyleStackSize() const { return m_attributeStack.GetCount(); }
4159
4160     /**
4161         Begins using bold.
4162     */
4163     bool BeginBold();
4164
4165     /**
4166         Ends using bold.
4167     */
4168     bool EndBold() { return EndStyle(); }
4169
4170     /**
4171         Begins using italic.
4172     */
4173     bool BeginItalic();
4174
4175     /**
4176         Ends using italic.
4177     */
4178     bool EndItalic() { return EndStyle(); }
4179
4180     /**
4181         Begins using underline.
4182     */
4183     bool BeginUnderline();
4184
4185     /**
4186         Ends using underline.
4187     */
4188     bool EndUnderline() { return EndStyle(); }
4189
4190     /**
4191         Begins using point size.
4192     */
4193     bool BeginFontSize(int pointSize);
4194
4195     /**
4196         Ends using point size.
4197     */
4198     bool EndFontSize() { return EndStyle(); }
4199
4200     /**
4201         Begins using this font.
4202     */
4203     bool BeginFont(const wxFont& font);
4204
4205     /**
4206         Ends using a font.
4207     */
4208     bool EndFont() { return EndStyle(); }
4209
4210     /**
4211         Begins using this colour.
4212     */
4213     bool BeginTextColour(const wxColour& colour);
4214
4215     /**
4216         Ends using a colour.
4217     */
4218     bool EndTextColour() { return EndStyle(); }
4219
4220     /**
4221         Begins using alignment.
4222     */
4223     bool BeginAlignment(wxTextAttrAlignment alignment);
4224
4225     /**
4226         Ends alignment.
4227     */
4228     bool EndAlignment() { return EndStyle(); }
4229
4230     /**
4231         Begins using @a leftIndent for the left indent, and optionally @a leftSubIndent for
4232         the sub-indent. Both are expressed in tenths of a millimetre.
4233
4234         The sub-indent is an offset from the left of the paragraph, and is used for all
4235         but the first line in a paragraph. A positive value will cause the first line to appear
4236         to the left of the subsequent lines, and a negative value will cause the first line to be
4237         indented relative to the subsequent lines.
4238     */
4239     bool BeginLeftIndent(int leftIndent, int leftSubIndent = 0);
4240
4241     /**
4242         Ends left indent.
4243     */
4244     bool EndLeftIndent() { return EndStyle(); }
4245
4246     /**
4247         Begins a right indent, specified in tenths of a millimetre.
4248     */
4249     bool BeginRightIndent(int rightIndent);
4250
4251     /**
4252         Ends right indent.
4253     */
4254     bool EndRightIndent() { return EndStyle(); }
4255
4256     /**
4257         Begins paragraph spacing; pass the before-paragraph and after-paragraph spacing
4258         in tenths of a millimetre.
4259     */
4260     bool BeginParagraphSpacing(int before, int after);
4261
4262     /**
4263         Ends paragraph spacing.
4264     */
4265     bool EndParagraphSpacing() { return EndStyle(); }
4266
4267     /**
4268         Begins line spacing using the specified value. @e spacing is a multiple, where
4269         10 means single-spacing, 15 means 1.5 spacing, and 20 means double spacing.
4270
4271         The ::wxTextAttrLineSpacing enumeration values are defined for convenience.
4272     */
4273     bool BeginLineSpacing(int lineSpacing);
4274
4275     /**
4276         Ends line spacing.
4277     */
4278     bool EndLineSpacing() { return EndStyle(); }
4279
4280     /**
4281         Begins numbered bullet.
4282
4283         This call will be needed for each item in the list, and the
4284         application should take care of incrementing the numbering.
4285
4286         @a bulletNumber is a number, usually starting with 1.
4287         @a leftIndent and @a leftSubIndent are values in tenths of a millimetre.
4288         @a bulletStyle is a bitlist of the following values:
4289
4290         wxRichTextBuffer uses indentation to render a bulleted item.
4291         The left indent is the distance between the margin and the bullet.
4292         The content of the paragraph, including the first line, starts
4293         at leftMargin + leftSubIndent.
4294         So the distance between the left edge of the bullet and the
4295         left of the actual paragraph is leftSubIndent.
4296     */
4297     bool BeginNumberedBullet(int bulletNumber, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_ARABIC|wxTEXT_ATTR_BULLET_STYLE_PERIOD);
4298
4299     /**
4300         Ends numbered bullet.
4301     */
4302     bool EndNumberedBullet() { return EndStyle(); }
4303
4304     /**
4305         Begins applying a symbol bullet, using a character from the current font.
4306
4307         See BeginNumberedBullet() for an explanation of how indentation is used
4308         to render the bulleted paragraph.
4309     */
4310     bool BeginSymbolBullet(const wxString& symbol, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_SYMBOL);
4311
4312     /**
4313         Ends symbol bullet.
4314     */
4315     bool EndSymbolBullet() { return EndStyle(); }
4316
4317     /**
4318         Begins applying a standard bullet, using one of the standard bullet names
4319         (currently @c standard/circle or @c standard/square.
4320
4321         See BeginNumberedBullet() for an explanation of how indentation is used to
4322         render the bulleted paragraph.
4323     */
4324     bool BeginStandardBullet(const wxString& bulletName, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_STANDARD);
4325
4326     /**
4327         Ends standard bullet.
4328     */
4329     bool EndStandardBullet() { return EndStyle(); }
4330
4331     /**
4332         Begins named character style.
4333     */
4334     bool BeginCharacterStyle(const wxString& characterStyle);
4335
4336     /**
4337         Ends named character style.
4338     */
4339     bool EndCharacterStyle() { return EndStyle(); }
4340
4341     /**
4342         Begins named paragraph style.
4343     */
4344     bool BeginParagraphStyle(const wxString& paragraphStyle);
4345
4346     /**
4347         Ends named character style.
4348     */
4349     bool EndParagraphStyle() { return EndStyle(); }
4350
4351     /**
4352         Begins named list style.
4353
4354         Optionally, you can also pass a level and a number.
4355     */
4356     bool BeginListStyle(const wxString& listStyle, int level = 1, int number = 1);
4357
4358     /**
4359         Ends named character style.
4360     */
4361     bool EndListStyle() { return EndStyle(); }
4362
4363     /**
4364         Begins applying wxTEXT_ATTR_URL to the content.
4365
4366         Pass a URL and optionally, a character style to apply, since it is common
4367         to mark a URL with a familiar style such as blue text with underlining.
4368     */
4369     bool BeginURL(const wxString& url, const wxString& characterStyle = wxEmptyString);
4370
4371     /**
4372         Ends URL.
4373     */
4374     bool EndURL() { return EndStyle(); }
4375
4376 // Event handling
4377
4378     /**
4379         Adds an event handler.
4380
4381         A buffer associated with a control has the control as the only event handler,
4382         but the application is free to add more if further notification is required.
4383         All handlers are notified of an event originating from the buffer, such as
4384         the replacement of a style sheet during loading.
4385
4386         The buffer never deletes any of the event handlers, unless RemoveEventHandler()
4387         is called with @true as the second argument.
4388     */
4389     bool AddEventHandler(wxEvtHandler* handler);
4390
4391     /**
4392         Removes an event handler from the buffer's list of handlers, deleting the
4393         object if @a deleteHandler is @true.
4394     */
4395     bool RemoveEventHandler(wxEvtHandler* handler, bool deleteHandler = false);
4396
4397     /**
4398         Clear event handlers.
4399     */
4400     void ClearEventHandlers();
4401
4402     /**
4403         Send event to event handlers. If sendToAll is true, will send to all event handlers,
4404         otherwise will stop at the first successful one.
4405     */
4406     bool SendEvent(wxEvent& event, bool sendToAll = true);
4407
4408 // Implementation
4409
4410     virtual int HitTest(wxDC& dc, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags = 0);
4411
4412     /**
4413         Copies the buffer.
4414     */
4415     void Copy(const wxRichTextBuffer& obj);
4416
4417     /**
4418         Assignment operator.
4419     */
4420     void operator= (const wxRichTextBuffer& obj) { Copy(obj); }
4421
4422     /**
4423         Clones the buffer.
4424     */
4425     virtual wxRichTextObject* Clone() const { return new wxRichTextBuffer(*this); }
4426
4427     /**
4428         Submits a command to insert paragraphs.
4429     */
4430     bool InsertParagraphsWithUndo(wxRichTextCtrl* ctrl, long pos, const wxRichTextParagraphLayoutBox& paragraphs, int flags = 0);
4431
4432     /**
4433         Submits a command to insert the given text.
4434     */
4435     bool InsertTextWithUndo(long pos, const wxString& text, wxRichTextCtrl* ctrl, int flags = 0);
4436
4437     /**
4438         Submits a command to insert a newline.
4439     */
4440     bool InsertNewlineWithUndo(long pos, wxRichTextCtrl* ctrl, int flags = 0);
4441
4442     /**
4443         Submits a command to insert the given image.
4444     */
4445     bool InsertImageWithUndo(long pos, const wxRichTextImageBlock& imageBlock, wxRichTextCtrl* ctrl, int flags = 0,
4446             const wxRichTextAttr& textAttr = wxRichTextAttr());
4447
4448     /**
4449         Submits a command to insert an object.
4450     */
4451     wxRichTextObject* InsertObjectWithUndo(long pos, wxRichTextObject *object, wxRichTextCtrl* ctrl, int flags);
4452
4453     /**
4454         Submits a command to delete this range.
4455     */
4456     bool DeleteRangeWithUndo(const wxRichTextRange& range, wxRichTextCtrl* ctrl);
4457
4458     /**
4459         Mark modified.
4460     */
4461     void Modify(bool modify = true) { m_modified = modify; }
4462
4463     /**
4464         Returns @true if the buffer was modified.
4465     */
4466     bool IsModified() const { return m_modified; }
4467
4468     //@{
4469     /**
4470         Dumps contents of buffer for debugging purposes.
4471     */
4472     virtual void Dump();
4473     virtual void Dump(wxTextOutputStream& stream) { wxRichTextParagraphLayoutBox::Dump(stream); }
4474     //@}
4475
4476     /**
4477         Returns the file handlers.
4478     */
4479     static wxList& GetHandlers() { return sm_handlers; }
4480
4481     /**
4482         Adds a file handler to the end.
4483     */
4484     static void AddHandler(wxRichTextFileHandler *handler);
4485
4486     /**
4487         Inserts a file handler at the front.
4488     */
4489     static void InsertHandler(wxRichTextFileHandler *handler);
4490
4491     /**
4492         Removes a file handler.
4493     */
4494     static bool RemoveHandler(const wxString& name);
4495
4496     /**
4497         Finds a file handler by name.
4498     */
4499     static wxRichTextFileHandler *FindHandler(const wxString& name);
4500
4501     /**
4502         Finds a file handler by extension and type.
4503     */
4504     static wxRichTextFileHandler *FindHandler(const wxString& extension, wxRichTextFileType imageType);
4505
4506     /**
4507         Finds a handler by filename or, if supplied, type.
4508     */
4509     static wxRichTextFileHandler *FindHandlerFilenameOrType(const wxString& filename,
4510                                                             wxRichTextFileType imageType);
4511
4512     /**
4513         Finds a handler by type.
4514     */
4515     static wxRichTextFileHandler *FindHandler(wxRichTextFileType imageType);
4516
4517     /**
4518         Gets a wildcard incorporating all visible handlers. If @a types is present,
4519         it will be filled with the file type corresponding to each filter. This can be
4520         used to determine the type to pass to LoadFile given a selected filter.
4521     */
4522     static wxString GetExtWildcard(bool combine = false, bool save = false, wxArrayInt* types = NULL);
4523
4524     /**
4525         Clean up file handlers.
4526     */
4527     static void CleanUpHandlers();
4528
4529     /**
4530         Initialise the standard file handlers.
4531         Currently, only the plain text loading/saving handler is initialised by default.
4532     */
4533     static void InitStandardHandlers();
4534
4535     /**
4536         Returns the renderer object.
4537     */
4538     static wxRichTextRenderer* GetRenderer() { return sm_renderer; }
4539
4540     /**
4541         Sets @a renderer as the object to be used to render certain aspects of the
4542         content, such as bullets.
4543
4544         You can override default rendering by deriving a new class from
4545         wxRichTextRenderer or wxRichTextStdRenderer, overriding one or more
4546         virtual functions, and setting an instance of the class using this function.
4547     */
4548     static void SetRenderer(wxRichTextRenderer* renderer);
4549
4550     /**
4551         Returns the minimum margin between bullet and paragraph in 10ths of a mm.
4552     */
4553     static int GetBulletRightMargin() { return sm_bulletRightMargin; }
4554
4555     /**
4556         Sets the minimum margin between bullet and paragraph in 10ths of a mm.
4557     */
4558     static void SetBulletRightMargin(int margin) { sm_bulletRightMargin = margin; }
4559
4560     /**
4561         Returns the factor to multiply by character height to get a reasonable bullet size.
4562     */
4563     static float GetBulletProportion() { return sm_bulletProportion; }
4564
4565     /**
4566         Sets the factor to multiply by character height to get a reasonable bullet size.
4567     */
4568     static void SetBulletProportion(float prop) { sm_bulletProportion = prop; }
4569
4570     /**
4571         Returns the scale factor for calculating dimensions.
4572     */
4573     double GetScale() const { return m_scale; }
4574
4575     /**
4576         Sets the scale factor for calculating dimensions.
4577     */
4578     void SetScale(double scale) { m_scale = scale; }
4579
4580 protected:
4581
4582     /// Command processor
4583     wxCommandProcessor*     m_commandProcessor;
4584
4585     /// Table storing fonts
4586     wxRichTextFontTable     m_fontTable;
4587
4588     /// Has been modified?
4589     bool                    m_modified;
4590
4591     /// Collapsed command stack
4592     int                     m_batchedCommandDepth;
4593
4594     /// Name for collapsed command
4595     wxString                m_batchedCommandsName;
4596
4597     /// Current collapsed command accumulating actions
4598     wxRichTextCommand*      m_batchedCommand;
4599
4600     /// Whether to suppress undo
4601     int                     m_suppressUndo;
4602
4603     /// Style sheet, if any
4604     wxRichTextStyleSheet*   m_styleSheet;
4605
4606     /// List of event handlers that will be notified of events
4607     wxList                  m_eventHandlers;
4608
4609     /// Stack of attributes for convenience functions
4610     wxList                  m_attributeStack;
4611
4612     /// Flags to be passed to handlers
4613     int                     m_handlerFlags;
4614
4615     /// File handlers
4616     static wxList           sm_handlers;
4617
4618     /// Renderer
4619     static wxRichTextRenderer* sm_renderer;
4620
4621     /// Minimum margin between bullet and paragraph in 10ths of a mm
4622     static int              sm_bulletRightMargin;
4623
4624     /// Factor to multiply by character height to get a reasonable bullet size
4625     static float            sm_bulletProportion;
4626
4627     /// Scaling factor in use: needed to calculate correct dimensions when printing
4628     double                  m_scale;
4629 };
4630
4631 /**
4632     @class wxRichTextCell
4633
4634     wxRichTextCell is the cell in a table.
4635  */
4636
4637 class WXDLLIMPEXP_RICHTEXT wxRichTextCell: public wxRichTextBox
4638 {
4639     DECLARE_DYNAMIC_CLASS(wxRichTextCell)
4640 public:
4641 // Constructors
4642
4643     /**
4644         Default constructor; optionally pass the parent object.
4645     */
4646
4647     wxRichTextCell(wxRichTextObject* parent = NULL);
4648
4649     /**
4650         Copy constructor.
4651     */
4652
4653     wxRichTextCell(const wxRichTextCell& obj): wxRichTextBox() { Copy(obj); }
4654
4655 // Overridables
4656
4657     virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
4658
4659     virtual wxString GetXMLNodeName() const { return wxT("cell"); }
4660
4661     virtual bool CanEditProperties() const { return true; }
4662
4663     virtual bool EditProperties(wxWindow* parent, wxRichTextBuffer* buffer);
4664
4665     virtual wxString GetPropertiesMenuLabel() const { return _("&Cell"); }
4666
4667 // Accessors
4668
4669 // Operations
4670
4671     virtual wxRichTextObject* Clone() const { return new wxRichTextCell(*this); }
4672
4673     void Copy(const wxRichTextCell& obj);
4674
4675 protected:
4676 };
4677
4678 /**
4679     @class wxRichTextTable
4680
4681     wxRichTextTable represents a table with arbitrary columns and rows.
4682  */
4683
4684 WX_DEFINE_ARRAY_PTR(wxRichTextObject*, wxRichTextObjectPtrArray);
4685 WX_DECLARE_OBJARRAY(wxRichTextObjectPtrArray, wxRichTextObjectPtrArrayArray);
4686
4687 class WXDLLIMPEXP_RICHTEXT wxRichTextTable: public wxRichTextBox
4688 {
4689     DECLARE_DYNAMIC_CLASS(wxRichTextTable)
4690 public:
4691
4692 // Constructors
4693
4694     /**
4695         Default constructor; optionally pass the parent object.
4696     */
4697
4698     wxRichTextTable(wxRichTextObject* parent = NULL);
4699
4700     /**
4701         Copy constructor.
4702     */
4703
4704     wxRichTextTable(const wxRichTextTable& obj): wxRichTextBox() { Copy(obj); }
4705
4706 // Overridables
4707
4708     virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
4709
4710     virtual wxString GetXMLNodeName() const { return wxT("table"); }
4711
4712     virtual bool Layout(wxDC& dc, const wxRect& rect, const wxRect& parentRect, int style);
4713
4714     virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
4715
4716     virtual bool DeleteRange(const wxRichTextRange& range);
4717
4718     virtual wxString GetTextForRange(const wxRichTextRange& range) const;
4719
4720 #if wxUSE_XML
4721     virtual bool ImportFromXML(wxRichTextBuffer* buffer, wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse);
4722 #endif
4723
4724 #if wxRICHTEXT_HAVE_DIRECT_OUTPUT
4725     virtual bool ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler);
4726 #endif
4727
4728 #if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
4729     virtual bool ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler);
4730 #endif
4731
4732     virtual bool FindPosition(wxDC& dc, long index, wxPoint& pt, int* height, bool forceLineStart);
4733
4734     virtual void CalculateRange(long start, long& end);
4735
4736     // Can this object handle the selections of its children? FOr example, a table.
4737     virtual bool HandlesChildSelections() const { return true; }
4738
4739     /// Returns a selection object specifying the selections between start and end character positions.
4740     /// For example, a table would deduce what cells (of range length 1) are selected when dragging across the table.
4741     virtual wxRichTextSelection GetSelection(long start, long end) const;
4742
4743     virtual bool CanEditProperties() const { return true; }
4744
4745     virtual bool EditProperties(wxWindow* parent, wxRichTextBuffer* buffer);
4746
4747     virtual wxString GetPropertiesMenuLabel() const { return _("&Table"); }
4748
4749     // Returns true if objects of this class can accept the focus, i.e. a call to SetFocusObject
4750     // is possible. For example, containers supporting text, such as a text box object, can accept the focus,
4751     // but a table can't (set the focus to individual cells instead).
4752     virtual bool AcceptsFocus() const { return false; }
4753
4754 // Accessors
4755
4756     /**
4757         Returns the cells array.
4758     */
4759     const wxRichTextObjectPtrArrayArray& GetCells() const { return m_cells; }
4760
4761     /**
4762         Returns the cells array.
4763     */
4764     wxRichTextObjectPtrArrayArray& GetCells() { return m_cells; }
4765
4766     /**
4767         Returns the row count.
4768     */
4769     int GetRowCount() const { return m_rowCount; }
4770
4771     /**
4772         Returns the column count.
4773     */
4774     int GetColumnCount() const { return m_colCount; }
4775
4776     /**
4777         Returns the cell at the given row/column position.
4778     */
4779     virtual wxRichTextCell* GetCell(int row, int col) const;
4780
4781     /**
4782         Returns the cell at the given character position (in the range of the table).
4783     */
4784     virtual wxRichTextCell* GetCell(long pos) const;
4785
4786     /**
4787         Returns the row/column for a given character position.
4788     */
4789     virtual bool GetCellRowColumnPosition(long pos, int& row, int& col) const;
4790
4791 // Operations
4792
4793     /**
4794         Clears the table.
4795     */
4796
4797     virtual void ClearTable();
4798
4799     /**
4800         Creates a table of the given dimensions.
4801     */
4802
4803     virtual bool CreateTable(int rows, int cols);
4804
4805     /**
4806         Sets the attributes for the cells specified by the selection.
4807     */
4808
4809     virtual bool SetCellStyle(const wxRichTextSelection& selection, const wxRichTextAttr& style, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
4810
4811     /**
4812         Deletes rows from the given row position.
4813     */
4814
4815     virtual bool DeleteRows(int startRow, int noRows = 1);
4816
4817     /**
4818         Deletes columns from the given column position.
4819     */
4820
4821     virtual bool DeleteColumns(int startCol, int noCols = 1);
4822
4823     /**
4824         Adds rows from the given row position.
4825     */
4826
4827     virtual bool AddRows(int startRow, int noRows = 1, const wxRichTextAttr& attr = wxRichTextAttr());
4828
4829     /**
4830         Adds columns from the given column position.
4831     */
4832
4833     virtual bool AddColumns(int startCol, int noCols = 1, const wxRichTextAttr& attr = wxRichTextAttr());
4834
4835     // Makes a clone of this object.
4836     virtual wxRichTextObject* Clone() const { return new wxRichTextTable(*this); }
4837
4838     // Copies this object.
4839     void Copy(const wxRichTextTable& obj);
4840
4841 protected:
4842
4843     int m_rowCount;
4844     int m_colCount;
4845
4846     // An array of rows, each of which is a wxRichTextObjectPtrArray containing
4847     // the cell objects. The cell objects are also children of this object.
4848     // Problem: if boxes are immediate children of a box, this will cause problems
4849     // with wxRichTextParagraphLayoutBox functions (and functions elsewhere) that
4850     // expect to find just paragraphs. May have to adjust the way we handle the
4851     // hierarchy to accept non-paragraph objects in a paragraph layout box.
4852     // We'll be overriding much wxRichTextParagraphLayoutBox functionality so this
4853     // may not be such a problem. Perhaps the table should derive from a different
4854     // class?
4855     wxRichTextObjectPtrArrayArray   m_cells;
4856 };
4857
4858
4859 /**
4860     The command identifiers for Do/Undo.
4861 */
4862
4863 enum wxRichTextCommandId
4864 {
4865     wxRICHTEXT_INSERT,
4866     wxRICHTEXT_DELETE,
4867     wxRICHTEXT_CHANGE_ATTRIBUTES,
4868     wxRICHTEXT_CHANGE_STYLE,
4869     wxRICHTEXT_CHANGE_OBJECT
4870 };
4871
4872 /**
4873     @class wxRichTextObjectAddress
4874
4875     A class for specifying an object anywhere in an object hierarchy,
4876     without using a pointer, necessary since wxRTC commands may delete
4877     and recreate sub-objects so physical object addresses change. An array
4878     of positions (one per hierarchy level) is used.
4879
4880     @library{wxrichtext}
4881     @category{richtext}
4882
4883     @see wxRichTextCommand
4884 */
4885
4886 class WXDLLIMPEXP_RICHTEXT wxRichTextObjectAddress
4887 {
4888 public:
4889     /**
4890         Creates the address given a container and an object.
4891     */
4892     wxRichTextObjectAddress(wxRichTextParagraphLayoutBox* topLevelContainer, wxRichTextObject* obj) { Create(topLevelContainer, obj); }
4893     /**
4894     */
4895     wxRichTextObjectAddress() { Init(); }
4896     /**
4897     */
4898     wxRichTextObjectAddress(const wxRichTextObjectAddress& address) { Copy(address); }
4899
4900     void Init() {}
4901
4902     /**
4903         Copies the address.
4904     */
4905     void Copy(const wxRichTextObjectAddress& address) { m_address = address.m_address; }
4906
4907     /**
4908         Assignment operator.
4909     */
4910     void operator=(const wxRichTextObjectAddress& address) { Copy(address); }
4911
4912     /**
4913         Returns the object specified by the address, given a top level container.
4914     */
4915     wxRichTextObject* GetObject(wxRichTextParagraphLayoutBox* topLevelContainer) const;
4916
4917     /**
4918         Creates the address given a container and an object.
4919     */
4920     bool Create(wxRichTextParagraphLayoutBox* topLevelContainer, wxRichTextObject* obj);
4921
4922     /**
4923         Returns the array of integers representing the object address.
4924     */
4925     wxArrayInt& GetAddress() { return m_address; }
4926
4927     /**
4928         Returns the array of integers representing the object address.
4929     */
4930     const wxArrayInt& GetAddress() const { return m_address; }
4931
4932     /**
4933         Sets the address from an array of integers.
4934     */
4935     void SetAddress(const wxArrayInt& address) { m_address = address; }
4936
4937 protected:
4938
4939     wxArrayInt  m_address;
4940 };
4941
4942 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextAction;
4943
4944 /**
4945     @class wxRichTextCommand
4946
4947     Implements a command on the undo/redo stack. A wxRichTextCommand object contains one or more wxRichTextAction
4948     objects, allowing aggregation of a number of operations into one command.
4949
4950     @library{wxrichtext}
4951     @category{richtext}
4952
4953     @see wxRichTextAction
4954 */
4955
4956 class WXDLLIMPEXP_RICHTEXT wxRichTextCommand: public wxCommand
4957 {
4958 public:
4959     /**
4960         Constructor for one action.
4961     */
4962     wxRichTextCommand(const wxString& name, wxRichTextCommandId id, wxRichTextBuffer* buffer,
4963         wxRichTextParagraphLayoutBox* container, wxRichTextCtrl* ctrl, bool ignoreFirstTime = false);
4964
4965     /**
4966         Constructor for multiple actions.
4967     */
4968     wxRichTextCommand(const wxString& name);
4969
4970     virtual ~wxRichTextCommand();
4971
4972     /**
4973         Performs the command.
4974     */
4975     bool Do();
4976
4977     /**
4978         Undoes the command.
4979     */
4980     bool Undo();
4981
4982     /**
4983         Adds an action to the action list.
4984     */
4985     void AddAction(wxRichTextAction* action);
4986
4987     /**
4988         Clears the action list.
4989     */
4990     void ClearActions();
4991
4992     /**
4993         Returns the action list.
4994     */
4995     wxList& GetActions() { return m_actions; }
4996
4997 protected:
4998
4999     wxList  m_actions;
5000 };
5001
5002 /**
5003     @class wxRichTextAction
5004
5005     Implements a part of a command.
5006
5007     @library{wxrichtext}
5008     @category{richtext}
5009
5010     @see wxRichTextCommand
5011 */
5012
5013 class WXDLLIMPEXP_RICHTEXT wxRichTextAction: public wxObject
5014 {
5015 public:
5016     /**
5017         Constructor. @a buffer is the top-level buffer, while @a container is the object within
5018         which the action is taking place. In the simplest case, they are the same.
5019     */
5020     wxRichTextAction(wxRichTextCommand* cmd, const wxString& name, wxRichTextCommandId id,
5021         wxRichTextBuffer* buffer, wxRichTextParagraphLayoutBox* container,
5022         wxRichTextCtrl* ctrl, bool ignoreFirstTime = false);
5023
5024     virtual ~wxRichTextAction();
5025
5026     /**
5027         Performs the action.
5028     */
5029     bool Do();
5030
5031     /**
5032         Undoes the action.
5033     */
5034     bool Undo();
5035
5036     /**
5037         Updates the control appearance, optimizing if possible given information from the call to Layout.
5038     */
5039     void UpdateAppearance(long caretPosition, bool sendUpdateEvent = false,
5040                             wxArrayInt* optimizationLineCharPositions = NULL, wxArrayInt* optimizationLineYPositions = NULL, bool isDoCmd = true);
5041
5042     /**
5043         Replaces the buffer paragraphs with the given fragment.
5044     */
5045     void ApplyParagraphs(const wxRichTextParagraphLayoutBox& fragment);
5046
5047     /**
5048         Returns the new fragments.
5049     */
5050     wxRichTextParagraphLayoutBox& GetNewParagraphs() { return m_newParagraphs; }
5051
5052     /**
5053         Returns the old fragments.
5054     */
5055     wxRichTextParagraphLayoutBox& GetOldParagraphs() { return m_oldParagraphs; }
5056
5057     /**
5058         Returns the attributes, for single-object commands.
5059     */
5060     wxRichTextAttr& GetAttributes() { return m_attributes; }
5061
5062     /**
5063         Returns the object to replace the one at the position defined by the container address
5064         and the action's range start position.
5065     */
5066     wxRichTextObject* GetObject() const { return m_object; }
5067
5068     /**
5069         Sets the object to replace the one at the position defined by the container address
5070         and the action's range start position.
5071     */
5072     void SetObject(wxRichTextObject* obj) { m_object = obj; m_objectAddress.Create(m_buffer, m_object); }
5073
5074     /**
5075         Makes an address from the given object.
5076     */
5077     void MakeObject(wxRichTextObject* obj) { m_objectAddress.Create(m_buffer, obj); }
5078
5079     /**
5080         Calculate arrays for refresh optimization.
5081     */
5082     void CalculateRefreshOptimizations(wxArrayInt& optimizationLineCharPositions, wxArrayInt& optimizationLineYPositions);
5083
5084     /**
5085         Sets the position used for e.g. insertion.
5086     */
5087     void SetPosition(long pos) { m_position = pos; }
5088
5089     /**
5090         Returns the position used for e.g. insertion.
5091     */
5092     long GetPosition() const { return m_position; }
5093
5094     /**
5095         Sets the range for e.g. deletion.
5096     */
5097     void SetRange(const wxRichTextRange& range) { m_range = range; }
5098
5099     /**
5100         Returns the range for e.g. deletion.
5101     */
5102     const wxRichTextRange& GetRange() const { return m_range; }
5103
5104     /**
5105         Returns the address (nested position) of the container within the buffer being manipulated.
5106     */
5107     wxRichTextObjectAddress& GetContainerAddress() { return m_containerAddress; }
5108
5109     /**
5110         Returns the address (nested position) of the container within the buffer being manipulated.
5111     */
5112     const wxRichTextObjectAddress& GetContainerAddress() const { return m_containerAddress; }
5113
5114     /**
5115         Sets the address (nested position) of the container within the buffer being manipulated.
5116     */
5117     void SetContainerAddress(const wxRichTextObjectAddress& address) { m_containerAddress = address; }
5118
5119     /**
5120         Sets the address (nested position) of the container within the buffer being manipulated.
5121     */
5122     void SetContainerAddress(wxRichTextParagraphLayoutBox* container, wxRichTextObject* obj) { m_containerAddress.Create(container, obj); }
5123
5124     /**
5125         Returns the container that this action refers to, using the container address and top-level buffer.
5126     */
5127     wxRichTextParagraphLayoutBox* GetContainer() const;
5128
5129     /**
5130         Returns the action name.
5131     */
5132     const wxString& GetName() const { return m_name; }
5133
5134 protected:
5135     // Action name
5136     wxString                        m_name;
5137
5138     // Buffer
5139     wxRichTextBuffer*               m_buffer;
5140
5141     // The address (nested position) of the container being manipulated.
5142     // This is necessary because objects are deleted, and we can't
5143     // therefore store actual pointers.
5144     wxRichTextObjectAddress         m_containerAddress;
5145
5146     // Control
5147     wxRichTextCtrl*                 m_ctrl;
5148
5149     // Stores the new paragraphs
5150     wxRichTextParagraphLayoutBox    m_newParagraphs;
5151
5152     // Stores the old paragraphs
5153     wxRichTextParagraphLayoutBox    m_oldParagraphs;
5154
5155     // Stores an object to replace the one at the position
5156     // defined by the container address and the action's range start position.
5157     wxRichTextObject*               m_object;
5158
5159     // Stores the attributes
5160     wxRichTextAttr                  m_attributes;
5161
5162     // The address of the object being manipulated (used for changing an individual object or its attributes)
5163     wxRichTextObjectAddress         m_objectAddress;
5164
5165     // Stores the old attributes
5166     // wxRichTextAttr                  m_oldAttributes;
5167
5168     // The affected range
5169     wxRichTextRange                 m_range;
5170
5171     // The insertion point for this command
5172     long                            m_position;
5173
5174     // Ignore 1st 'Do' operation because we already did it
5175     bool                            m_ignoreThis;
5176
5177     // The command identifier
5178     wxRichTextCommandId             m_cmdId;
5179 };
5180
5181 /*!
5182  * Handler flags
5183  */
5184
5185 // Include style sheet when loading and saving
5186 #define wxRICHTEXT_HANDLER_INCLUDE_STYLESHEET       0x0001
5187
5188 // Save images to memory file system in HTML handler
5189 #define wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_MEMORY    0x0010
5190
5191 // Save images to files in HTML handler
5192 #define wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_FILES     0x0020
5193
5194 // Save images as inline base64 data in HTML handler
5195 #define wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_BASE64    0x0040
5196
5197 // Don't write header and footer (or BODY), so we can include the fragment
5198 // in a larger document
5199 #define wxRICHTEXT_HANDLER_NO_HEADER_FOOTER         0x0080
5200
5201 // Convert the more common face names to names that will work on the current platform
5202 // in a larger document
5203 #define wxRICHTEXT_HANDLER_CONVERT_FACENAMES        0x0100
5204
5205 /**
5206     @class wxRichTextFileHandler
5207
5208     The base class for file handlers.
5209
5210     @library{wxrichtext}
5211     @category{richtext}
5212
5213     @see wxRichTextBuffer, wxRichTextCtrl
5214 */
5215
5216 class WXDLLIMPEXP_RICHTEXT wxRichTextFileHandler: public wxObject
5217 {
5218     DECLARE_CLASS(wxRichTextFileHandler)
5219 public:
5220     /**
5221         Creates a file handler object.
5222     */
5223     wxRichTextFileHandler(const wxString& name = wxEmptyString, const wxString& ext = wxEmptyString, int type = 0)
5224         : m_name(name), m_extension(ext), m_type(type), m_flags(0), m_visible(true)
5225         { }
5226
5227 #if wxUSE_STREAMS
5228     /**
5229         Loads the buffer from a stream.
5230         Not all handlers will implement file loading.
5231     */
5232     bool LoadFile(wxRichTextBuffer *buffer, wxInputStream& stream)
5233     { return DoLoadFile(buffer, stream); }
5234
5235     /**
5236         Saves the buffer to a stream.
5237         Not all handlers will implement file saving.
5238     */
5239     bool SaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream)
5240     { return DoSaveFile(buffer, stream); }
5241 #endif
5242
5243 #if wxUSE_FFILE && wxUSE_STREAMS
5244     /**
5245         Loads the buffer from a file.
5246     */
5247     virtual bool LoadFile(wxRichTextBuffer *buffer, const wxString& filename);
5248
5249     /**
5250         Saves the buffer to a file.
5251     */
5252     virtual bool SaveFile(wxRichTextBuffer *buffer, const wxString& filename);
5253 #endif // wxUSE_STREAMS && wxUSE_STREAMS
5254
5255     /**
5256         Returns @true if we handle this filename (if using files). By default, checks the extension.
5257     */
5258     virtual bool CanHandle(const wxString& filename) const;
5259
5260     /**
5261         Returns @true if we can save using this handler.
5262     */
5263     virtual bool CanSave() const { return false; }
5264
5265     /**
5266         Returns @true if we can load using this handler.
5267     */
5268     virtual bool CanLoad() const { return false; }
5269
5270     /**
5271         Returns @true if this handler should be visible to the user.
5272     */
5273     virtual bool IsVisible() const { return m_visible; }
5274
5275     /**
5276         Sets whether the handler should be visible to the user (via the application's
5277         load and save dialogs).
5278     */
5279     virtual void SetVisible(bool visible) { m_visible = visible; }
5280
5281     /**
5282         Sets the name of the nandler.
5283     */
5284     void SetName(const wxString& name) { m_name = name; }
5285
5286     /**
5287         Returns the name of the nandler.
5288     */
5289     wxString GetName() const { return m_name; }
5290
5291     /**
5292         Sets the default extension to recognise.
5293     */
5294     void SetExtension(const wxString& ext) { m_extension = ext; }
5295
5296     /**
5297         Returns the default extension to recognise.
5298     */
5299     wxString GetExtension() const { return m_extension; }
5300
5301     /**
5302         Sets the handler type.
5303     */
5304     void SetType(int type) { m_type = type; }
5305
5306     /**
5307         Returns the handler type.
5308     */
5309     int GetType() const { return m_type; }
5310
5311     /**
5312         Sets flags that change the behaviour of loading or saving.
5313         See the documentation for each handler class to see what flags are relevant
5314         for each handler.
5315
5316         You call this function directly if you are using a file handler explicitly
5317         (without going through the text control or buffer LoadFile/SaveFile API).
5318         Or, you can call the control or buffer's SetHandlerFlags function to set
5319         the flags that will be used for subsequent load and save operations.
5320     */
5321     void SetFlags(int flags) { m_flags = flags; }
5322
5323     /**
5324         Returns flags controlling how loading and saving is done.
5325     */
5326     int GetFlags() const { return m_flags; }
5327
5328     /**
5329         Sets the encoding to use when saving a file. If empty, a suitable encoding is chosen.
5330     */
5331     void SetEncoding(const wxString& encoding) { m_encoding = encoding; }
5332
5333     /**
5334         Returns the encoding to use when saving a file. If empty, a suitable encoding is chosen.
5335     */
5336     const wxString& GetEncoding() const { return m_encoding; }
5337
5338 protected:
5339
5340 #if wxUSE_STREAMS
5341     /**
5342         Override to load content from @a stream into @a buffer.
5343     */
5344     virtual bool DoLoadFile(wxRichTextBuffer *buffer, wxInputStream& stream) = 0;
5345
5346     /**
5347         Override to save content to @a stream from @a buffer.
5348     */
5349     virtual bool DoSaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream) = 0;
5350 #endif
5351
5352     wxString  m_name;
5353     wxString  m_encoding;
5354     wxString  m_extension;
5355     int       m_type;
5356     int       m_flags;
5357     bool      m_visible;
5358 };
5359
5360 /**
5361     @class wxRichTextPlainTextHandler
5362
5363     Implements saving a buffer to plain text.
5364
5365     @library{wxrichtext}
5366     @category{richtext}
5367
5368     @see wxRichTextFileHandler, wxRichTextBuffer, wxRichTextCtrl
5369 */
5370
5371 class WXDLLIMPEXP_RICHTEXT wxRichTextPlainTextHandler: public wxRichTextFileHandler
5372 {
5373     DECLARE_CLASS(wxRichTextPlainTextHandler)
5374 public:
5375     wxRichTextPlainTextHandler(const wxString& name = wxT("Text"),
5376                                const wxString& ext = wxT("txt"),
5377                                wxRichTextFileType type = wxRICHTEXT_TYPE_TEXT)
5378         : wxRichTextFileHandler(name, ext, type)
5379         { }
5380
5381     // Can we save using this handler?
5382     virtual bool CanSave() const { return true; }
5383
5384     // Can we load using this handler?
5385     virtual bool CanLoad() const { return true; }
5386
5387 protected:
5388
5389 #if wxUSE_STREAMS
5390     virtual bool DoLoadFile(wxRichTextBuffer *buffer, wxInputStream& stream);
5391     virtual bool DoSaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream);
5392 #endif
5393
5394 };
5395
5396 #if wxUSE_DATAOBJ
5397
5398 /**
5399     @class wxRichTextBufferDataObject
5400
5401     Implements a rich text data object for clipboard transfer.
5402
5403     @library{wxrichtext}
5404     @category{richtext}
5405
5406     @see wxDataObjectSimple, wxRichTextBuffer, wxRichTextCtrl
5407 */
5408
5409 class WXDLLIMPEXP_RICHTEXT wxRichTextBufferDataObject: public wxDataObjectSimple
5410 {
5411 public:
5412     /**
5413         The constructor doesn't copy the pointer, so it shouldn't go away while this object
5414         is alive.
5415     */
5416     wxRichTextBufferDataObject(wxRichTextBuffer* richTextBuffer = NULL);
5417     virtual ~wxRichTextBufferDataObject();
5418
5419     /**
5420         After a call to this function, the buffer is owned by the caller and it
5421         is responsible for deleting it.
5422     */
5423     wxRichTextBuffer* GetRichTextBuffer();
5424
5425     /**
5426         Returns the id for the new data format.
5427     */
5428     static const wxChar* GetRichTextBufferFormatId() { return ms_richTextBufferFormatId; }
5429
5430     // base class pure virtuals
5431
5432     virtual wxDataFormat GetPreferredFormat(Direction dir) const;
5433     virtual size_t GetDataSize() const;
5434     virtual bool GetDataHere(void *pBuf) const;
5435     virtual bool SetData(size_t len, const void *buf);
5436
5437     // prevent warnings
5438
5439     virtual size_t GetDataSize(const wxDataFormat&) const { return GetDataSize(); }
5440     virtual bool GetDataHere(const wxDataFormat&, void *buf) const { return GetDataHere(buf); }
5441     virtual bool SetData(const wxDataFormat&, size_t len, const void *buf) { return SetData(len, buf); }
5442
5443 private:
5444     wxDataFormat            m_formatRichTextBuffer;     // our custom format
5445     wxRichTextBuffer*       m_richTextBuffer;           // our data
5446     static const wxChar*    ms_richTextBufferFormatId;  // our format id
5447 };
5448
5449 #endif
5450
5451 /**
5452     @class wxRichTextRenderer
5453
5454     This class isolates some common drawing functionality.
5455
5456     @library{wxrichtext}
5457     @category{richtext}
5458
5459     @see wxRichTextBuffer, wxRichTextCtrl
5460 */
5461
5462 class WXDLLIMPEXP_RICHTEXT wxRichTextRenderer: public wxObject
5463 {
5464 public:
5465     /**
5466         Constructor.
5467     */
5468     wxRichTextRenderer() {}
5469     virtual ~wxRichTextRenderer() {}
5470
5471     /**
5472         Draws a standard bullet, as specified by the value of GetBulletName. This function should be overridden.
5473     */
5474     virtual bool DrawStandardBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect) = 0;
5475
5476     /**
5477         Draws a bullet that can be described by text, such as numbered or symbol bullets. This function should be overridden.
5478     */
5479     virtual bool DrawTextBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect, const wxString& text) = 0;
5480
5481     /**
5482         Draws a bitmap bullet, where the bullet bitmap is specified by the value of GetBulletName. This function should be overridden.
5483     */
5484     virtual bool DrawBitmapBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect) = 0;
5485
5486     /**
5487         Enumerate the standard bullet names currently supported. This function should be overridden.
5488     */
5489     virtual bool EnumerateStandardBulletNames(wxArrayString& bulletNames) = 0;
5490 };
5491
5492 /**
5493     @class wxRichTextStdRenderer
5494
5495     The standard renderer for drawing bullets.
5496
5497     @library{wxrichtext}
5498     @category{richtext}
5499
5500     @see wxRichTextRenderer, wxRichTextBuffer, wxRichTextCtrl
5501 */
5502
5503 class WXDLLIMPEXP_RICHTEXT wxRichTextStdRenderer: public wxRichTextRenderer
5504 {
5505 public:
5506     /**
5507         Constructor.
5508     */
5509     wxRichTextStdRenderer() {}
5510
5511     // Draw a standard bullet, as specified by the value of GetBulletName
5512     virtual bool DrawStandardBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect);
5513
5514     // Draw a bullet that can be described by text, such as numbered or symbol bullets
5515     virtual bool DrawTextBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect, const wxString& text);
5516
5517     // Draw a bitmap bullet, where the bullet bitmap is specified by the value of GetBulletName
5518     virtual bool DrawBitmapBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect);
5519
5520     // Enumerate the standard bullet names currently supported
5521     virtual bool EnumerateStandardBulletNames(wxArrayString& bulletNames);
5522 };
5523
5524 /*!
5525  * Utilities
5526  *
5527  */
5528
5529 inline bool wxRichTextHasStyle(int flags, int style)
5530 {
5531     return ((flags & style) == style);
5532 }
5533
5534 /// Compare two attribute objects
5535 WXDLLIMPEXP_RICHTEXT bool wxTextAttrEq(const wxRichTextAttr& attr1, const wxRichTextAttr& attr2);
5536 WXDLLIMPEXP_RICHTEXT bool wxTextAttrEq(const wxRichTextAttr& attr1, const wxRichTextAttr& attr2);
5537
5538 /// Compare two attribute objects, but take into account the flags
5539 /// specifying attributes of interest.
5540 WXDLLIMPEXP_RICHTEXT bool wxTextAttrEqPartial(const wxRichTextAttr& attr1, const wxRichTextAttr& attr2);
5541
5542 /// Apply one style to another
5543 WXDLLIMPEXP_RICHTEXT bool wxRichTextApplyStyle(wxRichTextAttr& destStyle, const wxRichTextAttr& style, wxRichTextAttr* compareWith = NULL);
5544
5545 // Remove attributes
5546 WXDLLIMPEXP_RICHTEXT bool wxRichTextRemoveStyle(wxRichTextAttr& destStyle, const wxRichTextAttr& style);
5547
5548 /// Combine two bitlists
5549 WXDLLIMPEXP_RICHTEXT bool wxRichTextCombineBitlists(int& valueA, int valueB, int& flagsA, int flagsB);
5550
5551 /// Compare two bitlists
5552 WXDLLIMPEXP_RICHTEXT bool wxRichTextBitlistsEqPartial(int valueA, int valueB, int flags);
5553
5554 /// Split into paragraph and character styles
5555 WXDLLIMPEXP_RICHTEXT bool wxRichTextSplitParaCharStyles(const wxRichTextAttr& style, wxRichTextAttr& parStyle, wxRichTextAttr& charStyle);
5556
5557 /// Compare tabs
5558 WXDLLIMPEXP_RICHTEXT bool wxRichTextTabsEq(const wxArrayInt& tabs1, const wxArrayInt& tabs2);
5559
5560 /// Convert a decimal to Roman numerals
5561 WXDLLIMPEXP_RICHTEXT wxString wxRichTextDecimalToRoman(long n);
5562
5563 // Collects the attributes that are common to a range of content, building up a note of
5564 // which attributes are absent in some objects and which clash in some objects.
5565 WXDLLIMPEXP_RICHTEXT void wxTextAttrCollectCommonAttributes(wxTextAttr& currentStyle, const wxTextAttr& attr, wxTextAttr& clashingAttr, wxTextAttr& absentAttr);
5566
5567 WXDLLIMPEXP_RICHTEXT void wxRichTextModuleInit();