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