src/richtext/richtextbuffer.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/richtext/richtextbuffer.cpp
   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 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16     #pragma hdrstop
  17 #endif
  18
  19 #if wxUSE_RICHTEXT
  20
  21 #include "wx/richtext/richtextbuffer.h"
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/dc.h"
  25     #include "wx/intl.h"
  26     #include "wx/log.h"
  27     #include "wx/dataobj.h"
  28     #include "wx/module.h"
  29 #endif
  30
  31 #include "wx/settings.h"
  32 #include "wx/filename.h"
  33 #include "wx/clipbrd.h"
  34 #include "wx/wfstream.h"
  35 #include "wx/mstream.h"
  36 #include "wx/sstream.h"
  37 #include "wx/textfile.h"
  38 #include "wx/hashmap.h"
  39 #include "wx/dynarray.h"
  40
  41 #include "wx/richtext/richtextctrl.h"
  42 #include "wx/richtext/richtextstyles.h"
  43 #include "wx/richtext/richtextimagedlg.h"
  44
  45 #include "wx/listimpl.cpp"
  46
  47 WX_DEFINE_LIST(wxRichTextObjectList)
  48 WX_DEFINE_LIST(wxRichTextLineList)
  49
  50 // Switch off if the platform doesn't like it for some reason
  51 #define wxRICHTEXT_USE_OPTIMIZED_DRAWING 1
  52
  53 // Use GetPartialTextExtents for platforms that support it natively
  54 #define wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS 1
  55
  56 const wxChar wxRichTextLineBreakChar = (wxChar) 29;
  57
  58 // Helper classes for floating layout
  59 struct wxRichTextFloatRectMap
  60 {
  61     wxRichTextFloatRectMap(int sY, int eY, int w, wxRichTextObject* obj)
  62     {
  63         startY = sY;
  64         endY = eY;
  65         width = w;
  66         anchor = obj;
  67     }
  68
  69     int startY, endY;
  70     int width;
  71     wxRichTextObject* anchor;
  72 };
  73
  74 WX_DEFINE_SORTED_ARRAY(wxRichTextFloatRectMap*, wxRichTextFloatRectMapArray);
  75
  76 int wxRichTextFloatRectMapCmp(wxRichTextFloatRectMap* r1, wxRichTextFloatRectMap* r2)
  77 {
  78     return r1->startY - r2->startY;
  79 }
  80
  81 class wxRichTextFloatCollector
  82 {
  83 public:
  84     wxRichTextFloatCollector(int width);
  85     ~wxRichTextFloatCollector();
  86
  87     // Collect the floating objects info in the given paragraph
  88     void CollectFloat(wxRichTextParagraph* para);
  89     void CollectFloat(wxRichTextParagraph* para, wxRichTextObject* floating);
  90
  91     // Return the last paragraph we collected
  92     wxRichTextParagraph* LastParagraph();
  93
  94     // Given the start y position and the height of the line,
  95     // find out how wide the line can be
  96     wxRect GetAvailableRect(int startY, int endY);
  97
  98     // Given a floating box, find its fit position
  99     int GetFitPosition(int direction, int start, int height) const;
 100     int GetFitPosition(const wxRichTextFloatRectMapArray& array, int start, int height) const;
 101
 102     // Find the last y position
 103     int GetLastRectBottom();
 104
 105     // Draw the floats inside a rect
 106     void Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style);
 107
 108     // HitTest the floats
 109     int HitTest(wxDC& dc, const wxPoint& pt, long& textPosition);
 110
 111     static int SearchAdjacentRect(const wxRichTextFloatRectMapArray& array, int point);
 112
 113     static int GetWidthFromFloatRect(const wxRichTextFloatRectMapArray& array, int index, int startY, int endY);
 114
 115     static void FreeFloatRectMapArray(wxRichTextFloatRectMapArray& array);
 116
 117     static void DrawFloat(const wxRichTextFloatRectMapArray& array, wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style);
 118
 119     static int HitTestFloat(const wxRichTextFloatRectMapArray& array, wxDC& WXUNUSED(dc), const wxPoint& pt, long& textPosition);
 120
 121 private:
 122     wxRichTextFloatRectMapArray m_left;
 123     wxRichTextFloatRectMapArray m_right;
 124     int m_width;
 125     wxRichTextParagraph* m_para;
 126 };
 127
 128 /*
 129  * Binary search helper function
 130  * The argument point is the Y coordinate, and this fuction
 131  * always return the floating rect that contain this coordinate
 132  * or under this coordinate.
 133  */
 134 int wxRichTextFloatCollector::SearchAdjacentRect(const wxRichTextFloatRectMapArray& array, int point)
 135 {
 136     int end = array.GetCount() - 1;
 137     int start = 0;
 138     int ret = 0;
 139
 140     wxASSERT(end >= 0);
 141
 142     while (true)
 143     {
 144         if (start > end)
 145         {
 146             break;
 147         }
 148
 149         int mid = (start + end) / 2;
 150         if (array[mid]->startY <= point && array[mid]->endY >= point)
 151             return mid;
 152         else if (array[mid]->startY > point)
 153         {
 154             end = mid - 1;
 155             ret = mid;
 156         }
 157         else if (array[mid]->endY < point)
 158         {
 159             start = mid + 1;
 160             ret = start;
 161         }
 162     }
 163
 164     return ret;
 165 }
 166
 167 int wxRichTextFloatCollector::GetWidthFromFloatRect(const wxRichTextFloatRectMapArray& array, int index, int startY, int endY)
 168 {
 169     int ret = 0;
 170     int len = array.GetCount();
 171
 172     wxASSERT(index >= 0 && index < len);
 173
 174     if (array[index]->startY < startY && array[index]->endY > startY)
 175         ret = ret < array[index]->width ? array[index]->width : ret;
 176     while (index < len && array[index]->startY <= endY)
 177     {
 178         ret = ret < array[index]->width ? array[index]->width : ret;
 179         index++;
 180     }
 181
 182     return ret;
 183 }
 184
 185 wxRichTextFloatCollector::wxRichTextFloatCollector(int width) : m_left(wxRichTextFloatRectMapCmp), m_right(wxRichTextFloatRectMapCmp)
 186 {
 187     m_width = width;
 188     m_para = NULL;
 189 }
 190
 191 void wxRichTextFloatCollector::FreeFloatRectMapArray(wxRichTextFloatRectMapArray& array)
 192 {
 193     int len = array.GetCount();
 194     for (int i = 0; i < len; i++)
 195         delete array[i];
 196 }
 197
 198 wxRichTextFloatCollector::~wxRichTextFloatCollector()
 199 {
 200     FreeFloatRectMapArray(m_left);
 201     FreeFloatRectMapArray(m_right);
 202 }
 203
 204 int wxRichTextFloatCollector::GetFitPosition(const wxRichTextFloatRectMapArray& array, int start, int height) const
 205 {
 206     if (array.GetCount() == 0)
 207         return start;
 208
 209     unsigned int i = SearchAdjacentRect(array, start);
 210     int last = start;
 211     while (i < array.GetCount())
 212     {
 213         if (array[i]->startY - last >= height)
 214             return last + 1;
 215         last = array[i]->endY;
 216         i++;
 217     }
 218
 219     return last + 1;
 220 }
 221
 222 int wxRichTextFloatCollector::GetFitPosition(int direction, int start, int height) const
 223 {
 224     if (direction == wxTEXT_BOX_ATTR_FLOAT_LEFT)
 225         return GetFitPosition(m_left, start, height);
 226     else if (direction == wxTEXT_BOX_ATTR_FLOAT_RIGHT)
 227         return GetFitPosition(m_right, start, height);
 228     else
 229     {
 230         wxASSERT("Never should be here");
 231         return start;
 232     }
 233 }
 234
 235 void wxRichTextFloatCollector::CollectFloat(wxRichTextParagraph* para, wxRichTextObject* floating)
 236 {
 237         int direction = floating->GetFloatDirection();
 238
 239         wxPoint pos = floating->GetPosition();
 240         wxSize size = floating->GetCachedSize();
 241         wxRichTextFloatRectMap *map = new wxRichTextFloatRectMap(pos.y, pos.y + size.y, size.x, floating);
 242         switch (direction)
 243         {
 244             case wxTEXT_BOX_ATTR_FLOAT_NONE:
 245                 delete map;
 246                 break;
 247             case wxTEXT_BOX_ATTR_FLOAT_LEFT:
 248                 // Just a not-enough simple assertion
 249                 wxASSERT (m_left.Index(map) == wxNOT_FOUND);
 250                 m_left.Add(map);
 251                 break;
 252             case wxTEXT_BOX_ATTR_FLOAT_RIGHT:
 253                 wxASSERT (m_right.Index(map) == wxNOT_FOUND);
 254                 m_right.Add(map);
 255                 break;
 256             default:
 257                 delete map;
 258                 wxASSERT("Must some error occurs");
 259         }
 260
 261         m_para = para;
 262 }
 263
 264 void wxRichTextFloatCollector::CollectFloat(wxRichTextParagraph* para)
 265 {
 266     wxRichTextObjectList::compatibility_iterator node = para->GetChildren().GetFirst();
 267     while (node)
 268     {
 269         wxRichTextObject* floating = node->GetData();
 270
 271         if (floating->IsFloating())
 272         {
 273             wxRichTextAnchoredObject* anchor = wxDynamicCast(floating, wxRichTextAnchoredObject);
 274             if (anchor)
 275             {
 276                 CollectFloat(para, floating);
 277             }
 278         }
 279
 280         node = node->GetNext();
 281     }
 282
 283     m_para = para;
 284 }
 285
 286 wxRichTextParagraph* wxRichTextFloatCollector::LastParagraph()
 287 {
 288     return m_para;
 289 }
 290
 291 wxRect wxRichTextFloatCollector::GetAvailableRect(int startY, int endY)
 292 {
 293     int widthLeft = 0, widthRight = 0;
 294     if (m_left.GetCount() != 0)
 295     {
 296         unsigned int i = SearchAdjacentRect(m_left, startY);
 297         if (i >= 0 && i < m_left.GetCount())
 298             widthLeft = GetWidthFromFloatRect(m_left, i, startY, endY);
 299     }
 300     if (m_right.GetCount() != 0)
 301     {
 302         unsigned int j = SearchAdjacentRect(m_right, startY);
 303         if (j >= 0 && j < m_right.GetCount())
 304             widthRight = GetWidthFromFloatRect(m_right, j, startY, endY);
 305     }
 306
 307     return wxRect(widthLeft, 0, m_width - widthLeft - widthRight, 0);
 308 }
 309
 310 int wxRichTextFloatCollector::GetLastRectBottom()
 311 {
 312     int ret = 0;
 313     int len = m_left.GetCount();
 314     if (len) {
 315         ret = ret > m_left[len-1]->endY ? ret : m_left[len-1]->endY;
 316     }
 317     len = m_right.GetCount();
 318     if (len) {
 319         ret = ret > m_right[len-1]->endY ? ret : m_right[len-1]->endY;
 320     }
 321
 322     return ret;
 323 }
 324
 325 void wxRichTextFloatCollector::DrawFloat(const wxRichTextFloatRectMapArray& array, wxDC& dc, const wxRichTextRange& WXUNUSED(range), const wxRichTextRange& WXUNUSED(selectionRange), const wxRect& rect, int descent, int style)
 326 {
 327     int start = rect.y;
 328     int end = rect.y + rect.height;
 329     unsigned int i, j;
 330     i = SearchAdjacentRect(array, start);
 331     if (i < 0 || i >= array.GetCount())
 332         return;
 333     j = SearchAdjacentRect(array, end);
 334     if (j < 0 || j >= array.GetCount())
 335         j = array.GetCount() - 1;
 336     while (i <= j)
 337     {
 338         wxRichTextObject* obj = array[i]->anchor;
 339         wxRichTextRange r = obj->GetRange();
 340         obj->Draw(dc, r, wxRichTextRange(0, -1), wxRect(obj->GetPosition(), obj->GetCachedSize()), descent, style);
 341         i++;
 342     }
 343 }
 344
 345 void wxRichTextFloatCollector::Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style)
 346 {
 347     if (m_left.GetCount() > 0)
 348         DrawFloat(m_left, dc, range, selectionRange, rect, descent, style);
 349     if (m_right.GetCount() > 0)
 350         DrawFloat(m_right, dc, range, selectionRange, rect, descent, style);
 351 }
 352
 353 int wxRichTextFloatCollector::HitTestFloat(const wxRichTextFloatRectMapArray& array, wxDC& WXUNUSED(dc), const wxPoint& pt, long& textPosition)
 354 {
 355     unsigned int i;
 356     if (array.GetCount() == 0)
 357         return wxRICHTEXT_HITTEST_NONE;
 358     i = SearchAdjacentRect(array, pt.y);
 359     if (i < 0 || i >= array.GetCount())
 360         return wxRICHTEXT_HITTEST_NONE;
 361     wxPoint point = array[i]->anchor->GetPosition();
 362     wxSize size = array[i]->anchor->GetCachedSize();
 363     if (point.x <= pt.x && point.x + size.x >= pt.x
 364         && point.y <= pt.y && point.y + size.y >= pt.y)
 365     {
 366         textPosition = array[i]->anchor->GetRange().GetStart();
 367         if (pt.x > (pt.x + pt.x + size.x) / 2)
 368             return wxRICHTEXT_HITTEST_BEFORE;
 369         else
 370             return wxRICHTEXT_HITTEST_AFTER;
 371     }
 372
 373     return wxRICHTEXT_HITTEST_NONE;
 374 }
 375
 376 int wxRichTextFloatCollector::HitTest(wxDC& dc, const wxPoint& pt, long& textPosition)
 377 {
 378     int ret = HitTestFloat(m_left, dc, pt, textPosition);
 379     if (ret == wxRICHTEXT_HITTEST_NONE)
 380     {
 381         ret = HitTestFloat(m_right, dc, pt, textPosition);
 382     }
 383     return ret;
 384 }
 385
 386 // Helpers for efficiency
 387 inline void wxCheckSetFont(wxDC& dc, const wxFont& font)
 388 {
 389     // JACS: did I do this some time ago when testing? Should we re-enable it?
 390 #if 0
 391     const wxFont& font1 = dc.GetFont();
 392     if (font1.IsOk() && font.IsOk())
 393     {
 394         if (font1.GetPointSize() == font.GetPointSize() &&
 395             font1.GetFamily() == font.GetFamily() &&
 396             font1.GetStyle() == font.GetStyle() &&
 397             font1.GetWeight() == font.GetWeight() &&
 398             font1.GetUnderlined() == font.GetUnderlined() &&
 399             font1.GetFamily() == font.GetFamily() &&
 400             font1.GetFaceName() == font.GetFaceName())
 401             return;
 402     }
 403 #endif
 404     dc.SetFont(font);
 405 }
 406
 407 inline void wxCheckSetPen(wxDC& dc, const wxPen& pen)
 408 {
 409     const wxPen& pen1 = dc.GetPen();
 410     if (pen1.IsOk() && pen.IsOk())
 411     {
 412         if (pen1.GetWidth() == pen.GetWidth() &&
 413             pen1.GetStyle() == pen.GetStyle() &&
 414             pen1.GetColour() == pen.GetColour())
 415             return;
 416     }
 417     dc.SetPen(pen);
 418 }
 419
 420 inline void wxCheckSetBrush(wxDC& dc, const wxBrush& brush)
 421 {
 422     const wxBrush& brush1 = dc.GetBrush();
 423     if (brush1.IsOk() && brush.IsOk())
 424     {
 425         if (brush1.GetStyle() == brush.GetStyle() &&
 426             brush1.GetColour() == brush.GetColour())
 427             return;
 428     }
 429     dc.SetBrush(brush);
 430 }
 431
 432 /*!
 433  * wxRichTextObject
 434  * This is the base for drawable objects.
 435  */
 436
 437 IMPLEMENT_CLASS(wxRichTextObject, wxObject)
 438
 439 wxRichTextObject::wxRichTextObject(wxRichTextObject* parent)
 440 {
 441     m_dirty = false;
 442     m_refCount = 1;
 443     m_parent = parent;
 444     m_leftMargin = 0;
 445     m_rightMargin = 0;
 446     m_topMargin = 0;
 447     m_bottomMargin = 0;
 448     m_descent = 0;
 449 }
 450
 451 wxRichTextObject::~wxRichTextObject()
 452 {
 453 }
 454
 455 void wxRichTextObject::Dereference()
 456 {
 457     m_refCount --;
 458     if (m_refCount <= 0)
 459         delete this;
 460 }
 461
 462 /// Copy
 463 void wxRichTextObject::Copy(const wxRichTextObject& obj)
 464 {
 465     m_size = obj.m_size;
 466     m_pos = obj.m_pos;
 467     m_dirty = obj.m_dirty;
 468     m_range = obj.m_range;
 469     m_attributes = obj.m_attributes;
 470     m_descent = obj.m_descent;
 471 }
 472
 473 void wxRichTextObject::SetMargins(int margin)
 474 {
 475     m_leftMargin = m_rightMargin = m_topMargin = m_bottomMargin = margin;
 476 }
 477
 478 void wxRichTextObject::SetMargins(int leftMargin, int rightMargin, int topMargin, int bottomMargin)
 479 {
 480     m_leftMargin = leftMargin;
 481     m_rightMargin = rightMargin;
 482     m_topMargin = topMargin;
 483     m_bottomMargin = bottomMargin;
 484 }
 485
 486 // Convert units in tenths of a millimetre to device units
 487 int wxRichTextObject::ConvertTenthsMMToPixels(wxDC& dc, int units) const
 488 {
 489     int p = ConvertTenthsMMToPixels(dc.GetPPI().x, units);
 490
 491     // Unscale
 492     wxRichTextBuffer* buffer = GetBuffer();
 493     if (buffer)
 494         p = (int) ((double)p / buffer->GetScale());
 495     return p;
 496 }
 497
 498 // Convert units in tenths of a millimetre to device units
 499 int wxRichTextObject::ConvertTenthsMMToPixels(int ppi, int units)
 500 {
 501     // There are ppi pixels in 254.1 "1/10 mm"
 502
 503     double pixels = ((double) units * (double)ppi) / 254.1;
 504
 505     return (int) pixels;
 506 }
 507
 508 // Convert units in pixels to tenths of a millimetre
 509 int wxRichTextObject::ConvertPixelsToTenthsMM(wxDC& dc, int pixels) const
 510 {
 511     int p = pixels;
 512     if (GetBuffer() && GetBuffer()->GetScale() != 1.0)
 513         p = (int) (double(p) * GetBuffer()->GetScale());
 514     return ConvertPixelsToTenthsMM(dc.GetPPI().x, p);
 515 }
 516
 517 int wxRichTextObject::ConvertPixelsToTenthsMM(int ppi, int pixels)
 518 {
 519     // There are ppi pixels in 254.1 "1/10 mm"
 520
 521     int units = int( double(pixels) * 254.1 / (double) ppi );
 522     return units;
 523 }
 524
 525 /// Dump to output stream for debugging
 526 void wxRichTextObject::Dump(wxTextOutputStream& stream)
 527 {
 528     stream << GetClassInfo()->GetClassName() << wxT("\n");
 529     stream << wxString::Format(wxT("Size: %d,%d. Position: %d,%d, Range: %ld,%ld"), m_size.x, m_size.y, m_pos.x, m_pos.y, m_range.GetStart(), m_range.GetEnd()) << wxT("\n");
 530     stream << wxString::Format(wxT("Text colour: %d,%d,%d."), (int) m_attributes.GetTextColour().Red(), (int) m_attributes.GetTextColour().Green(), (int) m_attributes.GetTextColour().Blue()) << wxT("\n");
 531 }
 532
 533 /// Gets the containing buffer
 534 wxRichTextBuffer* wxRichTextObject::GetBuffer() const
 535 {
 536     const wxRichTextObject* obj = this;
 537     while (obj && !obj->IsKindOf(CLASSINFO(wxRichTextBuffer)))
 538         obj = obj->GetParent();
 539     return wxDynamicCast(obj, wxRichTextBuffer);
 540 }
 541
 542 /*!
 543  * wxRichTextCompositeObject
 544  * This is the base for drawable objects.
 545  */
 546
 547 IMPLEMENT_CLASS(wxRichTextCompositeObject, wxRichTextObject)
 548
 549 wxRichTextCompositeObject::wxRichTextCompositeObject(wxRichTextObject* parent):
 550     wxRichTextObject(parent)
 551 {
 552 }
 553
 554 wxRichTextCompositeObject::~wxRichTextCompositeObject()
 555 {
 556     DeleteChildren();
 557 }
 558
 559 /// Get the nth child
 560 wxRichTextObject* wxRichTextCompositeObject::GetChild(size_t n) const
 561 {
 562     wxASSERT ( n < m_children.GetCount() );
 563
 564     return m_children.Item(n)->GetData();
 565 }
 566
 567 /// Append a child, returning the position
 568 size_t wxRichTextCompositeObject::AppendChild(wxRichTextObject* child)
 569 {
 570     m_children.Append(child);
 571     child->SetParent(this);
 572     return m_children.GetCount() - 1;
 573 }
 574
 575 /// Insert the child in front of the given object, or at the beginning
 576 bool wxRichTextCompositeObject::InsertChild(wxRichTextObject* child, wxRichTextObject* inFrontOf)
 577 {
 578     if (inFrontOf)
 579     {
 580         wxRichTextObjectList::compatibility_iterator node = m_children.Find(inFrontOf);
 581         m_children.Insert(node, child);
 582     }
 583     else
 584         m_children.Insert(child);
 585     child->SetParent(this);
 586
 587     return true;
 588 }
 589
 590 /// Delete the child
 591 bool wxRichTextCompositeObject::RemoveChild(wxRichTextObject* child, bool deleteChild)
 592 {
 593     wxRichTextObjectList::compatibility_iterator node = m_children.Find(child);
 594     if (node)
 595     {
 596         wxRichTextObject* obj = node->GetData();
 597         m_children.Erase(node);
 598         if (deleteChild)
 599             delete obj;
 600
 601         return true;
 602     }
 603     return false;
 604 }
 605
 606 /// Delete all children
 607 bool wxRichTextCompositeObject::DeleteChildren()
 608 {
 609     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
 610     while (node)
 611     {
 612         wxRichTextObjectList::compatibility_iterator oldNode = node;
 613
 614         wxRichTextObject* child = node->GetData();
 615         child->Dereference(); // Only delete if reference count is zero
 616
 617         node = node->GetNext();
 618         m_children.Erase(oldNode);
 619     }
 620
 621     return true;
 622 }
 623
 624 /// Get the child count
 625 size_t wxRichTextCompositeObject::GetChildCount() const
 626 {
 627     return m_children.GetCount();
 628 }
 629
 630 /// Copy
 631 void wxRichTextCompositeObject::Copy(const wxRichTextCompositeObject& obj)
 632 {
 633     wxRichTextObject::Copy(obj);
 634
 635     DeleteChildren();
 636
 637     wxRichTextObjectList::compatibility_iterator node = obj.m_children.GetFirst();
 638     while (node)
 639     {
 640         wxRichTextObject* child = node->GetData();
 641         wxRichTextObject* newChild = child->Clone();
 642         newChild->SetParent(this);
 643         m_children.Append(newChild);
 644
 645         node = node->GetNext();
 646     }
 647 }
 648
 649 /// Hit-testing: returns a flag indicating hit test details, plus
 650 /// information about position
 651 int wxRichTextCompositeObject::HitTest(wxDC& dc, const wxPoint& pt, long& textPosition)
 652 {
 653     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
 654     while (node)
 655     {
 656         wxRichTextObject* child = node->GetData();
 657
 658         int ret = child->HitTest(dc, pt, textPosition);
 659         if (ret != wxRICHTEXT_HITTEST_NONE)
 660             return ret;
 661
 662         node = node->GetNext();
 663     }
 664
 665     textPosition = GetRange().GetEnd()-1;
 666     return wxRICHTEXT_HITTEST_AFTER|wxRICHTEXT_HITTEST_OUTSIDE;
 667 }
 668
 669 /// Finds the absolute position and row height for the given character position
 670 bool wxRichTextCompositeObject::FindPosition(wxDC& dc, long index, wxPoint& pt, int* height, bool forceLineStart)
 671 {
 672     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
 673     while (node)
 674     {
 675         wxRichTextObject* child = node->GetData();
 676
 677         if (child->FindPosition(dc, index, pt, height, forceLineStart))
 678             return true;
 679
 680         node = node->GetNext();
 681     }
 682
 683     return false;
 684 }
 685
 686 /// Calculate range
 687 void wxRichTextCompositeObject::CalculateRange(long start, long& end)
 688 {
 689     long current = start;
 690     long lastEnd = current;
 691
 692     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
 693     while (node)
 694     {
 695         wxRichTextObject* child = node->GetData();
 696         long childEnd = 0;
 697
 698         child->CalculateRange(current, childEnd);
 699         lastEnd = childEnd;
 700
 701         current = childEnd + 1;
 702
 703         node = node->GetNext();
 704     }
 705
 706     end = lastEnd;
 707
 708     // An object with no children has zero length
 709     if (m_children.GetCount() == 0)
 710         end --;
 711
 712     m_range.SetRange(start, end);
 713 }
 714
 715 /// Delete range from layout.
 716 bool wxRichTextCompositeObject::DeleteRange(const wxRichTextRange& range)
 717 {
 718     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
 719
 720     while (node)
 721     {
 722         wxRichTextObject* obj = (wxRichTextObject*) node->GetData();
 723         wxRichTextObjectList::compatibility_iterator next = node->GetNext();
 724
 725         // Delete the range in each paragraph
 726
 727         // When a chunk has been deleted, internally the content does not
 728         // now match the ranges.
 729         // However, so long as deletion is not done on the same object twice this is OK.
 730         // If you may delete content from the same object twice, recalculate
 731         // the ranges inbetween DeleteRange calls by calling CalculateRanges, and
 732         // adjust the range you're deleting accordingly.
 733
 734         if (!obj->GetRange().IsOutside(range))
 735         {
 736             obj->DeleteRange(range);
 737
 738             // Delete an empty object, or paragraph within this range.
 739             if (obj->IsEmpty() ||
 740                 (range.GetStart() <= obj->GetRange().GetStart() && range.GetEnd() >= obj->GetRange().GetEnd()))
 741             {
 742                 // An empty paragraph has length 1, so won't be deleted unless the
 743                 // whole range is deleted.
 744                 RemoveChild(obj, true);
 745             }
 746         }
 747
 748         node = next;
 749     }
 750
 751     return true;
 752 }
 753
 754 /// Get any text in this object for the given range
 755 wxString wxRichTextCompositeObject::GetTextForRange(const wxRichTextRange& range) const
 756 {
 757     wxString text;
 758     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
 759     while (node)
 760     {
 761         wxRichTextObject* child = node->GetData();
 762         wxRichTextRange childRange = range;
 763         if (!child->GetRange().IsOutside(range))
 764         {
 765             childRange.LimitTo(child->GetRange());
 766
 767             wxString childText = child->GetTextForRange(childRange);
 768
 769             text += childText;
 770         }
 771         node = node->GetNext();
 772     }
 773
 774     return text;
 775 }
 776
 777 /// Recursively merge all pieces that can be merged.
 778 bool wxRichTextCompositeObject::Defragment(const wxRichTextRange& range)
 779 {
 780     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
 781     while (node)
 782     {
 783         wxRichTextObject* child = node->GetData();
 784         if (range == wxRICHTEXT_ALL || !child->GetRange().IsOutside(range))
 785         {
 786             wxRichTextCompositeObject* composite = wxDynamicCast(child, wxRichTextCompositeObject);
 787             if (composite)
 788                 composite->Defragment();
 789
 790             if (node->GetNext())
 791             {
 792                 wxRichTextObject* nextChild = node->GetNext()->GetData();
 793                 if (child->CanMerge(nextChild) && child->Merge(nextChild))
 794                 {
 795                     nextChild->Dereference();
 796                     m_children.Erase(node->GetNext());
 797
 798                     // Don't set node -- we'll see if we can merge again with the next
 799                     // child.
 800                 }
 801                 else
 802                     node = node->GetNext();
 803             }
 804             else
 805                 node = node->GetNext();
 806         }
 807         else
 808             node = node->GetNext();
 809     }
 810
 811     return true;
 812 }
 813
 814 /// Dump to output stream for debugging
 815 void wxRichTextCompositeObject::Dump(wxTextOutputStream& stream)
 816 {
 817     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
 818     while (node)
 819     {
 820         wxRichTextObject* child = node->GetData();
 821         child->Dump(stream);
 822         node = node->GetNext();
 823     }
 824 }
 825
 826
 827 /*!
 828  * wxRichTextBox
 829  * This defines a 2D space to lay out objects
 830  */
 831
 832 IMPLEMENT_DYNAMIC_CLASS(wxRichTextBox, wxRichTextCompositeObject)
 833
 834 wxRichTextBox::wxRichTextBox(wxRichTextObject* parent):
 835     wxRichTextCompositeObject(parent)
 836 {
 837 }
 838
 839 /// Draw the item
 840 bool wxRichTextBox::Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& WXUNUSED(rect), int descent, int style)
 841 {
 842     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
 843     while (node)
 844     {
 845         wxRichTextObject* child = node->GetData();
 846
 847         wxRect childRect = wxRect(child->GetPosition(), child->GetCachedSize());
 848         child->Draw(dc, range, selectionRange, childRect, descent, style);
 849
 850         node = node->GetNext();
 851     }
 852     return true;
 853 }
 854
 855 /// Lay the item out
 856 bool wxRichTextBox::Layout(wxDC& dc, const wxRect& rect, int style)
 857 {
 858     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
 859     while (node)
 860     {
 861         wxRichTextObject* child = node->GetData();
 862         child->Layout(dc, rect, style);
 863
 864         node = node->GetNext();
 865     }
 866     m_dirty = false;
 867     return true;
 868 }
 869
 870 /// Get/set the size for the given range. Assume only has one child.
 871 bool wxRichTextBox::GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position, wxArrayInt* partialExtents) const
 872 {
 873     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
 874     if (node)
 875     {
 876         wxRichTextObject* child = node->GetData();
 877         return child->GetRangeSize(range, size, descent, dc, flags, position, partialExtents);
 878     }
 879     else
 880         return false;
 881 }
 882
 883 /// Copy
 884 void wxRichTextBox::Copy(const wxRichTextBox& obj)
 885 {
 886     wxRichTextCompositeObject::Copy(obj);
 887 }
 888
 889
 890 /*!
 891  * wxRichTextParagraphLayoutBox
 892  * This box knows how to lay out paragraphs.
 893  */
 894
 895 IMPLEMENT_DYNAMIC_CLASS(wxRichTextParagraphLayoutBox, wxRichTextBox)
 896
 897 wxRichTextParagraphLayoutBox::wxRichTextParagraphLayoutBox(wxRichTextObject* parent):
 898     wxRichTextBox(parent)
 899 {
 900     Init();
 901 }
 902
 903 wxRichTextParagraphLayoutBox::~wxRichTextParagraphLayoutBox()
 904 {
 905     if (m_floatCollector)
 906     {
 907         delete m_floatCollector;
 908         m_floatCollector = NULL;
 909     }
 910 }
 911
 912 /// Initialize the object.
 913 void wxRichTextParagraphLayoutBox::Init()
 914 {
 915     m_ctrl = NULL;
 916
 917     // For now, assume is the only box and has no initial size.
 918     m_range = wxRichTextRange(0, -1);
 919
 920     m_invalidRange.SetRange(-1, -1);
 921     m_leftMargin = 4;
 922     m_rightMargin = 4;
 923     m_topMargin = 4;
 924     m_bottomMargin = 4;
 925     m_partialParagraph = false;
 926     m_floatCollector = NULL;
 927 }
 928
 929 // Gather information about floating objects
 930 bool wxRichTextParagraphLayoutBox::UpdateFloatingObjects(int width, wxRichTextObject* untilObj)
 931 {
 932     if (m_floatCollector != NULL)
 933         delete m_floatCollector;
 934     m_floatCollector = new wxRichTextFloatCollector(width);
 935     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
 936     while (node && node->GetData() != untilObj)
 937     {
 938         wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
 939         wxASSERT (child != NULL);
 940         if (child)
 941             m_floatCollector->CollectFloat(child);
 942         node = node->GetNext();
 943     }
 944
 945     return true;
 946 }
 947
 948 // HitTest
 949 int wxRichTextParagraphLayoutBox::HitTest(wxDC& dc, const wxPoint& pt, long& textPosition)
 950 {
 951     int ret = wxRICHTEXT_HITTEST_NONE;
 952     if (m_floatCollector)
 953         ret = m_floatCollector->HitTest(dc, pt, textPosition);
 954
 955     if (ret == wxRICHTEXT_HITTEST_NONE)
 956         return wxRichTextCompositeObject::HitTest(dc, pt, textPosition);
 957     else
 958         return ret;
 959 }
 960
 961 /// Draw the floating objects
 962 void wxRichTextParagraphLayoutBox::DrawFloats(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style)
 963 {
 964     if (m_floatCollector)
 965         m_floatCollector->Draw(dc, range, selectionRange, rect, descent, style);
 966 }
 967
 968 void wxRichTextParagraphLayoutBox::MoveAnchoredObjectToParagraph(wxRichTextParagraph* from, wxRichTextParagraph* to, wxRichTextAnchoredObject* obj)
 969 {
 970     if (from == to)
 971         return;
 972
 973     from->RemoveChild(obj);
 974     to->AppendChild(obj);
 975 }
 976
 977 /// Draw the item
 978 bool wxRichTextParagraphLayoutBox::Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style)
 979 {
 980     DrawFloats(dc, range, selectionRange, rect, descent, style);
 981     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
 982     while (node)
 983     {
 984         wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
 985         wxASSERT (child != NULL);
 986
 987         if (child && !child->GetRange().IsOutside(range))
 988         {
 989             wxRect childRect(child->GetPosition(), child->GetCachedSize());
 990
 991             if (((style & wxRICHTEXT_DRAW_IGNORE_CACHE) == 0) && childRect.GetTop() > rect.GetBottom())
 992             {
 993                 // Stop drawing
 994                 break;
 995             }
 996             else if (((style & wxRICHTEXT_DRAW_IGNORE_CACHE) == 0) && childRect.GetBottom() < rect.GetTop())
 997             {
 998                 // Skip
 999             }
1000             else
1001                 child->Draw(dc, range, selectionRange, rect, descent, style);
1002         }
1003
1004         node = node->GetNext();
1005     }
1006     return true;
1007 }
1008
1009 /// Lay the item out
1010 bool wxRichTextParagraphLayoutBox::Layout(wxDC& dc, const wxRect& rect, int style)
1011 {
1012     wxRect availableSpace;
1013     bool formatRect = (style & wxRICHTEXT_LAYOUT_SPECIFIED_RECT) == wxRICHTEXT_LAYOUT_SPECIFIED_RECT;
1014
1015     // If only laying out a specific area, the passed rect has a different meaning:
1016     // the visible part of the buffer. This is used in wxRichTextCtrl::OnSize,
1017     // so that during a size, only the visible part will be relaid out, or
1018     // it would take too long causing flicker. As an approximation, we assume that
1019     // everything up to the start of the visible area is laid out correctly.
1020     if (formatRect)
1021     {
1022         availableSpace = wxRect(0 + m_leftMargin,
1023                           0 + m_topMargin,
1024                           rect.width - m_leftMargin - m_rightMargin,
1025                           rect.height);
1026
1027         // Invalidate the part of the buffer from the first visible line
1028         // to the end. If other parts of the buffer are currently invalid,
1029         // then they too will be taken into account if they are above
1030         // the visible point.
1031         long startPos = 0;
1032         wxRichTextLine* line = GetLineAtYPosition(rect.y);
1033         if (line)
1034             startPos = line->GetAbsoluteRange().GetStart();
1035
1036         Invalidate(wxRichTextRange(startPos, GetRange().GetEnd()));
1037     }
1038     else
1039         availableSpace = wxRect(rect.x + m_leftMargin,
1040                           rect.y + m_topMargin,
1041                           rect.width - m_leftMargin - m_rightMargin,
1042                           rect.height - m_topMargin - m_bottomMargin);
1043
1044     int maxWidth = 0;
1045
1046     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1047
1048     bool layoutAll = true;
1049
1050     // Get invalid range, rounding to paragraph start/end.
1051     wxRichTextRange invalidRange = GetInvalidRange(true);
1052
1053     if (invalidRange == wxRICHTEXT_NONE && !formatRect)
1054         return true;
1055
1056     if (invalidRange == wxRICHTEXT_ALL)
1057         layoutAll = true;
1058     else    // If we know what range is affected, start laying out from that point on.
1059         if (invalidRange.GetStart() >= GetRange().GetStart())
1060     {
1061         wxRichTextParagraph* firstParagraph = GetParagraphAtPosition(invalidRange.GetStart());
1062         if (firstParagraph)
1063         {
1064             wxRichTextObjectList::compatibility_iterator firstNode = m_children.Find(firstParagraph);
1065             wxRichTextObjectList::compatibility_iterator previousNode;
1066             if ( firstNode )
1067                 previousNode = firstNode->GetPrevious();
1068             if (firstNode)
1069             {
1070                 if (previousNode)
1071                 {
1072                     wxRichTextParagraph* previousParagraph = wxDynamicCast(previousNode->GetData(), wxRichTextParagraph);
1073                     availableSpace.y = previousParagraph->GetPosition().y + previousParagraph->GetCachedSize().y;
1074                 }
1075
1076                 // Now we're going to start iterating from the first affected paragraph.
1077                 node = firstNode;
1078
1079                 layoutAll = false;
1080             }
1081         }
1082     }
1083
1084     UpdateFloatingObjects(availableSpace.width, node ? node->GetData() : (wxRichTextObject*) NULL);
1085
1086     // A way to force speedy rest-of-buffer layout (the 'else' below)
1087     bool forceQuickLayout = false;
1088
1089     while (node)
1090     {
1091         // Assume this box only contains paragraphs
1092
1093         wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
1094         wxCHECK_MSG( child, false, wxT("Unknown object in layout") );
1095
1096         // TODO: what if the child hasn't been laid out (e.g. involved in Undo) but still has 'old' lines
1097         if ( !forceQuickLayout &&
1098                 (layoutAll ||
1099                     child->GetLines().IsEmpty() ||
1100                         !child->GetRange().IsOutside(invalidRange)) )
1101         {
1102             child->Layout(dc, availableSpace, style);
1103
1104             // Layout must set the cached size
1105             availableSpace.y += child->GetCachedSize().y;
1106             maxWidth = wxMax(maxWidth, child->GetCachedSize().x);
1107
1108             // If we're just formatting the visible part of the buffer,
1109             // and we're now past the bottom of the window, start quick
1110             // layout.
1111             if (formatRect && child->GetPosition().y > rect.GetBottom())
1112                 forceQuickLayout = true;
1113         }
1114         else
1115         {
1116             // We're outside the immediately affected range, so now let's just
1117             // move everything up or down. This assumes that all the children have previously
1118             // been laid out and have wrapped line lists associated with them.
1119             // TODO: check all paragraphs before the affected range.
1120
1121             int inc = availableSpace.y - child->GetPosition().y;
1122
1123             while (node)
1124             {
1125                 wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
1126                 if (child)
1127                 {
1128                     if (child->GetLines().GetCount() == 0)
1129                         child->Layout(dc, availableSpace, style);
1130                     else
1131                         child->SetPosition(wxPoint(child->GetPosition().x, child->GetPosition().y + inc));
1132
1133                     availableSpace.y += child->GetCachedSize().y;
1134                     maxWidth = wxMax(maxWidth, child->GetCachedSize().x);
1135                 }
1136
1137                 node = node->GetNext();
1138             }
1139             break;
1140         }
1141
1142         node = node->GetNext();
1143     }
1144
1145     SetCachedSize(wxSize(maxWidth, availableSpace.y));
1146
1147     m_dirty = false;
1148     m_invalidRange = wxRICHTEXT_NONE;
1149
1150     return true;
1151 }
1152
1153 /// Copy
1154 void wxRichTextParagraphLayoutBox::Copy(const wxRichTextParagraphLayoutBox& obj)
1155 {
1156     wxRichTextBox::Copy(obj);
1157
1158     m_partialParagraph = obj.m_partialParagraph;
1159     m_defaultAttributes = obj.m_defaultAttributes;
1160 }
1161
1162 /// Get/set the size for the given range.
1163 bool wxRichTextParagraphLayoutBox::GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position, wxArrayInt* WXUNUSED(partialExtents)) const
1164 {
1165     wxSize sz;
1166
1167     wxRichTextObjectList::compatibility_iterator startPara = wxRichTextObjectList::compatibility_iterator();
1168     wxRichTextObjectList::compatibility_iterator endPara = wxRichTextObjectList::compatibility_iterator();
1169
1170     // First find the first paragraph whose starting position is within the range.
1171     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1172     while (node)
1173     {
1174         // child is a paragraph
1175         wxRichTextObject* child = node->GetData();
1176         const wxRichTextRange& r = child->GetRange();
1177
1178         if (r.GetStart() <= range.GetStart() && r.GetEnd() >= range.GetStart())
1179         {
1180             startPara = node;
1181             break;
1182         }
1183
1184         node = node->GetNext();
1185     }
1186
1187     // Next find the last paragraph containing part of the range
1188     node = m_children.GetFirst();
1189     while (node)
1190     {
1191         // child is a paragraph
1192         wxRichTextObject* child = node->GetData();
1193         const wxRichTextRange& r = child->GetRange();
1194
1195         if (r.GetStart() <= range.GetEnd() && r.GetEnd() >= range.GetEnd())
1196         {
1197             endPara = node;
1198             break;
1199         }
1200
1201         node = node->GetNext();
1202     }
1203
1204     if (!startPara || !endPara)
1205         return false;
1206
1207     // Now we can add up the sizes
1208     for (node = startPara; node ; node = node->GetNext())
1209     {
1210         // child is a paragraph
1211         wxRichTextObject* child = node->GetData();
1212         const wxRichTextRange& childRange = child->GetRange();
1213         wxRichTextRange rangeToFind = range;
1214         rangeToFind.LimitTo(childRange);
1215
1216         wxSize childSize;
1217
1218         int childDescent = 0;
1219         child->GetRangeSize(rangeToFind, childSize, childDescent, dc, flags, position);
1220
1221         descent = wxMax(childDescent, descent);
1222
1223         sz.x = wxMax(sz.x, childSize.x);
1224         sz.y += childSize.y;
1225
1226         if (node == endPara)
1227             break;
1228     }
1229
1230     size = sz;
1231
1232     return true;
1233 }
1234
1235 /// Get the paragraph at the given position
1236 wxRichTextParagraph* wxRichTextParagraphLayoutBox::GetParagraphAtPosition(long pos, bool caretPosition) const
1237 {
1238     if (caretPosition)
1239         pos ++;
1240
1241     // First find the first paragraph whose starting position is within the range.
1242     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1243     while (node)
1244     {
1245         // child is a paragraph
1246         wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
1247         wxASSERT (child != NULL);
1248
1249         // Return first child in buffer if position is -1
1250         // if (pos == -1)
1251         //    return child;
1252
1253         if (child->GetRange().Contains(pos))
1254             return child;
1255
1256         node = node->GetNext();
1257     }
1258     return NULL;
1259 }
1260
1261 /// Get the line at the given position
1262 wxRichTextLine* wxRichTextParagraphLayoutBox::GetLineAtPosition(long pos, bool caretPosition) const
1263 {
1264     if (caretPosition)
1265         pos ++;
1266
1267     // First find the first paragraph whose starting position is within the range.
1268     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1269     while (node)
1270     {
1271         wxRichTextObject* obj = (wxRichTextObject*) node->GetData();
1272         if (obj->GetRange().Contains(pos))
1273         {
1274             // child is a paragraph
1275             wxRichTextParagraph* child = wxDynamicCast(obj, wxRichTextParagraph);
1276             wxASSERT (child != NULL);
1277
1278             wxRichTextLineList::compatibility_iterator node2 = child->GetLines().GetFirst();
1279             while (node2)
1280             {
1281                 wxRichTextLine* line = node2->GetData();
1282
1283                 wxRichTextRange range = line->GetAbsoluteRange();
1284
1285                 if (range.Contains(pos) ||
1286
1287                     // If the position is end-of-paragraph, then return the last line of
1288                     // of the paragraph.
1289                     ((range.GetEnd() == child->GetRange().GetEnd()-1) && (pos == child->GetRange().GetEnd())))
1290                     return line;
1291
1292                 node2 = node2->GetNext();
1293             }
1294         }
1295
1296         node = node->GetNext();
1297     }
1298
1299     int lineCount = GetLineCount();
1300     if (lineCount > 0)
1301         return GetLineForVisibleLineNumber(lineCount-1);
1302     else
1303         return NULL;
1304 }
1305
1306 /// Get the line at the given y pixel position, or the last line.
1307 wxRichTextLine* wxRichTextParagraphLayoutBox::GetLineAtYPosition(int y) const
1308 {
1309     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1310     while (node)
1311     {
1312         wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
1313         wxASSERT (child != NULL);
1314
1315         wxRichTextLineList::compatibility_iterator node2 = child->GetLines().GetFirst();
1316         while (node2)
1317         {
1318             wxRichTextLine* line = node2->GetData();
1319
1320             wxRect rect(line->GetRect());
1321
1322             if (y <= rect.GetBottom())
1323                 return line;
1324
1325             node2 = node2->GetNext();
1326         }
1327
1328         node = node->GetNext();
1329     }
1330
1331     // Return last line
1332     int lineCount = GetLineCount();
1333     if (lineCount > 0)
1334         return GetLineForVisibleLineNumber(lineCount-1);
1335     else
1336         return NULL;
1337 }
1338
1339 /// Get the number of visible lines
1340 int wxRichTextParagraphLayoutBox::GetLineCount() const
1341 {
1342     int count = 0;
1343
1344     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1345     while (node)
1346     {
1347         wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
1348         wxASSERT (child != NULL);
1349
1350         count += child->GetLines().GetCount();
1351         node = node->GetNext();
1352     }
1353     return count;
1354 }
1355
1356
1357 /// Get the paragraph for a given line
1358 wxRichTextParagraph* wxRichTextParagraphLayoutBox::GetParagraphForLine(wxRichTextLine* line) const
1359 {
1360     return GetParagraphAtPosition(line->GetAbsoluteRange().GetStart());
1361 }
1362
1363 /// Get the line size at the given position
1364 wxSize wxRichTextParagraphLayoutBox::GetLineSizeAtPosition(long pos, bool caretPosition) const
1365 {
1366     wxRichTextLine* line = GetLineAtPosition(pos, caretPosition);
1367     if (line)
1368     {
1369         return line->GetSize();
1370     }
1371     else
1372         return wxSize(0, 0);
1373 }
1374
1375
1376 /// Convenience function to add a paragraph of text
1377 wxRichTextRange wxRichTextParagraphLayoutBox::AddParagraph(const wxString& text, wxRichTextAttr* paraStyle)
1378 {
1379     // Don't use the base style, just the default style, and the base style will
1380     // be combined at display time.
1381     // Divide into paragraph and character styles.
1382
1383     wxRichTextAttr defaultCharStyle;
1384     wxRichTextAttr defaultParaStyle;
1385
1386     // If the default style is a named paragraph style, don't apply any character formatting
1387     // to the initial text string.
1388     if (GetDefaultStyle().HasParagraphStyleName() && GetStyleSheet())
1389     {
1390         wxRichTextParagraphStyleDefinition* def = GetStyleSheet()->FindParagraphStyle(GetDefaultStyle().GetParagraphStyleName());
1391         if (def)
1392             defaultParaStyle = def->GetStyleMergedWithBase(GetStyleSheet());
1393     }
1394     else
1395         wxRichTextSplitParaCharStyles(GetDefaultStyle(), defaultParaStyle, defaultCharStyle);
1396
1397     wxRichTextAttr* pStyle = paraStyle ? paraStyle : (wxRichTextAttr*) & defaultParaStyle;
1398     wxRichTextAttr* cStyle = & defaultCharStyle;
1399
1400     wxRichTextParagraph* para = new wxRichTextParagraph(text, this, pStyle, cStyle);
1401
1402     AppendChild(para);
1403
1404     UpdateRanges();
1405     SetDirty(true);
1406
1407     return para->GetRange();
1408 }
1409
1410 /// Adds multiple paragraphs, based on newlines.
1411 wxRichTextRange wxRichTextParagraphLayoutBox::AddParagraphs(const wxString& text, wxRichTextAttr* paraStyle)
1412 {
1413     // Don't use the base style, just the default style, and the base style will
1414     // be combined at display time.
1415     // Divide into paragraph and character styles.
1416
1417     wxRichTextAttr defaultCharStyle;
1418     wxRichTextAttr defaultParaStyle;
1419
1420     // If the default style is a named paragraph style, don't apply any character formatting
1421     // to the initial text string.
1422     if (GetDefaultStyle().HasParagraphStyleName() && GetStyleSheet())
1423     {
1424         wxRichTextParagraphStyleDefinition* def = GetStyleSheet()->FindParagraphStyle(GetDefaultStyle().GetParagraphStyleName());
1425         if (def)
1426             defaultParaStyle = def->GetStyleMergedWithBase(GetStyleSheet());
1427     }
1428     else
1429         wxRichTextSplitParaCharStyles(GetDefaultStyle(), defaultParaStyle, defaultCharStyle);
1430
1431     wxRichTextAttr* pStyle = paraStyle ? paraStyle : (wxRichTextAttr*) & defaultParaStyle;
1432     wxRichTextAttr* cStyle = & defaultCharStyle;
1433
1434     wxRichTextParagraph* firstPara = NULL;
1435     wxRichTextParagraph* lastPara = NULL;
1436
1437     wxRichTextRange range(-1, -1);
1438
1439     size_t i = 0;
1440     size_t len = text.length();
1441     wxString line;
1442     wxRichTextParagraph* para = new wxRichTextParagraph(wxEmptyString, this, pStyle, cStyle);
1443
1444     AppendChild(para);
1445
1446     firstPara = para;
1447     lastPara = para;
1448
1449     while (i < len)
1450     {
1451         wxChar ch = text[i];
1452         if (ch == wxT('\n') || ch == wxT('\r'))
1453         {
1454             if (i != (len-1))
1455             {
1456                 wxRichTextPlainText* plainText = (wxRichTextPlainText*) para->GetChildren().GetFirst()->GetData();
1457                 plainText->SetText(line);
1458
1459                 para = new wxRichTextParagraph(wxEmptyString, this, pStyle, cStyle);
1460
1461                 AppendChild(para);
1462
1463                 lastPara = para;
1464                 line = wxEmptyString;
1465             }
1466         }
1467         else
1468             line += ch;
1469
1470         i ++;
1471     }
1472
1473     if (!line.empty())
1474     {
1475         wxRichTextPlainText* plainText = (wxRichTextPlainText*) para->GetChildren().GetFirst()->GetData();
1476         plainText->SetText(line);
1477     }
1478
1479     UpdateRanges();
1480
1481     SetDirty(false);
1482
1483     return wxRichTextRange(firstPara->GetRange().GetStart(), lastPara->GetRange().GetEnd());
1484 }
1485
1486 /// Convenience function to add an image
1487 wxRichTextRange wxRichTextParagraphLayoutBox::AddImage(const wxImage& image, wxRichTextAttr* paraStyle)
1488 {
1489     // Don't use the base style, just the default style, and the base style will
1490     // be combined at display time.
1491     // Divide into paragraph and character styles.
1492
1493     wxRichTextAttr defaultCharStyle;
1494     wxRichTextAttr defaultParaStyle;
1495
1496     // If the default style is a named paragraph style, don't apply any character formatting
1497     // to the initial text string.
1498     if (GetDefaultStyle().HasParagraphStyleName() && GetStyleSheet())
1499     {
1500         wxRichTextParagraphStyleDefinition* def = GetStyleSheet()->FindParagraphStyle(GetDefaultStyle().GetParagraphStyleName());
1501         if (def)
1502             defaultParaStyle = def->GetStyleMergedWithBase(GetStyleSheet());
1503     }
1504     else
1505         wxRichTextSplitParaCharStyles(GetDefaultStyle(), defaultParaStyle, defaultCharStyle);
1506
1507     wxRichTextAttr* pStyle = paraStyle ? paraStyle : (wxRichTextAttr*) & defaultParaStyle;
1508     wxRichTextAttr* cStyle = & defaultCharStyle;
1509
1510     wxRichTextParagraph* para = new wxRichTextParagraph(this, pStyle);
1511     AppendChild(para);
1512     para->AppendChild(new wxRichTextImage(image, this, cStyle));
1513
1514     UpdateRanges();
1515     SetDirty(true);
1516
1517     return para->GetRange();
1518 }
1519
1520
1521 /// Insert fragment into this box at the given position. If partialParagraph is true,
1522 /// it is assumed that the last (or only) paragraph is just a piece of data with no paragraph
1523 /// marker.
1524
1525 bool wxRichTextParagraphLayoutBox::InsertFragment(long position, wxRichTextParagraphLayoutBox& fragment)
1526 {
1527     SetDirty(true);
1528
1529     // First, find the first paragraph whose starting position is within the range.
1530     wxRichTextParagraph* para = GetParagraphAtPosition(position);
1531     if (para)
1532     {
1533         wxRichTextAttr originalAttr = para->GetAttributes();
1534
1535         wxRichTextObjectList::compatibility_iterator node = m_children.Find(para);
1536
1537         // Now split at this position, returning the object to insert the new
1538         // ones in front of.
1539         wxRichTextObject* nextObject = para->SplitAt(position);
1540
1541         // Special case: partial paragraph, just one paragraph. Might be a small amount of
1542         // text, for example, so let's optimize.
1543
1544         if (fragment.GetPartialParagraph() && fragment.GetChildren().GetCount() == 1)
1545         {
1546             // Add the first para to this para...
1547             wxRichTextObjectList::compatibility_iterator firstParaNode = fragment.GetChildren().GetFirst();
1548             if (!firstParaNode)
1549                 return false;
1550
1551             // Iterate through the fragment paragraph inserting the content into this paragraph.
1552             wxRichTextParagraph* firstPara = wxDynamicCast(firstParaNode->GetData(), wxRichTextParagraph);
1553             wxASSERT (firstPara != NULL);
1554
1555             wxRichTextObjectList::compatibility_iterator objectNode = firstPara->GetChildren().GetFirst();
1556             while (objectNode)
1557             {
1558                 wxRichTextObject* newObj = objectNode->GetData()->Clone();
1559
1560                 if (!nextObject)
1561                 {
1562                     // Append
1563                     para->AppendChild(newObj);
1564                 }
1565                 else
1566                 {
1567                     // Insert before nextObject
1568                     para->InsertChild(newObj, nextObject);
1569                 }
1570
1571                 objectNode = objectNode->GetNext();
1572             }
1573
1574             return true;
1575         }
1576         else
1577         {
1578             // Procedure for inserting a fragment consisting of a number of
1579             // paragraphs:
1580             //
1581             // 1. Remove and save the content that's after the insertion point, for adding
1582             //    back once we've added the fragment.
1583             // 2. Add the content from the first fragment paragraph to the current
1584             //    paragraph.
1585             // 3. Add remaining fragment paragraphs after the current paragraph.
1586             // 4. Add back the saved content from the first paragraph. If partialParagraph
1587             //    is true, add it to the last paragraph added and not a new one.
1588
1589             // 1. Remove and save objects after split point.
1590             wxList savedObjects;
1591             if (nextObject)
1592                 para->MoveToList(nextObject, savedObjects);
1593
1594             // 2. Add the content from the 1st fragment paragraph.
1595             wxRichTextObjectList::compatibility_iterator firstParaNode = fragment.GetChildren().GetFirst();
1596             if (!firstParaNode)
1597                 return false;
1598
1599             wxRichTextParagraph* firstPara = wxDynamicCast(firstParaNode->GetData(), wxRichTextParagraph);
1600             wxASSERT(firstPara != NULL);
1601
1602             if (!(fragment.GetAttributes().GetFlags() & wxTEXT_ATTR_KEEP_FIRST_PARA_STYLE))
1603                 para->SetAttributes(firstPara->GetAttributes());
1604
1605             // Save empty paragraph attributes for appending later
1606             // These are character attributes deliberately set for a new paragraph. Without this,
1607             // we couldn't pass default attributes when appending a new paragraph.
1608             wxRichTextAttr emptyParagraphAttributes;
1609
1610             wxRichTextObjectList::compatibility_iterator objectNode = firstPara->GetChildren().GetFirst();
1611
1612             if (objectNode && firstPara->GetChildren().GetCount() == 1 && objectNode->GetData()->IsEmpty())
1613                 emptyParagraphAttributes = objectNode->GetData()->GetAttributes();
1614
1615             while (objectNode)
1616             {
1617                 wxRichTextObject* newObj = objectNode->GetData()->Clone();
1618
1619                 // Append
1620                 para->AppendChild(newObj);
1621
1622                 objectNode = objectNode->GetNext();
1623             }
1624
1625             // 3. Add remaining fragment paragraphs after the current paragraph.
1626             wxRichTextObjectList::compatibility_iterator nextParagraphNode = node->GetNext();
1627             wxRichTextObject* nextParagraph = NULL;
1628             if (nextParagraphNode)
1629                 nextParagraph = nextParagraphNode->GetData();
1630
1631             wxRichTextObjectList::compatibility_iterator i = fragment.GetChildren().GetFirst()->GetNext();
1632             wxRichTextParagraph* finalPara = para;
1633
1634             bool needExtraPara = (!i || !fragment.GetPartialParagraph());
1635
1636             // If there was only one paragraph, we need to insert a new one.
1637             while (i)
1638             {
1639                 wxRichTextParagraph* para = wxDynamicCast(i->GetData(), wxRichTextParagraph);
1640                 wxASSERT( para != NULL );
1641
1642                 finalPara = (wxRichTextParagraph*) para->Clone();
1643
1644                 if (nextParagraph)
1645                     InsertChild(finalPara, nextParagraph);
1646                 else
1647                     AppendChild(finalPara);
1648
1649                 i = i->GetNext();
1650             }
1651
1652             // If there was only one paragraph, or we have full paragraphs in our fragment,
1653             // we need to insert a new one.
1654             if (needExtraPara)
1655             {
1656                 finalPara = new wxRichTextParagraph;
1657
1658                 if (nextParagraph)
1659                     InsertChild(finalPara, nextParagraph);
1660                 else
1661                     AppendChild(finalPara);
1662             }
1663
1664             // 4. Add back the remaining content.
1665             if (finalPara)
1666             {
1667                 if (nextObject)
1668                     finalPara->MoveFromList(savedObjects);
1669
1670                 // Ensure there's at least one object
1671                 if (finalPara->GetChildCount() == 0)
1672                 {
1673                     wxRichTextPlainText* text = new wxRichTextPlainText(wxEmptyString);
1674                     text->SetAttributes(emptyParagraphAttributes);
1675
1676                     finalPara->AppendChild(text);
1677                 }
1678             }
1679
1680             if ((fragment.GetAttributes().GetFlags() & wxTEXT_ATTR_KEEP_FIRST_PARA_STYLE) && firstPara)
1681                 finalPara->SetAttributes(firstPara->GetAttributes());
1682             else if (finalPara && finalPara != para)
1683                 finalPara->SetAttributes(originalAttr);
1684
1685             return true;
1686         }
1687     }
1688     else
1689     {
1690         // Append
1691         wxRichTextObjectList::compatibility_iterator i = fragment.GetChildren().GetFirst();
1692         while (i)
1693         {
1694             wxRichTextParagraph* para = wxDynamicCast(i->GetData(), wxRichTextParagraph);
1695             wxASSERT( para != NULL );
1696
1697             AppendChild(para->Clone());
1698
1699             i = i->GetNext();
1700         }
1701
1702         return true;
1703     }
1704 }
1705
1706 /// Make a copy of the fragment corresponding to the given range, putting it in 'fragment'.
1707 /// If there was an incomplete paragraph at the end, partialParagraph is set to true.
1708 bool wxRichTextParagraphLayoutBox::CopyFragment(const wxRichTextRange& range, wxRichTextParagraphLayoutBox& fragment)
1709 {
1710     wxRichTextObjectList::compatibility_iterator i = GetChildren().GetFirst();
1711     while (i)
1712     {
1713         wxRichTextParagraph* para = wxDynamicCast(i->GetData(), wxRichTextParagraph);
1714         wxASSERT( para != NULL );
1715
1716         if (!para->GetRange().IsOutside(range))
1717         {
1718             fragment.AppendChild(para->Clone());
1719         }
1720         i = i->GetNext();
1721     }
1722
1723     // Now top and tail the first and last paragraphs in our new fragment (which might be the same).
1724     if (!fragment.IsEmpty())
1725     {
1726         wxRichTextRange topTailRange(range);
1727
1728         wxRichTextParagraph* firstPara = wxDynamicCast(fragment.GetChildren().GetFirst()->GetData(), wxRichTextParagraph);
1729         wxASSERT( firstPara != NULL );
1730
1731         // Chop off the start of the paragraph
1732         if (topTailRange.GetStart() > firstPara->GetRange().GetStart())
1733         {
1734             wxRichTextRange r(firstPara->GetRange().GetStart(), topTailRange.GetStart()-1);
1735             firstPara->DeleteRange(r);
1736
1737             // Make sure the numbering is correct
1738             long end;
1739             fragment.CalculateRange(firstPara->GetRange().GetStart(), end);
1740
1741             // Now, we've deleted some positions, so adjust the range
1742             // accordingly.
1743             topTailRange.SetEnd(topTailRange.GetEnd() - r.GetLength());
1744         }
1745
1746         wxRichTextParagraph* lastPara = wxDynamicCast(fragment.GetChildren().GetLast()->GetData(), wxRichTextParagraph);
1747         wxASSERT( lastPara != NULL );
1748
1749         if (topTailRange.GetEnd() < (lastPara->GetRange().GetEnd()-1))
1750         {
1751             wxRichTextRange r(topTailRange.GetEnd()+1, lastPara->GetRange().GetEnd()-1); /* -1 since actual text ends 1 position before end of para marker */
1752             lastPara->DeleteRange(r);
1753
1754             // Make sure the numbering is correct
1755             long end;
1756             fragment.CalculateRange(firstPara->GetRange().GetStart(), end);
1757
1758             // We only have part of a paragraph at the end
1759             fragment.SetPartialParagraph(true);
1760         }
1761         else
1762         {
1763             if (topTailRange.GetEnd() == (lastPara->GetRange().GetEnd() - 1))
1764                 // We have a partial paragraph (don't save last new paragraph marker)
1765                 fragment.SetPartialParagraph(true);
1766             else
1767                 // We have a complete paragraph
1768                 fragment.SetPartialParagraph(false);
1769         }
1770     }
1771
1772     return true;
1773 }
1774
1775 /// Given a position, get the number of the visible line (potentially many to a paragraph),
1776 /// starting from zero at the start of the buffer.
1777 long wxRichTextParagraphLayoutBox::GetVisibleLineNumber(long pos, bool caretPosition, bool startOfLine) const
1778 {
1779     if (caretPosition)
1780         pos ++;
1781
1782     int lineCount = 0;
1783
1784     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1785     while (node)
1786     {
1787         wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
1788         wxASSERT( child != NULL );
1789
1790         if (child->GetRange().Contains(pos))
1791         {
1792             wxRichTextLineList::compatibility_iterator node2 = child->GetLines().GetFirst();
1793             while (node2)
1794             {
1795                 wxRichTextLine* line = node2->GetData();
1796                 wxRichTextRange lineRange = line->GetAbsoluteRange();
1797
1798                 if (lineRange.Contains(pos) || pos == lineRange.GetStart())
1799                 {
1800                     // If the caret is displayed at the end of the previous wrapped line,
1801                     // we want to return the line it's _displayed_ at (not the actual line
1802                     // containing the position).
1803                     if (lineRange.GetStart() == pos && !startOfLine && child->GetRange().GetStart() != pos)
1804                         return lineCount - 1;
1805                     else
1806                         return lineCount;
1807                 }
1808
1809                 lineCount ++;
1810
1811                 node2 = node2->GetNext();
1812             }
1813             // If we didn't find it in the lines, it must be
1814             // the last position of the paragraph. So return the last line.
1815             return lineCount-1;
1816         }
1817         else
1818             lineCount += child->GetLines().GetCount();
1819
1820         node = node->GetNext();
1821     }
1822
1823     // Not found
1824     return -1;
1825 }
1826
1827 /// Given a line number, get the corresponding wxRichTextLine object.
1828 wxRichTextLine* wxRichTextParagraphLayoutBox::GetLineForVisibleLineNumber(long lineNumber) const
1829 {
1830     int lineCount = 0;
1831
1832     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1833     while (node)
1834     {
1835         wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
1836         wxASSERT(child != NULL);
1837
1838         if (lineNumber < (int) (child->GetLines().GetCount() + lineCount))
1839         {
1840             wxRichTextLineList::compatibility_iterator node2 = child->GetLines().GetFirst();
1841             while (node2)
1842             {
1843                 wxRichTextLine* line = node2->GetData();
1844
1845                 if (lineCount == lineNumber)
1846                     return line;
1847
1848                 lineCount ++;
1849
1850                 node2 = node2->GetNext();
1851             }
1852         }
1853         else
1854             lineCount += child->GetLines().GetCount();
1855
1856         node = node->GetNext();
1857     }
1858
1859     // Didn't find it
1860     return NULL;
1861 }
1862
1863 /// Delete range from layout.
1864 bool wxRichTextParagraphLayoutBox::DeleteRange(const wxRichTextRange& range)
1865 {
1866     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1867
1868     wxRichTextParagraph* firstPara = NULL;
1869     while (node)
1870     {
1871         wxRichTextParagraph* obj = wxDynamicCast(node->GetData(), wxRichTextParagraph);
1872         wxASSERT (obj != NULL);
1873
1874         wxRichTextObjectList::compatibility_iterator next = node->GetNext();
1875
1876         // Delete the range in each paragraph
1877
1878         if (!obj->GetRange().IsOutside(range))
1879         {
1880             // Deletes the content of this object within the given range
1881             obj->DeleteRange(range);
1882
1883             wxRichTextRange thisRange = obj->GetRange();
1884             wxRichTextAttr thisAttr = obj->GetAttributes();
1885
1886             // If the whole paragraph is within the range to delete,
1887             // delete the whole thing.
1888             if (range.GetStart() <= thisRange.GetStart() && range.GetEnd() >= thisRange.GetEnd())
1889             {
1890                 // Delete the whole object
1891                 RemoveChild(obj, true);
1892                 obj = NULL;
1893             }
1894             else if (!firstPara)
1895                 firstPara = obj;
1896
1897             // If the range includes the paragraph end, we need to join this
1898             // and the next paragraph.
1899             if (range.GetEnd() <= thisRange.GetEnd())
1900             {
1901                 // We need to move the objects from the next paragraph
1902                 // to this paragraph
1903
1904                 wxRichTextParagraph* nextParagraph = NULL;
1905                 if ((range.GetEnd() < thisRange.GetEnd()) && obj)
1906                     nextParagraph = obj;
1907                 else
1908                 {
1909                     // We're ending at the end of the paragraph, so merge the _next_ paragraph.
1910                     if (next)
1911                         nextParagraph = wxDynamicCast(next->GetData(), wxRichTextParagraph);
1912                 }
1913
1914                 bool applyFinalParagraphStyle = firstPara && nextParagraph && nextParagraph != firstPara;
1915
1916                 wxRichTextAttr nextParaAttr;
1917                 if (applyFinalParagraphStyle)
1918                 {
1919                     // Special case when deleting the end of a paragraph - use _this_ paragraph's style,
1920                     // not the next one.
1921                     if (range.GetStart() == range.GetEnd() && range.GetStart() == thisRange.GetEnd())
1922                         nextParaAttr = thisAttr;
1923                     else
1924                         nextParaAttr = nextParagraph->GetAttributes();
1925                 }
1926
1927                 if (firstPara && nextParagraph && firstPara != nextParagraph)
1928                 {
1929                     // Move the objects to the previous para
1930                     wxRichTextObjectList::compatibility_iterator node1 = nextParagraph->GetChildren().GetFirst();
1931
1932                     while (node1)
1933                     {
1934                         wxRichTextObject* obj1 = node1->GetData();
1935
1936                         firstPara->AppendChild(obj1);
1937
1938                         wxRichTextObjectList::compatibility_iterator next1 = node1->GetNext();
1939                         nextParagraph->GetChildren().Erase(node1);
1940
1941                         node1 = next1;
1942                     }
1943
1944                     // Delete the paragraph
1945                     RemoveChild(nextParagraph, true);
1946                 }
1947
1948                 // Avoid empty paragraphs
1949                 if (firstPara && firstPara->GetChildren().GetCount() == 0)
1950                 {
1951                     wxRichTextPlainText* text = new wxRichTextPlainText(wxEmptyString);
1952                     firstPara->AppendChild(text);
1953                 }
1954
1955                 if (applyFinalParagraphStyle)
1956                     firstPara->SetAttributes(nextParaAttr);
1957
1958                 return true;
1959             }
1960         }
1961
1962         node = next;
1963     }
1964
1965     return true;
1966 }
1967
1968 /// Get any text in this object for the given range
1969 wxString wxRichTextParagraphLayoutBox::GetTextForRange(const wxRichTextRange& range) const
1970 {
1971     int lineCount = 0;
1972     wxString text;
1973     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1974     while (node)
1975     {
1976         wxRichTextObject* child = node->GetData();
1977         if (!child->GetRange().IsOutside(range))
1978         {
1979             wxRichTextRange childRange = range;
1980             childRange.LimitTo(child->GetRange());
1981
1982             wxString childText = child->GetTextForRange(childRange);
1983
1984             text += childText;
1985
1986             if ((childRange.GetEnd() == child->GetRange().GetEnd()) && node->GetNext())
1987                 text += wxT("\n");
1988
1989             lineCount ++;
1990         }
1991         node = node->GetNext();
1992     }
1993
1994     return text;
1995 }
1996
1997 /// Get all the text
1998 wxString wxRichTextParagraphLayoutBox::GetText() const
1999 {
2000     return GetTextForRange(GetRange());
2001 }
2002
2003 /// Get the paragraph by number
2004 wxRichTextParagraph* wxRichTextParagraphLayoutBox::GetParagraphAtLine(long paragraphNumber) const
2005 {
2006     if ((size_t) paragraphNumber >= GetChildCount())
2007         return NULL;
2008
2009     return (wxRichTextParagraph*) GetChild((size_t) paragraphNumber);
2010 }
2011
2012 /// Get the length of the paragraph
2013 int wxRichTextParagraphLayoutBox::GetParagraphLength(long paragraphNumber) const
2014 {
2015     wxRichTextParagraph* para = GetParagraphAtLine(paragraphNumber);
2016     if (para)
2017         return para->GetRange().GetLength() - 1; // don't include newline
2018     else
2019         return 0;
2020 }
2021
2022 /// Get the text of the paragraph
2023 wxString wxRichTextParagraphLayoutBox::GetParagraphText(long paragraphNumber) const
2024 {
2025     wxRichTextParagraph* para = GetParagraphAtLine(paragraphNumber);
2026     if (para)
2027         return para->GetTextForRange(para->GetRange());
2028     else
2029         return wxEmptyString;
2030 }
2031
2032 /// Convert zero-based line column and paragraph number to a position.
2033 long wxRichTextParagraphLayoutBox::XYToPosition(long x, long y) const
2034 {
2035     wxRichTextParagraph* para = GetParagraphAtLine(y);
2036     if (para)
2037     {
2038         return para->GetRange().GetStart() + x;
2039     }
2040     else
2041         return -1;
2042 }
2043
2044 /// Convert zero-based position to line column and paragraph number
2045 bool wxRichTextParagraphLayoutBox::PositionToXY(long pos, long* x, long* y) const
2046 {
2047     wxRichTextParagraph* para = GetParagraphAtPosition(pos);
2048     if (para)
2049     {
2050         int count = 0;
2051         wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
2052         while (node)
2053         {
2054             wxRichTextObject* child = node->GetData();
2055             if (child == para)
2056                 break;
2057             count ++;
2058             node = node->GetNext();
2059         }
2060
2061         *y = count;
2062         *x = pos - para->GetRange().GetStart();
2063
2064         return true;
2065     }
2066     else
2067         return false;
2068 }
2069
2070 /// Get the leaf object in a paragraph at this position.
2071 /// Given a line number, get the corresponding wxRichTextLine object.
2072 wxRichTextObject* wxRichTextParagraphLayoutBox::GetLeafObjectAtPosition(long position) const
2073 {
2074     wxRichTextParagraph* para = GetParagraphAtPosition(position);
2075     if (para)
2076     {
2077         wxRichTextObjectList::compatibility_iterator node = para->GetChildren().GetFirst();
2078
2079         while (node)
2080         {
2081             wxRichTextObject* child = node->GetData();
2082             if (child->GetRange().Contains(position))
2083                 return child;
2084
2085             node = node->GetNext();
2086         }
2087         if (position == para->GetRange().GetEnd() && para->GetChildCount() > 0)
2088             return para->GetChildren().GetLast()->GetData();
2089     }
2090     return NULL;
2091 }
2092
2093 /// Set character or paragraph text attributes: apply character styles only to immediate text nodes
2094 bool wxRichTextParagraphLayoutBox::SetStyle(const wxRichTextRange& range, const wxRichTextAttr& style, int flags)
2095 {
2096     bool characterStyle = false;
2097     bool paragraphStyle = false;
2098
2099     if (style.IsCharacterStyle())
2100         characterStyle = true;
2101     if (style.IsParagraphStyle())
2102         paragraphStyle = true;
2103
2104     bool withUndo = ((flags & wxRICHTEXT_SETSTYLE_WITH_UNDO) != 0);
2105     bool applyMinimal = ((flags & wxRICHTEXT_SETSTYLE_OPTIMIZE) != 0);
2106     bool parasOnly = ((flags & wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY) != 0);
2107     bool charactersOnly = ((flags & wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY) != 0);
2108     bool resetExistingStyle = ((flags & wxRICHTEXT_SETSTYLE_RESET) != 0);
2109     bool removeStyle = ((flags & wxRICHTEXT_SETSTYLE_REMOVE) != 0);
2110
2111     // Apply paragraph style first, if any
2112     wxRichTextAttr wholeStyle(style);
2113
2114     if (!removeStyle && wholeStyle.HasParagraphStyleName() && GetStyleSheet())
2115     {
2116         wxRichTextParagraphStyleDefinition* def = GetStyleSheet()->FindParagraphStyle(wholeStyle.GetParagraphStyleName());
2117         if (def)
2118             wxRichTextApplyStyle(wholeStyle, def->GetStyleMergedWithBase(GetStyleSheet()));
2119     }
2120
2121     // Limit the attributes to be set to the content to only character attributes.
2122     wxRichTextAttr characterAttributes(wholeStyle);
2123     characterAttributes.SetFlags(characterAttributes.GetFlags() & (wxTEXT_ATTR_CHARACTER));
2124
2125     if (!removeStyle && characterAttributes.HasCharacterStyleName() && GetStyleSheet())
2126     {
2127         wxRichTextCharacterStyleDefinition* def = GetStyleSheet()->FindCharacterStyle(characterAttributes.GetCharacterStyleName());
2128         if (def)
2129             wxRichTextApplyStyle(characterAttributes, def->GetStyleMergedWithBase(GetStyleSheet()));
2130     }
2131
2132     // If we are associated with a control, make undoable; otherwise, apply immediately
2133     // to the data.
2134
2135     bool haveControl = (GetRichTextCtrl() != NULL);
2136
2137     wxRichTextAction* action = NULL;
2138
2139     if (haveControl && withUndo)
2140     {
2141         action = new wxRichTextAction(NULL, _("Change Style"), wxRICHTEXT_CHANGE_STYLE, & GetRichTextCtrl()->GetBuffer(), GetRichTextCtrl());
2142         action->SetRange(range);
2143         action->SetPosition(GetRichTextCtrl()->GetCaretPosition());
2144     }
2145
2146     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
2147     while (node)
2148     {
2149         wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
2150         wxASSERT (para != NULL);
2151
2152         if (para && para->GetChildCount() > 0)
2153         {
2154             // Stop searching if we're beyond the range of interest
2155             if (para->GetRange().GetStart() > range.GetEnd())
2156                 break;
2157
2158             if (!para->GetRange().IsOutside(range))
2159             {
2160                 // We'll be using a copy of the paragraph to make style changes,
2161                 // not updating the buffer directly.
2162                 wxRichTextParagraph* newPara wxDUMMY_INITIALIZE(NULL);
2163
2164                 if (haveControl && withUndo)
2165                 {
2166                     newPara = new wxRichTextParagraph(*para);
2167                     action->GetNewParagraphs().AppendChild(newPara);
2168
2169                     // Also store the old ones for Undo
2170                     action->GetOldParagraphs().AppendChild(new wxRichTextParagraph(*para));
2171                 }
2172                 else
2173                     newPara = para;
2174
2175                 // If we're specifying paragraphs only, then we really mean character formatting
2176                 // to be included in the paragraph style
2177                 if ((paragraphStyle || parasOnly) && !charactersOnly)
2178                 {
2179                     if (removeStyle)
2180                     {
2181                         // Removes the given style from the paragraph
2182                         wxRichTextRemoveStyle(newPara->GetAttributes(), style);
2183                     }
2184                     else if (resetExistingStyle)
2185                         newPara->GetAttributes() = wholeStyle;
2186                     else
2187                     {
2188                         if (applyMinimal)
2189                         {
2190                             // Only apply attributes that will make a difference to the combined
2191                             // style as seen on the display
2192                             wxRichTextAttr combinedAttr(para->GetCombinedAttributes());
2193                             wxRichTextApplyStyle(newPara->GetAttributes(), wholeStyle, & combinedAttr);
2194                         }
2195                         else
2196                             wxRichTextApplyStyle(newPara->GetAttributes(), wholeStyle);
2197                     }
2198                 }
2199
2200                 // When applying paragraph styles dynamically, don't change the text objects' attributes
2201                 // since they will computed as needed. Only apply the character styling if it's _only_
2202                 // character styling. This policy is subject to change and might be put under user control.
2203
2204                 // Hm. we might well be applying a mix of paragraph and character styles, in which
2205                 // case we _do_ want to apply character styles regardless of what para styles are set.
2206                 // But if we're applying a paragraph style, which has some character attributes, but
2207                 // we only want the paragraphs to hold this character style, then we _don't_ want to
2208                 // apply the character style. So we need to be able to choose.
2209
2210                 if (!parasOnly && (characterStyle|charactersOnly) && range.GetStart() != newPara->GetRange().GetEnd())
2211                 {
2212                     wxRichTextRange childRange(range);
2213                     childRange.LimitTo(newPara->GetRange());
2214
2215                     // Find the starting position and if necessary split it so
2216                     // we can start applying a different style.
2217                     // TODO: check that the style actually changes or is different
2218                     // from style outside of range
2219                     wxRichTextObject* firstObject wxDUMMY_INITIALIZE(NULL);
2220                     wxRichTextObject* lastObject wxDUMMY_INITIALIZE(NULL);
2221
2222                     if (childRange.GetStart() == newPara->GetRange().GetStart())
2223                         firstObject = newPara->GetChildren().GetFirst()->GetData();
2224                     else
2225                         firstObject = newPara->SplitAt(range.GetStart());
2226
2227                     // Increment by 1 because we're apply the style one _after_ the split point
2228                     long splitPoint = childRange.GetEnd();
2229                     if (splitPoint != newPara->GetRange().GetEnd())
2230                         splitPoint ++;
2231
2232                     // Find last object
2233                     if (splitPoint == newPara->GetRange().GetEnd())
2234                         lastObject = newPara->GetChildren().GetLast()->GetData();
2235                     else
2236                         // lastObject is set as a side-effect of splitting. It's
2237                         // returned as the object before the new object.
2238                         (void) newPara->SplitAt(splitPoint, & lastObject);
2239
2240                     wxASSERT(firstObject != NULL);
2241                     wxASSERT(lastObject != NULL);
2242
2243                     if (!firstObject || !lastObject)
2244                         continue;
2245
2246                     wxRichTextObjectList::compatibility_iterator firstNode = newPara->GetChildren().Find(firstObject);
2247                     wxRichTextObjectList::compatibility_iterator lastNode = newPara->GetChildren().Find(lastObject);
2248
2249                     wxASSERT(firstNode);
2250                     wxASSERT(lastNode);
2251
2252                     wxRichTextObjectList::compatibility_iterator node2 = firstNode;
2253
2254                     while (node2)
2255                     {
2256                         wxRichTextObject* child = node2->GetData();
2257
2258                         if (removeStyle)
2259                         {
2260                             // Removes the given style from the paragraph
2261                             wxRichTextRemoveStyle(child->GetAttributes(), style);
2262                         }
2263                         else if (resetExistingStyle)
2264                             child->GetAttributes() = characterAttributes;
2265                         else
2266                         {
2267                             if (applyMinimal)
2268                             {
2269                                 // Only apply attributes that will make a difference to the combined
2270                                 // style as seen on the display
2271                                 wxRichTextAttr combinedAttr(newPara->GetCombinedAttributes(child->GetAttributes()));
2272                                 wxRichTextApplyStyle(child->GetAttributes(), characterAttributes, & combinedAttr);
2273                             }
2274                             else
2275                                 wxRichTextApplyStyle(child->GetAttributes(), characterAttributes);
2276                         }
2277
2278                         if (node2 == lastNode)
2279                             break;
2280
2281                         node2 = node2->GetNext();
2282                     }
2283                 }
2284             }
2285         }
2286
2287         node = node->GetNext();
2288     }
2289
2290     // Do action, or delay it until end of batch.
2291     if (haveControl && withUndo)
2292         GetRichTextCtrl()->GetBuffer().SubmitAction(action);
2293
2294     return true;
2295 }
2296
2297 void wxRichTextParagraphLayoutBox::SetImageStyle(wxRichTextImage *image, const wxRichTextAttr& textAttr, int flags)
2298 {
2299     bool withUndo = flags & wxRICHTEXT_SETSTYLE_WITH_UNDO;
2300     bool haveControl = (GetRichTextCtrl() != NULL);
2301     wxRichTextParagraph* newPara wxDUMMY_INITIALIZE(NULL);
2302     wxRichTextParagraph* para = GetParagraphAtPosition(image->GetRange().GetStart());
2303     wxRichTextAction *action = NULL;
2304     wxRichTextAttr oldTextAttr = image->GetAttributes();
2305
2306     if (haveControl && withUndo)
2307     {
2308         action = new wxRichTextAction(NULL, _("Change Image Style"), wxRICHTEXT_CHANGE_STYLE, & GetRichTextCtrl()->GetBuffer(), GetRichTextCtrl());
2309         action->SetRange(image->GetRange().FromInternal());
2310         action->SetPosition(GetRichTextCtrl()->GetCaretPosition());
2311         image->SetAttributes(textAttr);
2312
2313         // Set the new attribute
2314         newPara = new wxRichTextParagraph(*para);
2315         action->GetNewParagraphs().AppendChild(newPara);
2316         // Change back to the old one
2317         image->SetAttributes(oldTextAttr);
2318         action->GetOldParagraphs().AppendChild(new wxRichTextParagraph(*para));
2319     }
2320     else
2321         newPara = para;
2322
2323     if (haveControl && withUndo)
2324         GetRichTextCtrl()->GetBuffer().SubmitAction(action);
2325 }
2326
2327 /// Get the text attributes for this position.
2328 bool wxRichTextParagraphLayoutBox::GetStyle(long position, wxRichTextAttr& style)
2329 {
2330     return DoGetStyle(position, style, true);
2331 }
2332
2333 bool wxRichTextParagraphLayoutBox::GetUncombinedStyle(long position, wxRichTextAttr& style)
2334 {
2335     return DoGetStyle(position, style, false);
2336 }
2337
2338 /// Implementation helper for GetStyle. If combineStyles is true, combine base, paragraph and
2339 /// context attributes.
2340 bool wxRichTextParagraphLayoutBox::DoGetStyle(long position, wxRichTextAttr& style, bool combineStyles)
2341 {
2342     wxRichTextObject* obj wxDUMMY_INITIALIZE(NULL);
2343
2344     if (style.IsParagraphStyle())
2345     {
2346         obj = GetParagraphAtPosition(position);
2347         if (obj)
2348         {
2349             if (combineStyles)
2350             {
2351                 // Start with the base style
2352                 style = GetAttributes();
2353
2354                 // Apply the paragraph style
2355                 wxRichTextApplyStyle(style, obj->GetAttributes());
2356             }
2357             else
2358                 style = obj->GetAttributes();
2359
2360             return true;
2361         }
2362     }
2363     else
2364     {
2365         obj = GetLeafObjectAtPosition(position);
2366         if (obj)
2367         {
2368             if (combineStyles)
2369             {
2370                 wxRichTextParagraph* para = wxDynamicCast(obj->GetParent(), wxRichTextParagraph);
2371                 style = para ? para->GetCombinedAttributes(obj->GetAttributes()) : obj->GetAttributes();
2372             }
2373             else
2374                 style = obj->GetAttributes();
2375
2376             return true;
2377         }
2378     }
2379     return false;
2380 }
2381
2382 static bool wxHasStyle(long flags, long style)
2383 {
2384     return (flags & style) != 0;
2385 }
2386
2387 /// Combines 'style' with 'currentStyle' for the purpose of summarising the attributes of a range of
2388 /// content.
2389 bool wxRichTextParagraphLayoutBox::CollectStyle(wxRichTextAttr& currentStyle, const wxRichTextAttr& style, wxRichTextAttr& clashingAttr, wxRichTextAttr& absentAttr)
2390 {
2391     currentStyle.CollectCommonAttributes(style, clashingAttr, absentAttr);
2392
2393     return true;
2394 }
2395
2396 /// Get the combined style for a range - if any attribute is different within the range,
2397 /// that attribute is not present within the flags.
2398 /// *** Note that this is not recursive, and so assumes that content inside a paragraph is not itself
2399 /// nested.
2400 bool wxRichTextParagraphLayoutBox::GetStyleForRange(const wxRichTextRange& range, wxRichTextAttr& style)
2401 {
2402     style = wxRichTextAttr();
2403
2404     wxRichTextAttr clashingAttr;
2405     wxRichTextAttr absentAttrPara, absentAttrChar;
2406
2407     wxRichTextObjectList::compatibility_iterator node = GetChildren().GetFirst();
2408     while (node)
2409     {
2410         wxRichTextParagraph* para = (wxRichTextParagraph*) node->GetData();
2411         if (!(para->GetRange().GetStart() > range.GetEnd() || para->GetRange().GetEnd() < range.GetStart()))
2412         {
2413             if (para->GetChildren().GetCount() == 0)
2414             {
2415                 wxRichTextAttr paraStyle = para->GetCombinedAttributes();
2416
2417                 CollectStyle(style, paraStyle, clashingAttr, absentAttrPara);
2418             }
2419             else
2420             {
2421                 wxRichTextRange paraRange(para->GetRange());
2422                 paraRange.LimitTo(range);
2423
2424                 // First collect paragraph attributes only
2425                 wxRichTextAttr paraStyle = para->GetCombinedAttributes();
2426                 paraStyle.SetFlags(paraStyle.GetFlags() & wxTEXT_ATTR_PARAGRAPH);
2427                 CollectStyle(style, paraStyle, clashingAttr, absentAttrPara);
2428
2429                 wxRichTextObjectList::compatibility_iterator childNode = para->GetChildren().GetFirst();
2430
2431                 while (childNode)
2432                 {
2433                     wxRichTextObject* child = childNode->GetData();
2434                     if (!(child->GetRange().GetStart() > range.GetEnd() || child->GetRange().GetEnd() < range.GetStart()))
2435                     {
2436                         wxRichTextAttr childStyle = para->GetCombinedAttributes(child->GetAttributes());
2437
2438                         // Now collect character attributes only
2439                         childStyle.SetFlags(childStyle.GetFlags() & wxTEXT_ATTR_CHARACTER);
2440
2441                         CollectStyle(style, childStyle, clashingAttr, absentAttrChar);
2442                     }
2443
2444                     childNode = childNode->GetNext();
2445                 }
2446             }
2447         }
2448         node = node->GetNext();
2449     }
2450     return true;
2451 }
2452
2453 /// Set default style
2454 bool wxRichTextParagraphLayoutBox::SetDefaultStyle(const wxRichTextAttr& style)
2455 {
2456     m_defaultAttributes = style;
2457     return true;
2458 }
2459
2460 /// Test if this whole range has character attributes of the specified kind. If any
2461 /// of the attributes are different within the range, the test fails. You
2462 /// can use this to implement, for example, bold button updating. style must have
2463 /// flags indicating which attributes are of interest.
2464 bool wxRichTextParagraphLayoutBox::HasCharacterAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const
2465 {
2466     int foundCount = 0;
2467     int matchingCount = 0;
2468
2469     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
2470     while (node)
2471     {
2472         wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
2473         wxASSERT (para != NULL);
2474
2475         if (para)
2476         {
2477             // Stop searching if we're beyond the range of interest
2478             if (para->GetRange().GetStart() > range.GetEnd())
2479                 return foundCount == matchingCount && foundCount != 0;
2480
2481             if (!para->GetRange().IsOutside(range))
2482             {
2483                 wxRichTextObjectList::compatibility_iterator node2 = para->GetChildren().GetFirst();
2484
2485                 while (node2)
2486                 {
2487                     wxRichTextObject* child = node2->GetData();
2488                     // Allow for empty string if no buffer
2489                     wxRichTextRange childRange = child->GetRange();
2490                     if (childRange.GetLength() == 0 && GetRange().GetLength() == 1)
2491                         childRange.SetEnd(childRange.GetEnd()+1);
2492
2493                     if (!childRange.IsOutside(range) && child->IsKindOf(CLASSINFO(wxRichTextPlainText)))
2494                     {
2495                         foundCount ++;
2496                         wxRichTextAttr textAttr = para->GetCombinedAttributes(child->GetAttributes());
2497
2498                         if (wxTextAttrEqPartial(textAttr, style))
2499                             matchingCount ++;
2500                     }
2501
2502                     node2 = node2->GetNext();
2503                 }
2504             }
2505         }
2506
2507         node = node->GetNext();
2508     }
2509
2510     return foundCount == matchingCount && foundCount != 0;
2511 }
2512
2513 /// Test if this whole range has paragraph attributes of the specified kind. If any
2514 /// of the attributes are different within the range, the test fails. You
2515 /// can use this to implement, for example, centering button updating. style must have
2516 /// flags indicating which attributes are of interest.
2517 bool wxRichTextParagraphLayoutBox::HasParagraphAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const
2518 {
2519     int foundCount = 0;
2520     int matchingCount = 0;
2521
2522     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
2523     while (node)
2524     {
2525         wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
2526         wxASSERT (para != NULL);
2527
2528         if (para)
2529         {
2530             // Stop searching if we're beyond the range of interest
2531             if (para->GetRange().GetStart() > range.GetEnd())
2532                 return foundCount == matchingCount && foundCount != 0;
2533
2534             if (!para->GetRange().IsOutside(range))
2535             {
2536                 wxRichTextAttr textAttr = GetAttributes();
2537                 // Apply the paragraph style
2538                 wxRichTextApplyStyle(textAttr, para->GetAttributes());
2539
2540                 foundCount ++;
2541                 if (wxTextAttrEqPartial(textAttr, style))
2542                     matchingCount ++;
2543             }
2544         }
2545
2546         node = node->GetNext();
2547     }
2548     return foundCount == matchingCount && foundCount != 0;
2549 }
2550
2551 void wxRichTextParagraphLayoutBox::Clear()
2552 {
2553     DeleteChildren();
2554 }
2555
2556 void wxRichTextParagraphLayoutBox::Reset()
2557 {
2558     Clear();
2559
2560     wxRichTextBuffer* buffer = wxDynamicCast(this, wxRichTextBuffer);
2561     if (buffer && GetRichTextCtrl())
2562     {
2563         wxRichTextEvent event(wxEVT_COMMAND_RICHTEXT_BUFFER_RESET, GetRichTextCtrl()->GetId());
2564         event.SetEventObject(GetRichTextCtrl());
2565
2566         buffer->SendEvent(event, true);
2567     }
2568
2569     AddParagraph(wxEmptyString);
2570
2571     Invalidate(wxRICHTEXT_ALL);
2572 }
2573
2574 /// Invalidate the buffer. With no argument, invalidates whole buffer.
2575 void wxRichTextParagraphLayoutBox::Invalidate(const wxRichTextRange& invalidRange)
2576 {
2577     SetDirty(true);
2578
2579     if (invalidRange == wxRICHTEXT_ALL)
2580     {
2581         m_invalidRange = wxRICHTEXT_ALL;
2582         return;
2583     }
2584
2585     // Already invalidating everything
2586     if (m_invalidRange == wxRICHTEXT_ALL)
2587         return;
2588
2589     if ((invalidRange.GetStart() < m_invalidRange.GetStart()) || m_invalidRange.GetStart() == -1)
2590         m_invalidRange.SetStart(invalidRange.GetStart());
2591     if (invalidRange.GetEnd() > m_invalidRange.GetEnd())
2592         m_invalidRange.SetEnd(invalidRange.GetEnd());
2593 }
2594
2595 /// Get invalid range, rounding to entire paragraphs if argument is true.
2596 wxRichTextRange wxRichTextParagraphLayoutBox::GetInvalidRange(bool wholeParagraphs) const
2597 {
2598     if (m_invalidRange == wxRICHTEXT_ALL || m_invalidRange == wxRICHTEXT_NONE)
2599         return m_invalidRange;
2600
2601     wxRichTextRange range = m_invalidRange;
2602
2603     if (wholeParagraphs)
2604     {
2605         wxRichTextParagraph* para1 = GetParagraphAtPosition(range.GetStart());
2606         if (para1)
2607             range.SetStart(para1->GetRange().GetStart());
2608         // floating layout make all child should be relayout
2609         range.SetEnd(GetRange().GetEnd());
2610     }
2611     return range;
2612 }
2613
2614 /// Apply the style sheet to the buffer, for example if the styles have changed.
2615 bool wxRichTextParagraphLayoutBox::ApplyStyleSheet(wxRichTextStyleSheet* styleSheet)
2616 {
2617     wxASSERT(styleSheet != NULL);
2618     if (!styleSheet)
2619         return false;
2620
2621     int foundCount = 0;
2622
2623     wxRichTextAttr attr(GetBasicStyle());
2624     if (GetBasicStyle().HasParagraphStyleName())
2625     {
2626         wxRichTextParagraphStyleDefinition* paraDef = styleSheet->FindParagraphStyle(GetBasicStyle().GetParagraphStyleName());
2627         if (paraDef)
2628         {
2629             attr.Apply(paraDef->GetStyleMergedWithBase(styleSheet));
2630             SetBasicStyle(attr);
2631             foundCount ++;
2632         }
2633     }
2634
2635     if (GetBasicStyle().HasCharacterStyleName())
2636     {
2637         wxRichTextCharacterStyleDefinition* charDef = styleSheet->FindCharacterStyle(GetBasicStyle().GetCharacterStyleName());
2638         if (charDef)
2639         {
2640             attr.Apply(charDef->GetStyleMergedWithBase(styleSheet));
2641             SetBasicStyle(attr);
2642             foundCount ++;
2643         }
2644     }
2645
2646     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
2647     while (node)
2648     {
2649         wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
2650         wxASSERT (para != NULL);
2651
2652         if (para)
2653         {
2654             // Combine paragraph and list styles. If there is a list style in the original attributes,
2655             // the current indentation overrides anything else and is used to find the item indentation.
2656             // Also, for applying paragraph styles, consider having 2 modes: (1) we merge with what we have,
2657             // thereby taking into account all user changes, (2) reset the style completely (except for indentation/list
2658             // exception as above).
2659             // Problem: when changing from one list style to another, there's a danger that the level info will get lost.
2660             // So when changing a list style interactively, could retrieve level based on current style, then
2661             // set appropriate indent and apply new style.
2662
2663             int outline = -1;
2664             int num = -1;
2665             if (para->GetAttributes().HasOutlineLevel())
2666                 outline = para->GetAttributes().GetOutlineLevel();
2667             if (para->GetAttributes().HasBulletNumber())
2668                 num = para->GetAttributes().GetBulletNumber();
2669
2670             if (!para->GetAttributes().GetParagraphStyleName().IsEmpty() && !para->GetAttributes().GetListStyleName().IsEmpty())
2671             {
2672                 int currentIndent = para->GetAttributes().GetLeftIndent();
2673
2674                 wxRichTextParagraphStyleDefinition* paraDef = styleSheet->FindParagraphStyle(para->GetAttributes().GetParagraphStyleName());
2675                 wxRichTextListStyleDefinition* listDef = styleSheet->FindListStyle(para->GetAttributes().GetListStyleName());
2676                 if (paraDef && !listDef)
2677                 {
2678                     para->GetAttributes() = paraDef->GetStyleMergedWithBase(styleSheet);
2679                     foundCount ++;
2680                 }
2681                 else if (listDef && !paraDef)
2682                 {
2683                     // Set overall style defined for the list style definition
2684                     para->GetAttributes() = listDef->GetStyleMergedWithBase(styleSheet);
2685
2686                     // Apply the style for this level
2687                     wxRichTextApplyStyle(para->GetAttributes(), * listDef->GetLevelAttributes(listDef->FindLevelForIndent(currentIndent)));
2688                     foundCount ++;
2689                 }
2690                 else if (listDef && paraDef)
2691                 {
2692                     // Combines overall list style, style for level, and paragraph style
2693                     para->GetAttributes() = listDef->CombineWithParagraphStyle(currentIndent, paraDef->GetStyleMergedWithBase(styleSheet));
2694                     foundCount ++;
2695                 }
2696             }
2697             else if (para->GetAttributes().GetParagraphStyleName().IsEmpty() && !para->GetAttributes().GetListStyleName().IsEmpty())
2698             {
2699                 int currentIndent = para->GetAttributes().GetLeftIndent();
2700
2701                 wxRichTextListStyleDefinition* listDef = styleSheet->FindListStyle(para->GetAttributes().GetListStyleName());
2702
2703                 // Overall list definition style
2704                 para->GetAttributes() = listDef->GetStyleMergedWithBase(styleSheet);
2705
2706                 // Style for this level
2707                 wxRichTextApplyStyle(para->GetAttributes(), * listDef->GetLevelAttributes(listDef->FindLevelForIndent(currentIndent)));
2708
2709                 foundCount ++;
2710             }
2711             else if (!para->GetAttributes().GetParagraphStyleName().IsEmpty() && para->GetAttributes().GetListStyleName().IsEmpty())
2712             {
2713                 wxRichTextParagraphStyleDefinition* def = styleSheet->FindParagraphStyle(para->GetAttributes().GetParagraphStyleName());
2714                 if (def)
2715                 {
2716                     para->GetAttributes() = def->GetStyleMergedWithBase(styleSheet);
2717                     foundCount ++;
2718                 }
2719             }
2720
2721             if (outline != -1)
2722                 para->GetAttributes().SetOutlineLevel(outline);
2723             if (num != -1)
2724                 para->GetAttributes().SetBulletNumber(num);
2725         }
2726
2727         node = node->GetNext();
2728     }
2729     return foundCount != 0;
2730 }
2731
2732 /// Set list style
2733 bool wxRichTextParagraphLayoutBox::SetListStyle(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags, int startFrom, int specifiedLevel)
2734 {
2735     wxRichTextStyleSheet* styleSheet = GetStyleSheet();
2736
2737     bool withUndo = ((flags & wxRICHTEXT_SETSTYLE_WITH_UNDO) != 0);
2738     // bool applyMinimal = ((flags & wxRICHTEXT_SETSTYLE_OPTIMIZE) != 0);
2739     bool specifyLevel = ((flags & wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL) != 0);
2740     bool renumber = ((flags & wxRICHTEXT_SETSTYLE_RENUMBER) != 0);
2741
2742     // Current number, if numbering
2743     int n = startFrom;
2744
2745     wxASSERT (!specifyLevel || (specifyLevel && (specifiedLevel >= 0)));
2746
2747     // If we are associated with a control, make undoable; otherwise, apply immediately
2748     // to the data.
2749
2750     bool haveControl = (GetRichTextCtrl() != NULL);
2751
2752     wxRichTextAction* action = NULL;
2753
2754     if (haveControl && withUndo)
2755     {
2756         action = new wxRichTextAction(NULL, _("Change List Style"), wxRICHTEXT_CHANGE_STYLE, & GetRichTextCtrl()->GetBuffer(), GetRichTextCtrl());
2757         action->SetRange(range);
2758         action->SetPosition(GetRichTextCtrl()->GetCaretPosition());
2759     }
2760
2761     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
2762     while (node)
2763     {
2764         wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
2765         wxASSERT (para != NULL);
2766
2767         if (para && para->GetChildCount() > 0)
2768         {
2769             // Stop searching if we're beyond the range of interest
2770             if (para->GetRange().GetStart() > range.GetEnd())
2771                 break;
2772
2773             if (!para->GetRange().IsOutside(range))
2774             {
2775                 // We'll be using a copy of the paragraph to make style changes,
2776                 // not updating the buffer directly.
2777                 wxRichTextParagraph* newPara wxDUMMY_INITIALIZE(NULL);
2778
2779                 if (haveControl && withUndo)
2780                 {
2781                     newPara = new wxRichTextParagraph(*para);
2782                     action->GetNewParagraphs().AppendChild(newPara);
2783
2784                     // Also store the old ones for Undo
2785                     action->GetOldParagraphs().AppendChild(new wxRichTextParagraph(*para));
2786                 }
2787                 else
2788                     newPara = para;
2789
2790                 if (def)
2791                 {
2792                     int thisIndent = newPara->GetAttributes().GetLeftIndent();
2793                     int thisLevel = specifyLevel ? specifiedLevel : def->FindLevelForIndent(thisIndent);
2794
2795                     // How is numbering going to work?
2796                     // If we are renumbering, or numbering for the first time, we need to keep
2797                     // track of the number for each level. But we might be simply applying a different
2798                     // list style.
2799                     // In Word, applying a style to several paragraphs, even if at different levels,
2800                     // reverts the level back to the same one. So we could do the same here.
2801                     // Renumbering will need to be done when we promote/demote a paragraph.
2802
2803                     // Apply the overall list style, and item style for this level
2804                     wxRichTextAttr listStyle(def->GetCombinedStyleForLevel(thisLevel, styleSheet));
2805                     wxRichTextApplyStyle(newPara->GetAttributes(), listStyle);
2806
2807                     // Now we need to do numbering
2808                     if (renumber)
2809                     {
2810                         newPara->GetAttributes().SetBulletNumber(n);
2811                     }
2812
2813                     n ++;
2814                 }
2815                 else if (!newPara->GetAttributes().GetListStyleName().IsEmpty())
2816                 {
2817                     // if def is NULL, remove list style, applying any associated paragraph style
2818                     // to restore the attributes
2819
2820                     newPara->GetAttributes().SetListStyleName(wxEmptyString);
2821                     newPara->GetAttributes().SetLeftIndent(0, 0);
2822                     newPara->GetAttributes().SetBulletText(wxEmptyString);
2823
2824                     // Eliminate the main list-related attributes
2825                     newPara->GetAttributes().SetFlags(newPara->GetAttributes().GetFlags() & ~wxTEXT_ATTR_LEFT_INDENT & ~wxTEXT_ATTR_BULLET_STYLE & ~wxTEXT_ATTR_BULLET_NUMBER & ~wxTEXT_ATTR_BULLET_TEXT & wxTEXT_ATTR_LIST_STYLE_NAME);
2826
2827                     if (styleSheet && !newPara->GetAttributes().GetParagraphStyleName().IsEmpty())
2828                     {
2829                         wxRichTextParagraphStyleDefinition* def = styleSheet->FindParagraphStyle(newPara->GetAttributes().GetParagraphStyleName());
2830                         if (def)
2831                         {
2832                             newPara->GetAttributes() = def->GetStyleMergedWithBase(styleSheet);
2833                         }
2834                     }
2835                 }
2836             }
2837         }
2838
2839         node = node->GetNext();
2840     }
2841
2842     // Do action, or delay it until end of batch.
2843     if (haveControl && withUndo)
2844         GetRichTextCtrl()->GetBuffer().SubmitAction(action);
2845
2846     return true;
2847 }
2848
2849 bool wxRichTextParagraphLayoutBox::SetListStyle(const wxRichTextRange& range, const wxString& defName, int flags, int startFrom, int specifiedLevel)
2850 {
2851     if (GetStyleSheet())
2852     {
2853         wxRichTextListStyleDefinition* def = GetStyleSheet()->FindListStyle(defName);
2854         if (def)
2855             return SetListStyle(range, def, flags, startFrom, specifiedLevel);
2856     }
2857     return false;
2858 }
2859
2860 /// Clear list for given range
2861 bool wxRichTextParagraphLayoutBox::ClearListStyle(const wxRichTextRange& range, int flags)
2862 {
2863     return SetListStyle(range, NULL, flags);
2864 }
2865
2866 /// Number/renumber any list elements in the given range
2867 bool wxRichTextParagraphLayoutBox::NumberList(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags, int startFrom, int specifiedLevel)
2868 {
2869     return DoNumberList(range, range, 0, def, flags, startFrom, specifiedLevel);
2870 }
2871
2872 /// Number/renumber any list elements in the given range. Also do promotion or demotion of items, if specified
2873 bool wxRichTextParagraphLayoutBox::DoNumberList(const wxRichTextRange& range, const wxRichTextRange& promotionRange, int promoteBy,
2874                                                 wxRichTextListStyleDefinition* def, int flags, int startFrom, int specifiedLevel)
2875 {
2876     wxRichTextStyleSheet* styleSheet = GetStyleSheet();
2877
2878     bool withUndo = ((flags & wxRICHTEXT_SETSTYLE_WITH_UNDO) != 0);
2879     // bool applyMinimal = ((flags & wxRICHTEXT_SETSTYLE_OPTIMIZE) != 0);
2880 #if wxDEBUG_LEVEL
2881     bool specifyLevel = ((flags & wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL) != 0);
2882 #endif
2883
2884     bool renumber = ((flags & wxRICHTEXT_SETSTYLE_RENUMBER) != 0);
2885
2886     // Max number of levels
2887     const int maxLevels = 10;
2888
2889     // The level we're looking at now
2890     int currentLevel = -1;
2891
2892     // The item number for each level
2893     int levels[maxLevels];
2894     int i;
2895
2896     // Reset all numbering
2897     for (i = 0; i < maxLevels; i++)
2898     {
2899         if (startFrom != -1)
2900             levels[i] = startFrom-1;
2901         else if (renumber) // start again
2902             levels[i] = 0;
2903         else
2904             levels[i] = -1; // start from the number we found, if any
2905     }
2906
2907     wxASSERT(!specifyLevel || (specifyLevel && (specifiedLevel >= 0)));
2908
2909     // If we are associated with a control, make undoable; otherwise, apply immediately
2910     // to the data.
2911
2912     bool haveControl = (GetRichTextCtrl() != NULL);
2913
2914     wxRichTextAction* action = NULL;
2915
2916     if (haveControl && withUndo)
2917     {
2918         action = new wxRichTextAction(NULL, _("Renumber List"), wxRICHTEXT_CHANGE_STYLE, & GetRichTextCtrl()->GetBuffer(), GetRichTextCtrl());
2919         action->SetRange(range);
2920         action->SetPosition(GetRichTextCtrl()->GetCaretPosition());
2921     }
2922
2923     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
2924     while (node)
2925     {
2926         wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
2927         wxASSERT (para != NULL);
2928
2929         if (para && para->GetChildCount() > 0)
2930         {
2931             // Stop searching if we're beyond the range of interest
2932             if (para->GetRange().GetStart() > range.GetEnd())
2933                 break;
2934
2935             if (!para->GetRange().IsOutside(range))
2936             {
2937                 // We'll be using a copy of the paragraph to make style changes,
2938                 // not updating the buffer directly.
2939                 wxRichTextParagraph* newPara wxDUMMY_INITIALIZE(NULL);
2940
2941                 if (haveControl && withUndo)
2942                 {
2943                     newPara = new wxRichTextParagraph(*para);
2944                     action->GetNewParagraphs().AppendChild(newPara);
2945
2946                     // Also store the old ones for Undo
2947                     action->GetOldParagraphs().AppendChild(new wxRichTextParagraph(*para));
2948                 }
2949                 else
2950                     newPara = para;
2951
2952                 wxRichTextListStyleDefinition* defToUse = def;
2953                 if (!defToUse)
2954                 {
2955                     if (styleSheet && !newPara->GetAttributes().GetListStyleName().IsEmpty())
2956                         defToUse = styleSheet->FindListStyle(newPara->GetAttributes().GetListStyleName());
2957                 }
2958
2959                 if (defToUse)
2960                 {
2961                     int thisIndent = newPara->GetAttributes().GetLeftIndent();
2962                     int thisLevel = defToUse->FindLevelForIndent(thisIndent);
2963
2964                     // If we've specified a level to apply to all, change the level.
2965                     if (specifiedLevel != -1)
2966                         thisLevel = specifiedLevel;
2967
2968                     // Do promotion if specified
2969                     if ((promoteBy != 0) && !para->GetRange().IsOutside(promotionRange))
2970                     {
2971                         thisLevel = thisLevel - promoteBy;
2972                         if (thisLevel < 0)
2973                             thisLevel = 0;
2974                         if (thisLevel > 9)
2975                             thisLevel = 9;
2976                     }
2977
2978                     // Apply the overall list style, and item style for this level
2979                     wxRichTextAttr listStyle(defToUse->GetCombinedStyleForLevel(thisLevel, styleSheet));
2980                     wxRichTextApplyStyle(newPara->GetAttributes(), listStyle);
2981
2982                     // OK, we've (re)applied the style, now let's get the numbering right.
2983
2984                     if (currentLevel == -1)
2985                         currentLevel = thisLevel;
2986
2987                     // Same level as before, do nothing except increment level's number afterwards
2988                     if (currentLevel == thisLevel)
2989                     {
2990                     }
2991                     // A deeper level: start renumbering all levels after current level
2992                     else if (thisLevel > currentLevel)
2993                     {
2994                         for (i = currentLevel+1; i <= thisLevel; i++)
2995                         {
2996                             levels[i] = 0;
2997                         }
2998                         currentLevel = thisLevel;
2999                     }
3000                     else if (thisLevel < currentLevel)
3001                     {
3002                         currentLevel = thisLevel;
3003                     }
3004
3005                     // Use the current numbering if -1 and we have a bullet number already
3006                     if (levels[currentLevel] == -1)
3007                     {
3008                         if (newPara->GetAttributes().HasBulletNumber())
3009                             levels[currentLevel] = newPara->GetAttributes().GetBulletNumber();
3010                         else
3011                             levels[currentLevel] = 1;
3012                     }
3013                     else
3014                     {
3015                         levels[currentLevel] ++;
3016                     }
3017
3018                     newPara->GetAttributes().SetBulletNumber(levels[currentLevel]);
3019
3020                     // Create the bullet text if an outline list
3021                     if (listStyle.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_OUTLINE)
3022                     {
3023                         wxString text;
3024                         for (i = 0; i <= currentLevel; i++)
3025                         {
3026                             if (!text.IsEmpty())
3027                                 text += wxT(".");
3028                             text += wxString::Format(wxT("%d"), levels[i]);
3029                         }
3030                         newPara->GetAttributes().SetBulletText(text);
3031                     }
3032                 }
3033             }
3034         }
3035
3036         node = node->GetNext();
3037     }
3038
3039     // Do action, or delay it until end of batch.
3040     if (haveControl && withUndo)
3041         GetRichTextCtrl()->GetBuffer().SubmitAction(action);
3042
3043     return true;
3044 }
3045
3046 bool wxRichTextParagraphLayoutBox::NumberList(const wxRichTextRange& range, const wxString& defName, int flags, int startFrom, int specifiedLevel)
3047 {
3048     if (GetStyleSheet())
3049     {
3050         wxRichTextListStyleDefinition* def = NULL;
3051         if (!defName.IsEmpty())
3052             def = GetStyleSheet()->FindListStyle(defName);
3053         return NumberList(range, def, flags, startFrom, specifiedLevel);
3054     }
3055     return false;
3056 }
3057
3058 /// Promote the list items within the given range. promoteBy can be a positive or negative number, e.g. 1 or -1
3059 bool wxRichTextParagraphLayoutBox::PromoteList(int promoteBy, const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags, int specifiedLevel)
3060 {
3061     // TODO
3062     // One strategy is to first work out the range within which renumbering must occur. Then could pass these two ranges
3063     // to NumberList with a flag indicating promotion is required within one of the ranges.
3064     // Find first and last paragraphs in range. Then for first, calculate new indentation and look back until we find
3065     // a paragraph that either has no list style, or has one that is different or whose indentation is less.
3066     // We start renumbering from the para after that different para we found. We specify that the numbering of that
3067     // list position will start from 1.
3068     // Similarly, we look after the last para in the promote range for an indentation that is less (or no list style).
3069     // We can end the renumbering at this point.
3070
3071     // For now, only renumber within the promotion range.
3072
3073     return DoNumberList(range, range, promoteBy, def, flags, 1, specifiedLevel);
3074 }
3075
3076 bool wxRichTextParagraphLayoutBox::PromoteList(int promoteBy, const wxRichTextRange& range, const wxString& defName, int flags, int specifiedLevel)
3077 {
3078     if (GetStyleSheet())
3079     {
3080         wxRichTextListStyleDefinition* def = NULL;
3081         if (!defName.IsEmpty())
3082             def = GetStyleSheet()->FindListStyle(defName);
3083         return PromoteList(promoteBy, range, def, flags, specifiedLevel);
3084     }
3085     return false;
3086 }
3087
3088 /// Fills in the attributes for numbering a paragraph after previousParagraph. It also finds the
3089 /// position of the paragraph that it had to start looking from.
3090 bool wxRichTextParagraphLayoutBox::FindNextParagraphNumber(wxRichTextParagraph* previousParagraph, wxRichTextAttr& attr) const
3091 {
3092     if (!previousParagraph->GetAttributes().HasFlag(wxTEXT_ATTR_BULLET_STYLE) || previousParagraph->GetAttributes().GetBulletStyle() == wxTEXT_ATTR_BULLET_STYLE_NONE)
3093         return false;
3094
3095     wxRichTextStyleSheet* styleSheet = GetStyleSheet();
3096     if (styleSheet && !previousParagraph->GetAttributes().GetListStyleName().IsEmpty())
3097     {
3098         wxRichTextListStyleDefinition* def = styleSheet->FindListStyle(previousParagraph->GetAttributes().GetListStyleName());
3099         if (def)
3100         {
3101             // int thisIndent = previousParagraph->GetAttributes().GetLeftIndent();
3102             // int thisLevel = def->FindLevelForIndent(thisIndent);
3103
3104             bool isOutline = (previousParagraph->GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_OUTLINE) != 0;
3105
3106             attr.SetFlags(previousParagraph->GetAttributes().GetFlags() & (wxTEXT_ATTR_BULLET_STYLE|wxTEXT_ATTR_BULLET_NUMBER|wxTEXT_ATTR_BULLET_TEXT|wxTEXT_ATTR_BULLET_NAME));
3107             if (previousParagraph->GetAttributes().HasBulletName())
3108                 attr.SetBulletName(previousParagraph->GetAttributes().GetBulletName());
3109             attr.SetBulletStyle(previousParagraph->GetAttributes().GetBulletStyle());
3110             attr.SetListStyleName(previousParagraph->GetAttributes().GetListStyleName());
3111
3112             int nextNumber = previousParagraph->GetAttributes().GetBulletNumber() + 1;
3113             attr.SetBulletNumber(nextNumber);
3114
3115             if (isOutline)
3116             {
3117                 wxString text = previousParagraph->GetAttributes().GetBulletText();
3118                 if (!text.IsEmpty())
3119                 {
3120                     int pos = text.Find(wxT('.'), true);
3121                     if (pos != wxNOT_FOUND)
3122                     {
3123                         text = text.Mid(0, text.Length() - pos - 1);
3124                     }
3125                     else
3126                         text = wxEmptyString;
3127                     if (!text.IsEmpty())
3128                         text += wxT(".");
3129                     text += wxString::Format(wxT("%d"), nextNumber);
3130                     attr.SetBulletText(text);
3131                 }
3132             }
3133
3134             return true;
3135         }
3136         else
3137             return false;
3138     }
3139     else
3140         return false;
3141 }
3142
3143 /*!
3144  * wxRichTextParagraph
3145  * This object represents a single paragraph (or in a straight text editor, a line).
3146  */
3147
3148 IMPLEMENT_DYNAMIC_CLASS(wxRichTextParagraph, wxRichTextBox)
3149
3150 wxArrayInt wxRichTextParagraph::sm_defaultTabs;
3151
3152 wxRichTextParagraph::wxRichTextParagraph(wxRichTextObject* parent, wxRichTextAttr* style):
3153     wxRichTextBox(parent)
3154 {
3155     if (style)
3156         SetAttributes(*style);
3157 }
3158
3159 wxRichTextParagraph::wxRichTextParagraph(const wxString& text, wxRichTextObject* parent, wxRichTextAttr* paraStyle, wxRichTextAttr* charStyle):
3160     wxRichTextBox(parent)
3161 {
3162     if (paraStyle)
3163         SetAttributes(*paraStyle);
3164
3165     AppendChild(new wxRichTextPlainText(text, this, charStyle));
3166 }
3167
3168 wxRichTextParagraph::~wxRichTextParagraph()
3169 {
3170     ClearLines();
3171 }
3172
3173 /// Draw the item
3174 bool wxRichTextParagraph::Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int WXUNUSED(descent), int style)
3175 {
3176     wxRichTextAttr attr = GetCombinedAttributes();
3177
3178     // Draw the bullet, if any
3179     if (attr.GetBulletStyle() != wxTEXT_ATTR_BULLET_STYLE_NONE)
3180     {
3181         if (attr.GetLeftSubIndent() != 0)
3182         {
3183             int spaceBeforePara = ConvertTenthsMMToPixels(dc, attr.GetParagraphSpacingBefore());
3184             int leftIndent = ConvertTenthsMMToPixels(dc, attr.GetLeftIndent());
3185
3186             wxRichTextAttr bulletAttr(GetCombinedAttributes());
3187
3188             // Combine with the font of the first piece of content, if one is specified
3189             if (GetChildren().GetCount() > 0)
3190             {
3191                 wxRichTextObject* firstObj = (wxRichTextObject*) GetChildren().GetFirst()->GetData();
3192                 if (!firstObj->IsFloatable() && firstObj->GetAttributes().HasFont())
3193                 {
3194                     wxRichTextApplyStyle(bulletAttr, firstObj->GetAttributes());
3195                 }
3196             }
3197
3198             // Get line height from first line, if any
3199             wxRichTextLine* line = m_cachedLines.GetFirst() ? (wxRichTextLine* ) m_cachedLines.GetFirst()->GetData() : NULL;
3200
3201             wxPoint linePos;
3202             int lineHeight wxDUMMY_INITIALIZE(0);
3203             if (line)
3204             {
3205                 lineHeight = line->GetSize().y;
3206                 linePos = line->GetPosition() + GetPosition();
3207             }
3208             else
3209             {
3210                 wxFont font;
3211                 if (bulletAttr.HasFont() && GetBuffer())
3212                     font = GetBuffer()->GetFontTable().FindFont(bulletAttr);
3213                 else
3214                     font = (*wxNORMAL_FONT);
3215
3216                 wxCheckSetFont(dc, font);
3217
3218                 lineHeight = dc.GetCharHeight();
3219                 linePos = GetPosition();
3220                 linePos.y += spaceBeforePara;
3221             }
3222
3223             wxRect bulletRect(GetPosition().x + leftIndent, linePos.y, linePos.x - (GetPosition().x + leftIndent), lineHeight);
3224
3225             if (attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_BITMAP)
3226             {
3227                 if (wxRichTextBuffer::GetRenderer())
3228                     wxRichTextBuffer::GetRenderer()->DrawBitmapBullet(this, dc, bulletAttr, bulletRect);
3229             }
3230             else if (attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_STANDARD)
3231             {
3232                 if (wxRichTextBuffer::GetRenderer())
3233                     wxRichTextBuffer::GetRenderer()->DrawStandardBullet(this, dc, bulletAttr, bulletRect);
3234             }
3235             else
3236             {
3237                 wxString bulletText = GetBulletText();
3238
3239                 if (!bulletText.empty() && wxRichTextBuffer::GetRenderer())
3240                     wxRichTextBuffer::GetRenderer()->DrawTextBullet(this, dc, bulletAttr, bulletRect, bulletText);
3241             }
3242         }
3243     }
3244
3245     // Draw the range for each line, one object at a time.
3246
3247     wxRichTextLineList::compatibility_iterator node = m_cachedLines.GetFirst();
3248     while (node)
3249     {
3250         wxRichTextLine* line = node->GetData();
3251         wxRichTextRange lineRange = line->GetAbsoluteRange();
3252
3253         // Lines are specified relative to the paragraph
3254
3255         wxPoint linePosition = line->GetPosition() + GetPosition();
3256
3257         // Don't draw if off the screen
3258         if (((style & wxRICHTEXT_DRAW_IGNORE_CACHE) != 0) || ((linePosition.y + line->GetSize().y) >= rect.y && linePosition.y <= rect.y + rect.height))
3259         {
3260             wxPoint objectPosition = linePosition;
3261             int maxDescent = line->GetDescent();
3262
3263             // Loop through objects until we get to the one within range
3264             wxRichTextObjectList::compatibility_iterator node2 = m_children.GetFirst();
3265
3266             int i = 0;
3267             while (node2)
3268             {
3269                 wxRichTextObject* child = node2->GetData();
3270
3271                 if (!child->IsFloating() && child->GetRange().GetLength() > 0 && !child->GetRange().IsOutside(lineRange) && !lineRange.IsOutside(range))
3272                 {
3273                     // Draw this part of the line at the correct position
3274                     wxRichTextRange objectRange(child->GetRange());
3275                     objectRange.LimitTo(lineRange);
3276
3277                     wxSize objectSize;
3278 #if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING && wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
3279                     if (i < (int) line->GetObjectSizes().GetCount())
3280                     {
3281                         objectSize.x = line->GetObjectSizes()[(size_t) i];
3282                     }
3283                     else
3284 #endif
3285                     {
3286                         int descent = 0;
3287                         child->GetRangeSize(objectRange, objectSize, descent, dc, wxRICHTEXT_UNFORMATTED, objectPosition);
3288                     }
3289
3290                     // Use the child object's width, but the whole line's height
3291                     wxRect childRect(objectPosition, wxSize(objectSize.x, line->GetSize().y));
3292                     child->Draw(dc, objectRange, selectionRange, childRect, maxDescent, style);
3293
3294                     objectPosition.x += objectSize.x;
3295                     i ++;
3296                 }
3297                 else if (child->GetRange().GetStart() > lineRange.GetEnd())
3298                     // Can break out of inner loop now since we've passed this line's range
3299                     break;
3300
3301                 node2 = node2->GetNext();
3302             }
3303         }
3304
3305         node = node->GetNext();
3306     }
3307
3308     return true;
3309 }
3310
3311 // Get the range width using partial extents calculated for the whole paragraph.
3312 static int wxRichTextGetRangeWidth(const wxRichTextParagraph& para, const wxRichTextRange& range, const wxArrayInt& partialExtents)
3313 {
3314     wxASSERT(partialExtents.GetCount() >= (size_t) range.GetLength());
3315
3316     if (partialExtents.GetCount() < (size_t) range.GetLength())
3317         return 0;
3318
3319     int leftMostPos = 0;
3320     if (range.GetStart() - para.GetRange().GetStart() > 0)
3321         leftMostPos = partialExtents[range.GetStart() - para.GetRange().GetStart() - 1];
3322
3323     int rightMostPos = partialExtents[range.GetEnd() - para.GetRange().GetStart()];
3324
3325     int w = rightMostPos - leftMostPos;
3326
3327     return w;
3328 }
3329
3330 /// Lay the item out
3331 bool wxRichTextParagraph::Layout(wxDC& dc, const wxRect& rect, int style)
3332 {
3333     // Deal with floating objects firstly before the normal layout
3334     wxRichTextBuffer* buffer = GetBuffer();
3335     wxASSERT(buffer);
3336     wxRichTextFloatCollector* collector = buffer->GetFloatCollector();
3337     wxASSERT(collector);
3338     LayoutFloat(dc, rect, style, collector);
3339
3340     wxRichTextAttr attr = GetCombinedAttributes();
3341
3342     // ClearLines();
3343
3344     // Increase the size of the paragraph due to spacing
3345     int spaceBeforePara = ConvertTenthsMMToPixels(dc, attr.GetParagraphSpacingBefore());
3346     int spaceAfterPara = ConvertTenthsMMToPixels(dc, attr.GetParagraphSpacingAfter());
3347     int leftIndent = ConvertTenthsMMToPixels(dc, attr.GetLeftIndent());
3348     int leftSubIndent = ConvertTenthsMMToPixels(dc, attr.GetLeftSubIndent());
3349     int rightIndent = ConvertTenthsMMToPixels(dc, attr.GetRightIndent());
3350
3351     int lineSpacing = 0;
3352
3353     // Let's assume line spacing of 10 is normal, 15 is 1.5, 20 is 2, etc.
3354     if (attr.HasLineSpacing() && attr.GetLineSpacing() > 0 && attr.GetFont().Ok())
3355     {
3356         wxCheckSetFont(dc, attr.GetFont());
3357         lineSpacing = (int) (double(dc.GetCharHeight()) * (double(attr.GetLineSpacing())/10.0 - 1.0));
3358     }
3359
3360     // Start position for each line relative to the paragraph
3361     int startPositionFirstLine = leftIndent;
3362     int startPositionSubsequentLines = leftIndent + leftSubIndent;
3363     wxRect availableRect;
3364
3365     // If we have a bullet in this paragraph, the start position for the first line's text
3366     // is actually leftIndent + leftSubIndent.
3367     if (attr.GetBulletStyle() != wxTEXT_ATTR_BULLET_STYLE_NONE)
3368         startPositionFirstLine = startPositionSubsequentLines;
3369
3370     long lastEndPos = GetRange().GetStart()-1;
3371     long lastCompletedEndPos = lastEndPos;
3372
3373     int currentWidth = 0;
3374     SetPosition(rect.GetPosition());
3375
3376     wxPoint currentPosition(0, spaceBeforePara); // We will calculate lines relative to paragraph
3377     int lineHeight = 0;
3378     int maxWidth = 0;
3379     int maxAscent = 0;
3380     int maxDescent = 0;
3381     int lineCount = 0;
3382     int lineAscent = 0;
3383     int lineDescent = 0;
3384
3385     wxRichTextObjectList::compatibility_iterator node;
3386
3387 #if wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
3388     wxUnusedVar(style);
3389     wxArrayInt partialExtents;
3390
3391     wxSize paraSize;
3392     int paraDescent;
3393
3394     // This calculates the partial text extents
3395     GetRangeSize(GetRange(), paraSize, paraDescent, dc, wxRICHTEXT_UNFORMATTED|wxRICHTEXT_CACHE_SIZE, wxPoint(0,0), & partialExtents);
3396 #else
3397     node = m_children.GetFirst();
3398     while (node)
3399     {
3400         wxRichTextObject* child = node->GetData();
3401
3402         child->SetCachedSize(wxDefaultSize);
3403         child->Layout(dc, rect, style);
3404
3405         node = node->GetNext();
3406     }
3407
3408 #endif
3409
3410     // Split up lines
3411
3412     // We may need to go back to a previous child, in which case create the new line,
3413     // find the child corresponding to the start position of the string, and
3414     // continue.
3415
3416     node = m_children.GetFirst();
3417     while (node)
3418     {
3419         wxRichTextObject* child = node->GetData();
3420
3421         // If floating, ignore. We already laid out floats.
3422         if (child->IsFloating() || child->GetRange().GetLength() == 0)
3423         {
3424             node = node->GetNext();
3425             continue;
3426         }
3427
3428         // If this is e.g. a composite text box, it will need to be laid out itself.
3429         // But if just a text fragment or image, for example, this will
3430         // do nothing. NB: won't we need to set the position after layout?
3431         // since for example if position is dependent on vertical line size, we
3432         // can't tell the position until the size is determined. So possibly introduce
3433         // another layout phase.
3434
3435         // We may only be looking at part of a child, if we searched back for wrapping
3436         // and found a suitable point some way into the child. So get the size for the fragment
3437         // if necessary.
3438
3439         long nextBreakPos = GetFirstLineBreakPosition(lastEndPos+1);
3440         long lastPosToUse = child->GetRange().GetEnd();
3441         bool lineBreakInThisObject = (nextBreakPos > -1 && nextBreakPos <= child->GetRange().GetEnd());
3442
3443         if (lineBreakInThisObject)
3444             lastPosToUse = nextBreakPos;
3445
3446         wxSize childSize;
3447         int childDescent = 0;
3448
3449         if ((nextBreakPos == -1) && (lastEndPos == child->GetRange().GetStart() - 1)) // i.e. we want to get the whole thing
3450         {
3451             childSize = child->GetCachedSize();
3452             childDescent = child->GetDescent();
3453         }
3454         else
3455         {
3456 #if wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
3457             // Get height only, then the width using the partial extents
3458             GetRangeSize(wxRichTextRange(lastEndPos+1, lastPosToUse), childSize, childDescent, dc, wxRICHTEXT_UNFORMATTED|wxRICHTEXT_HEIGHT_ONLY);
3459             childSize.x = wxRichTextGetRangeWidth(*this, wxRichTextRange(lastEndPos+1, lastPosToUse), partialExtents);
3460 #else
3461             GetRangeSize(wxRichTextRange(lastEndPos+1, lastPosToUse), childSize, childDescent, dc, wxRICHTEXT_UNFORMATTED, rect.GetPosition());
3462 #endif
3463         }
3464
3465         // Available width depends on the floating objects and the line height
3466         // Note: the floating objects may be placed vertically along the two side of
3467         //       buffer, so we may have different available line width with different
3468         //       [startY, endY]. So, we should can't determine how wide the available
3469         //       space is until we know the exact line height.
3470         lineDescent = wxMax(childDescent, maxDescent);
3471         lineAscent = wxMax(childSize.y-childDescent, maxAscent);
3472         lineHeight = lineDescent + lineAscent;
3473         availableRect = collector->GetAvailableRect(rect.y + currentPosition.y, rect.y + currentPosition.y + lineHeight);
3474
3475         currentPosition.x = (lineCount == 0 ? availableRect.x + startPositionFirstLine : availableRect.x + startPositionSubsequentLines);
3476
3477         // Cases:
3478         // 1) There was a line break BEFORE the natural break
3479         // 2) There was a line break AFTER the natural break
3480         // 3) The child still fits (carry on)
3481
3482         if ((lineBreakInThisObject && (childSize.x + currentWidth <= availableRect.width)) ||
3483             (childSize.x + currentWidth > availableRect.width))
3484         {
3485             long wrapPosition = 0;
3486
3487             int indent = lineCount == 0 ? startPositionFirstLine : startPositionSubsequentLines;
3488             indent += rightIndent;
3489             // Find a place to wrap. This may walk back to previous children,
3490             // for example if a word spans several objects.
3491             // Note: one object must contains only one wxTextAtrr, so the line height will not
3492             //       change inside one object. Thus, we can pass the remain line width to the
3493             //       FindWrapPosition function.
3494             if (!FindWrapPosition(wxRichTextRange(lastCompletedEndPos+1, child->GetRange().GetEnd()), dc, availableRect.width - indent, wrapPosition, & partialExtents))
3495             {
3496                 // If the function failed, just cut it off at the end of this child.
3497                 wrapPosition = child->GetRange().GetEnd();
3498             }
3499
3500             // FindWrapPosition can still return a value that will put us in an endless wrapping loop
3501             if (wrapPosition <= lastCompletedEndPos)
3502                 wrapPosition = wxMax(lastCompletedEndPos+1,child->GetRange().GetEnd());
3503
3504             // wxLogDebug(wxT("Split at %ld"), wrapPosition);
3505
3506             // Let's find the actual size of the current line now
3507             wxSize actualSize;
3508             wxRichTextRange actualRange(lastCompletedEndPos+1, wrapPosition);
3509
3510             /// Use previous descent, not the wrapping descent we just found, since this may be too big
3511             /// for the fragment we're about to add.
3512             childDescent = maxDescent;
3513
3514 #if wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
3515             // Get height only, then the width using the partial extents
3516             GetRangeSize(actualRange, actualSize, childDescent, dc, wxRICHTEXT_UNFORMATTED|wxRICHTEXT_HEIGHT_ONLY);
3517             actualSize.x = wxRichTextGetRangeWidth(*this, actualRange, partialExtents);
3518 #else
3519             GetRangeSize(actualRange, actualSize, childDescent, dc, wxRICHTEXT_UNFORMATTED);
3520 #endif
3521
3522             currentWidth = actualSize.x;
3523             maxDescent = wxMax(childDescent, maxDescent);
3524             maxAscent = wxMax(actualSize.y-childDescent, maxAscent);
3525             lineHeight = maxDescent + maxAscent;
3526
3527             // Add a new line
3528             wxRichTextLine* line = AllocateLine(lineCount);
3529
3530             // Set relative range so we won't have to change line ranges when paragraphs are moved
3531             line->SetRange(wxRichTextRange(actualRange.GetStart() - GetRange().GetStart(), actualRange.GetEnd() - GetRange().GetStart()));
3532             line->SetPosition(currentPosition);
3533             line->SetSize(wxSize(currentWidth, lineHeight));
3534             line->SetDescent(maxDescent);
3535
3536             // Now move down a line. TODO: add margins, spacing
3537             currentPosition.y += lineHeight;
3538             currentPosition.y += lineSpacing;
3539             currentWidth = 0;
3540             maxDescent = 0;
3541             maxAscent = 0;
3542             maxWidth = wxMax(maxWidth, currentWidth);
3543
3544             lineCount ++;
3545
3546             // TODO: account for zero-length objects, such as fields
3547             wxASSERT(wrapPosition > lastCompletedEndPos);
3548
3549             lastEndPos = wrapPosition;
3550             lastCompletedEndPos = lastEndPos;
3551
3552             lineHeight = 0;
3553
3554             // May need to set the node back to a previous one, due to searching back in wrapping
3555             wxRichTextObject* childAfterWrapPosition = FindObjectAtPosition(wrapPosition+1);
3556             if (childAfterWrapPosition)
3557                 node = m_children.Find(childAfterWrapPosition);
3558             else
3559                 node = node->GetNext();
3560         }
3561         else
3562         {
3563             // We still fit, so don't add a line, and keep going
3564             currentWidth += childSize.x;
3565             maxDescent = wxMax(childDescent, maxDescent);
3566             maxAscent = wxMax(childSize.y-childDescent, maxAscent);
3567             lineHeight = maxDescent + maxAscent;
3568
3569             maxWidth = wxMax(maxWidth, currentWidth);
3570             lastEndPos = child->GetRange().GetEnd();
3571
3572             node = node->GetNext();
3573         }
3574     }
3575
3576     // Add the last line - it's the current pos -> last para pos
3577     // Substract -1 because the last position is always the end-paragraph position.
3578     if (lastCompletedEndPos <= GetRange().GetEnd()-1)
3579     {
3580         currentPosition.x = (lineCount == 0 ? availableRect.x + startPositionFirstLine : availableRect.x + startPositionSubsequentLines);
3581
3582         wxRichTextLine* line = AllocateLine(lineCount);
3583
3584         wxRichTextRange actualRange(lastCompletedEndPos+1, GetRange().GetEnd()-1);
3585
3586         // Set relative range so we won't have to change line ranges when paragraphs are moved
3587         line->SetRange(wxRichTextRange(actualRange.GetStart() - GetRange().GetStart(), actualRange.GetEnd() - GetRange().GetStart()));
3588
3589         line->SetPosition(currentPosition);
3590
3591         if (lineHeight == 0 && GetBuffer())
3592         {
3593             wxFont font(GetBuffer()->GetFontTable().FindFont(attr));
3594             wxCheckSetFont(dc, font);
3595             lineHeight = dc.GetCharHeight();
3596         }
3597         if (maxDescent == 0)
3598         {
3599             int w, h;
3600             dc.GetTextExtent(wxT("X"), & w, &h, & maxDescent);
3601         }
3602
3603         line->SetSize(wxSize(currentWidth, lineHeight));
3604         line->SetDescent(maxDescent);
3605         currentPosition.y += lineHeight;
3606         currentPosition.y += lineSpacing;
3607         lineCount ++;
3608     }
3609
3610     // Remove remaining unused line objects, if any
3611     ClearUnusedLines(lineCount);
3612
3613     // Apply styles to wrapped lines
3614     ApplyParagraphStyle(attr, rect, dc);
3615
3616     SetCachedSize(wxSize(maxWidth, currentPosition.y + spaceAfterPara));
3617
3618     m_dirty = false;
3619
3620 #if wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
3621 #if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING
3622     // Use the text extents to calculate the size of each fragment in each line
3623     wxRichTextLineList::compatibility_iterator lineNode = m_cachedLines.GetFirst();
3624     while (lineNode)
3625     {
3626         wxRichTextLine* line = lineNode->GetData();
3627         wxRichTextRange lineRange = line->GetAbsoluteRange();
3628
3629         // Loop through objects until we get to the one within range
3630         wxRichTextObjectList::compatibility_iterator node2 = m_children.GetFirst();
3631
3632         while (node2)
3633         {
3634             wxRichTextObject* child = node2->GetData();
3635
3636             if (child->GetRange().GetLength() > 0 && !child->GetRange().IsOutside(lineRange))
3637             {
3638                 wxRichTextRange rangeToUse = lineRange;
3639                 rangeToUse.LimitTo(child->GetRange());
3640
3641                 // Find the size of the child from the text extents, and store in an array
3642                 // for drawing later
3643                 int left = 0;
3644                 if (rangeToUse.GetStart() > GetRange().GetStart())
3645                     left = partialExtents[(rangeToUse.GetStart()-1) - GetRange().GetStart()];
3646                 int right = partialExtents[rangeToUse.GetEnd() - GetRange().GetStart()];
3647                 int sz = right - left;
3648                 line->GetObjectSizes().Add(sz);
3649             }
3650             else if (child->GetRange().GetStart() > lineRange.GetEnd())
3651                 // Can break out of inner loop now since we've passed this line's range
3652                 break;
3653
3654             node2 = node2->GetNext();
3655         }
3656
3657         lineNode = lineNode->GetNext();
3658     }
3659 #endif
3660 #endif
3661
3662     return true;
3663 }
3664
3665 /// Apply paragraph styles, such as centering, to wrapped lines
3666 void wxRichTextParagraph::ApplyParagraphStyle(const wxRichTextAttr& attr, const wxRect& rect, wxDC& dc)
3667 {
3668     if (!attr.HasAlignment())
3669         return;
3670
3671     wxRichTextLineList::compatibility_iterator node = m_cachedLines.GetFirst();
3672     while (node)
3673     {
3674         wxRichTextLine* line = node->GetData();
3675
3676         wxPoint pos = line->GetPosition();
3677         wxSize size = line->GetSize();
3678
3679         // centering, right-justification
3680         if (attr.HasAlignment() && GetAttributes().GetAlignment() == wxTEXT_ALIGNMENT_CENTRE)
3681         {
3682             int rightIndent = ConvertTenthsMMToPixels(dc, attr.GetRightIndent());
3683             pos.x = (rect.GetWidth() - pos.x - rightIndent - size.x)/2 + pos.x;
3684             line->SetPosition(pos);
3685         }
3686         else if (attr.HasAlignment() && GetAttributes().GetAlignment() == wxTEXT_ALIGNMENT_RIGHT)
3687         {
3688             int rightIndent = ConvertTenthsMMToPixels(dc, attr.GetRightIndent());
3689             pos.x = rect.GetWidth() - size.x - rightIndent;
3690             line->SetPosition(pos);
3691         }
3692
3693         node = node->GetNext();
3694     }
3695 }
3696
3697 /// Insert text at the given position
3698 bool wxRichTextParagraph::InsertText(long pos, const wxString& text)
3699 {
3700     wxRichTextObject* childToUse = NULL;
3701     wxRichTextObjectList::compatibility_iterator nodeToUse = wxRichTextObjectList::compatibility_iterator();
3702
3703     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
3704     while (node)
3705     {
3706         wxRichTextObject* child = node->GetData();
3707         if (child->GetRange().Contains(pos) && child->GetRange().GetLength() > 0)
3708         {
3709             childToUse = child;
3710             nodeToUse = node;
3711             break;
3712         }
3713
3714         node = node->GetNext();
3715     }
3716
3717     if (childToUse)
3718     {
3719         wxRichTextPlainText* textObject = wxDynamicCast(childToUse, wxRichTextPlainText);
3720         if (textObject)
3721         {
3722             int posInString = pos - textObject->GetRange().GetStart();
3723
3724             wxString newText = textObject->GetText().Mid(0, posInString) +
3725                                text + textObject->GetText().Mid(posInString);
3726             textObject->SetText(newText);
3727
3728             int textLength = text.length();
3729
3730             textObject->SetRange(wxRichTextRange(textObject->GetRange().GetStart(),
3731                                                  textObject->GetRange().GetEnd() + textLength));
3732
3733             // Increment the end range of subsequent fragments in this paragraph.
3734             // We'll set the paragraph range itself at a higher level.
3735
3736             wxRichTextObjectList::compatibility_iterator node = nodeToUse->GetNext();
3737             while (node)
3738             {
3739                 wxRichTextObject* child = node->GetData();
3740                 child->SetRange(wxRichTextRange(textObject->GetRange().GetStart() + textLength,
3741                                                  textObject->GetRange().GetEnd() + textLength));
3742
3743                 node = node->GetNext();
3744             }
3745
3746             return true;
3747         }
3748         else
3749         {
3750             // TODO: if not a text object, insert at closest position, e.g. in front of it
3751         }
3752     }
3753     else
3754     {
3755         // Add at end.
3756         // Don't pass parent initially to suppress auto-setting of parent range.
3757         // We'll do that at a higher level.
3758         wxRichTextPlainText* textObject = new wxRichTextPlainText(text, this);
3759
3760         AppendChild(textObject);
3761         return true;
3762     }
3763
3764     return false;
3765 }
3766
3767 void wxRichTextParagraph::Copy(const wxRichTextParagraph& obj)
3768 {
3769     wxRichTextBox::Copy(obj);
3770 }
3771
3772 /// Clear the cached lines
3773 void wxRichTextParagraph::ClearLines()
3774 {
3775     WX_CLEAR_LIST(wxRichTextLineList, m_cachedLines);
3776 }
3777
3778 /// Get/set the object size for the given range. Returns false if the range
3779 /// is invalid for this object.
3780 bool wxRichTextParagraph::GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position, wxArrayInt* partialExtents) const
3781 {
3782     if (!range.IsWithin(GetRange()))
3783         return false;
3784
3785     if (flags & wxRICHTEXT_UNFORMATTED)
3786     {
3787         // Just use unformatted data, assume no line breaks
3788         // TODO: take into account line breaks
3789
3790         wxSize sz;
3791
3792         wxArrayInt childExtents;
3793         wxArrayInt* p;
3794         if (partialExtents)
3795             p = & childExtents;
3796         else
3797             p = NULL;
3798
3799         wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
3800         while (node)
3801         {
3802
3803             wxRichTextObject* child = node->GetData();
3804             if (!child->GetRange().IsOutside(range))
3805             {
3806                 // Floating objects have a zero size within the paragraph.
3807                 if (child->IsFloating())
3808                 {
3809                     if (partialExtents)
3810                     {
3811                         int lastSize;
3812                         if (partialExtents->GetCount() > 0)
3813                             lastSize = (*partialExtents)[partialExtents->GetCount()-1];
3814                         else
3815                             lastSize = 0;
3816
3817                         partialExtents->Add(0 /* zero size */ + lastSize);
3818                     }
3819                 }
3820                 else
3821                 {
3822                 wxSize childSize;
3823
3824                 wxRichTextRange rangeToUse = range;
3825                 rangeToUse.LimitTo(child->GetRange());
3826                 int childDescent = 0;
3827
3828                 // At present wxRICHTEXT_HEIGHT_ONLY is only fast if we're already cached the size,
3829                 // but it's only going to be used after caching has taken place.
3830                 if ((flags & wxRICHTEXT_HEIGHT_ONLY) && child->GetCachedSize().y != 0)
3831                 {
3832                     childDescent = child->GetDescent();
3833                     childSize = child->GetCachedSize();
3834
3835                     sz.y = wxMax(sz.y, childSize.y);
3836                     sz.x += childSize.x;
3837                     descent = wxMax(descent, childDescent);
3838                 }
3839                 else if (child->GetRangeSize(rangeToUse, childSize, childDescent, dc, flags, wxPoint(position.x + sz.x, position.y), p))
3840                 {
3841                     sz.y = wxMax(sz.y, childSize.y);
3842                     sz.x += childSize.x;
3843                     descent = wxMax(descent, childDescent);
3844
3845                     if ((flags & wxRICHTEXT_CACHE_SIZE) && (rangeToUse == child->GetRange()))
3846                     {
3847                         child->SetCachedSize(childSize);
3848                         child->SetDescent(childDescent);
3849                     }
3850
3851                     if (partialExtents)
3852                     {
3853                         int lastSize;
3854                         if (partialExtents->GetCount() > 0)
3855                             lastSize = (*partialExtents)[partialExtents->GetCount()-1];
3856                         else
3857                             lastSize = 0;
3858
3859                         size_t i;
3860                         for (i = 0; i < childExtents.GetCount(); i++)
3861                         {
3862                             partialExtents->Add(childExtents[i] + lastSize);
3863                         }
3864                     }
3865                 }
3866                 }
3867
3868                 if (p)
3869                     p->Clear();
3870             }
3871
3872             node = node->GetNext();
3873         }
3874         size = sz;
3875     }
3876     else
3877     {
3878         // Use formatted data, with line breaks
3879         wxSize sz;
3880
3881         // We're going to loop through each line, and then for each line,
3882         // call GetRangeSize for the fragment that comprises that line.
3883         // Only we have to do that multiple times within the line, because
3884         // the line may be broken into pieces. For now ignore line break commands
3885         // (so we can assume that getting the unformatted size for a fragment
3886         // within a line is the actual size)
3887
3888         wxRichTextLineList::compatibility_iterator node = m_cachedLines.GetFirst();
3889         while (node)
3890         {
3891             wxRichTextLine* line = node->GetData();
3892             wxRichTextRange lineRange = line->GetAbsoluteRange();
3893             if (!lineRange.IsOutside(range))
3894             {
3895                 wxSize lineSize;
3896
3897                 wxRichTextObjectList::compatibility_iterator node2 = m_children.GetFirst();
3898                 while (node2)
3899                 {
3900                     wxRichTextObject* child = node2->GetData();
3901
3902                     if (!child->IsFloating() && !child->GetRange().IsOutside(lineRange))
3903                     {
3904                         wxRichTextRange rangeToUse = lineRange;
3905                         rangeToUse.LimitTo(child->GetRange());
3906
3907                         wxSize childSize;
3908                         int childDescent = 0;
3909                         if (child->GetRangeSize(rangeToUse, childSize, childDescent, dc, flags, wxPoint(position.x + sz.x, position.y)))
3910                         {
3911                             lineSize.y = wxMax(lineSize.y, childSize.y);
3912                             lineSize.x += childSize.x;
3913                         }
3914                         descent = wxMax(descent, childDescent);
3915                     }
3916
3917                     node2 = node2->GetNext();
3918                 }
3919
3920                 // Increase size by a line (TODO: paragraph spacing)
3921                 sz.y += lineSize.y;
3922                 sz.x = wxMax(sz.x, lineSize.x);
3923             }
3924             node = node->GetNext();
3925         }
3926         size = sz;
3927     }
3928     return true;
3929 }
3930
3931 /// Finds the absolute position and row height for the given character position
3932 bool wxRichTextParagraph::FindPosition(wxDC& dc, long index, wxPoint& pt, int* height, bool forceLineStart)
3933 {
3934     if (index == -1)
3935     {
3936         wxRichTextLine* line = ((wxRichTextParagraphLayoutBox*)GetParent())->GetLineAtPosition(0);
3937         if (line)
3938             *height = line->GetSize().y;
3939         else
3940             *height = dc.GetCharHeight();
3941
3942         // -1 means 'the start of the buffer'.
3943         pt = GetPosition();
3944         if (line)
3945             pt = pt + line->GetPosition();
3946
3947         return true;
3948     }
3949
3950     // The final position in a paragraph is taken to mean the position
3951     // at the start of the next paragraph.
3952     if (index == GetRange().GetEnd())
3953     {
3954         wxRichTextParagraphLayoutBox* parent = wxDynamicCast(GetParent(), wxRichTextParagraphLayoutBox);
3955         wxASSERT( parent != NULL );
3956
3957         // Find the height at the next paragraph, if any
3958         wxRichTextLine* line = parent->GetLineAtPosition(index + 1);
3959         if (line)
3960         {
3961             *height = line->GetSize().y;
3962             pt = line->GetAbsolutePosition();
3963         }
3964         else
3965         {
3966             *height = dc.GetCharHeight();
3967             int indent = ConvertTenthsMMToPixels(dc, m_attributes.GetLeftIndent());
3968             pt = wxPoint(indent, GetCachedSize().y);
3969         }
3970
3971         return true;
3972     }
3973
3974     if (index < GetRange().GetStart() || index > GetRange().GetEnd())
3975         return false;
3976
3977     wxRichTextLineList::compatibility_iterator node = m_cachedLines.GetFirst();
3978     while (node)
3979     {
3980         wxRichTextLine* line = node->GetData();
3981         wxRichTextRange lineRange = line->GetAbsoluteRange();
3982         if (index >= lineRange.GetStart() && index <= lineRange.GetEnd())
3983         {
3984             // If this is the last point in the line, and we're forcing the
3985             // returned value to be the start of the next line, do the required
3986             // thing.
3987             if (index == lineRange.GetEnd() && forceLineStart)
3988             {
3989                 if (node->GetNext())
3990                 {
3991                     wxRichTextLine* nextLine = node->GetNext()->GetData();
3992                     *height = nextLine->GetSize().y;
3993                     pt = nextLine->GetAbsolutePosition();
3994                     return true;
3995                 }
3996             }
3997
3998             pt.y = line->GetPosition().y + GetPosition().y;
3999
4000             wxRichTextRange r(lineRange.GetStart(), index);
4001             wxSize rangeSize;
4002             int descent = 0;
4003
4004             // We find the size of the line up to this point,
4005             // then we can add this size to the line start position and
4006             // paragraph start position to find the actual position.
4007
4008             if (GetRangeSize(r, rangeSize, descent, dc, wxRICHTEXT_UNFORMATTED, line->GetPosition()+ GetPosition()))
4009             {
4010                 pt.x = line->GetPosition().x + GetPosition().x + rangeSize.x;
4011                 *height = line->GetSize().y;
4012
4013                 return true;
4014             }
4015
4016         }
4017
4018         node = node->GetNext();
4019     }
4020
4021     return false;
4022 }
4023
4024 /// Hit-testing: returns a flag indicating hit test details, plus
4025 /// information about position
4026 int wxRichTextParagraph::HitTest(wxDC& dc, const wxPoint& pt, long& textPosition)
4027 {
4028     wxPoint paraPos = GetPosition();
4029
4030     wxRichTextLineList::compatibility_iterator node = m_cachedLines.GetFirst();
4031     while (node)
4032     {
4033         wxRichTextLine* line = node->GetData();
4034         wxPoint linePos = paraPos + line->GetPosition();
4035         wxSize lineSize = line->GetSize();
4036         wxRichTextRange lineRange = line->GetAbsoluteRange();
4037
4038         if (pt.y <= linePos.y + lineSize.y)
4039         {
4040             if (pt.x < linePos.x)
4041             {
4042                 textPosition = lineRange.GetStart();
4043                 return wxRICHTEXT_HITTEST_BEFORE|wxRICHTEXT_HITTEST_OUTSIDE;
4044             }
4045             else if (pt.x >= (linePos.x + lineSize.x))
4046             {
4047                 textPosition = lineRange.GetEnd();
4048                 return wxRICHTEXT_HITTEST_AFTER|wxRICHTEXT_HITTEST_OUTSIDE;
4049             }
4050             else
4051             {
4052 #if wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
4053                 wxArrayInt partialExtents;
4054
4055                 wxSize paraSize;
4056                 int paraDescent;
4057
4058                 // This calculates the partial text extents
4059                 GetRangeSize(lineRange, paraSize, paraDescent, dc, wxRICHTEXT_UNFORMATTED, wxPoint(0,0), & partialExtents);
4060
4061                 int lastX = linePos.x;
4062                 size_t i;
4063                 for (i = 0; i < partialExtents.GetCount(); i++)
4064                 {
4065                     int nextX = partialExtents[i] + linePos.x;
4066
4067                     if (pt.x >= lastX && pt.x <= nextX)
4068                     {
4069                         textPosition = i + lineRange.GetStart(); // minus 1?
4070
4071                         // So now we know it's between i-1 and i.
4072                         // Let's see if we can be more precise about
4073                         // which side of the position it's on.
4074
4075                         int midPoint = (nextX + lastX)/2;
4076                         if (pt.x >= midPoint)
4077                             return wxRICHTEXT_HITTEST_AFTER;
4078                         else
4079                             return wxRICHTEXT_HITTEST_BEFORE;
4080                     }
4081
4082                     lastX = nextX;
4083                 }
4084 #else
4085                 long i;
4086                 int lastX = linePos.x;
4087                 for (i = lineRange.GetStart(); i <= lineRange.GetEnd(); i++)
4088                 {
4089                     wxSize childSize;
4090                     int descent = 0;
4091
4092                     wxRichTextRange rangeToUse(lineRange.GetStart(), i);
4093
4094                     GetRangeSize(rangeToUse, childSize, descent, dc, wxRICHTEXT_UNFORMATTED, linePos);
4095
4096                     int nextX = childSize.x + linePos.x;
4097
4098                     if (pt.x >= lastX && pt.x <= nextX)
4099                     {
4100                         textPosition = i;
4101
4102                         // So now we know it's between i-1 and i.
4103                         // Let's see if we can be more precise about
4104                         // which side of the position it's on.
4105
4106                         int midPoint = (nextX + lastX)/2;
4107                         if (pt.x >= midPoint)
4108                             return wxRICHTEXT_HITTEST_AFTER;
4109                         else
4110                             return wxRICHTEXT_HITTEST_BEFORE;
4111                     }
4112                     else
4113                     {
4114                         lastX = nextX;
4115                     }
4116                 }
4117 #endif
4118             }
4119         }
4120
4121         node = node->GetNext();
4122     }
4123
4124     return wxRICHTEXT_HITTEST_NONE;
4125 }
4126
4127 /// Split an object at this position if necessary, and return
4128 /// the previous object, or NULL if inserting at beginning.
4129 wxRichTextObject* wxRichTextParagraph::SplitAt(long pos, wxRichTextObject** previousObject)
4130 {
4131     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
4132     while (node)
4133     {
4134         wxRichTextObject* child = node->GetData();
4135
4136         if (pos == child->GetRange().GetStart())
4137         {
4138             if (previousObject)
4139             {
4140                 if (node->GetPrevious())
4141                     *previousObject = node->GetPrevious()->GetData();
4142                 else
4143                     *previousObject = NULL;
4144             }
4145
4146             return child;
4147         }
4148
4149         if (child->GetRange().Contains(pos))
4150         {
4151             // This should create a new object, transferring part of
4152             // the content to the old object and the rest to the new object.
4153             wxRichTextObject* newObject = child->DoSplit(pos);
4154
4155             // If we couldn't split this object, just insert in front of it.
4156             if (!newObject)
4157             {
4158                 // Maybe this is an empty string, try the next one
4159                 // return child;
4160             }
4161             else
4162             {
4163                 // Insert the new object after 'child'
4164                 if (node->GetNext())
4165                     m_children.Insert(node->GetNext(), newObject);
4166                 else
4167                     m_children.Append(newObject);
4168                 newObject->SetParent(this);
4169
4170                 if (previousObject)
4171                     *previousObject = child;
4172
4173                 return newObject;
4174             }
4175         }
4176
4177         node = node->GetNext();
4178     }
4179     if (previousObject)
4180         *previousObject = NULL;
4181     return NULL;
4182 }
4183
4184 /// Move content to a list from obj on
4185 void wxRichTextParagraph::MoveToList(wxRichTextObject* obj, wxList& list)
4186 {
4187     wxRichTextObjectList::compatibility_iterator node = m_children.Find(obj);
4188     while (node)
4189     {
4190         wxRichTextObject* child = node->GetData();
4191         list.Append(child);
4192
4193         wxRichTextObjectList::compatibility_iterator oldNode = node;
4194
4195         node = node->GetNext();
4196
4197         m_children.DeleteNode(oldNode);
4198     }
4199 }
4200
4201 /// Add content back from list
4202 void wxRichTextParagraph::MoveFromList(wxList& list)
4203 {
4204     for (wxList::compatibility_iterator node = list.GetFirst(); node; node = node->GetNext())
4205     {
4206         AppendChild((wxRichTextObject*) node->GetData());
4207     }
4208 }
4209
4210 /// Calculate range
4211 void wxRichTextParagraph::CalculateRange(long start, long& end)
4212 {
4213     wxRichTextCompositeObject::CalculateRange(start, end);
4214
4215     // Add one for end of paragraph
4216     end ++;
4217
4218     m_range.SetRange(start, end);
4219 }
4220
4221 /// Find the object at the given position
4222 wxRichTextObject* wxRichTextParagraph::FindObjectAtPosition(long position)
4223 {
4224     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
4225     while (node)
4226     {
4227         wxRichTextObject* obj = node->GetData();
4228         if (obj->GetRange().Contains(position))
4229             return obj;
4230
4231         node = node->GetNext();
4232     }
4233     return NULL;
4234 }
4235
4236 /// Get the plain text searching from the start or end of the range.
4237 /// The resulting string may be shorter than the range given.
4238 bool wxRichTextParagraph::GetContiguousPlainText(wxString& text, const wxRichTextRange& range, bool fromStart)
4239 {
4240     text = wxEmptyString;
4241
4242     if (fromStart)
4243     {
4244         wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
4245         while (node)
4246         {
4247             wxRichTextObject* obj = node->GetData();
4248             if (!obj->GetRange().IsOutside(range))
4249             {
4250                 wxRichTextPlainText* textObj = wxDynamicCast(obj, wxRichTextPlainText);
4251                 if (textObj)
4252                 {
4253                     text += textObj->GetTextForRange(range);
4254                 }
4255                 else
4256                 {
4257                     text += wxT(" ");
4258                 }
4259             }
4260
4261             node = node->GetNext();
4262         }
4263     }
4264     else
4265     {
4266         wxRichTextObjectList::compatibility_iterator node = m_children.GetLast();
4267         while (node)
4268         {
4269             wxRichTextObject* obj = node->GetData();
4270             if (!obj->GetRange().IsOutside(range))
4271             {
4272                 wxRichTextPlainText* textObj = wxDynamicCast(obj, wxRichTextPlainText);
4273                 if (textObj)
4274                 {
4275                     text = textObj->GetTextForRange(range) + text;
4276                 }
4277                 else
4278                 {
4279                     text = wxT(" ") + text;
4280                 }
4281             }
4282
4283             node = node->GetPrevious();
4284         }
4285     }
4286
4287     return true;
4288 }
4289
4290 /// Find a suitable wrap position.
4291 bool wxRichTextParagraph::FindWrapPosition(const wxRichTextRange& range, wxDC& dc, int availableSpace, long& wrapPosition, wxArrayInt* partialExtents)
4292 {
4293     if (range.GetLength() <= 0)
4294         return false;
4295
4296     // Find the first position where the line exceeds the available space.
4297     wxSize sz;
4298     long breakPosition = range.GetEnd();
4299
4300 #if wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
4301     if (partialExtents && partialExtents->GetCount() >= (size_t) (GetRange().GetLength()-1)) // the final position in a paragraph is the newline
4302     {
4303         int widthBefore;
4304
4305         if (range.GetStart() > GetRange().GetStart())
4306             widthBefore = (*partialExtents)[range.GetStart() - GetRange().GetStart() - 1];
4307         else
4308             widthBefore = 0;
4309
4310         size_t i;
4311         for (i = (size_t) range.GetStart(); i <= (size_t) range.GetEnd(); i++)
4312         {
4313             int widthFromStartOfThisRange = (*partialExtents)[i - GetRange().GetStart()] - widthBefore;
4314
4315             if (widthFromStartOfThisRange > availableSpace)
4316             {
4317                 breakPosition = i-1;
4318                 break;
4319             }
4320         }
4321     }
4322     else
4323 #endif
4324     {
4325         // Binary chop for speed
4326         long minPos = range.GetStart();
4327         long maxPos = range.GetEnd();
4328         while (true)
4329         {
4330             if (minPos == maxPos)
4331             {
4332                 int descent = 0;
4333                 GetRangeSize(wxRichTextRange(range.GetStart(), minPos), sz, descent, dc, wxRICHTEXT_UNFORMATTED);
4334
4335                 if (sz.x > availableSpace)
4336                     breakPosition = minPos - 1;
4337                 break;
4338             }
4339             else if ((maxPos - minPos) == 1)
4340             {
4341                 int descent = 0;
4342                 GetRangeSize(wxRichTextRange(range.GetStart(), minPos), sz, descent, dc, wxRICHTEXT_UNFORMATTED);
4343
4344                 if (sz.x > availableSpace)
4345                     breakPosition = minPos - 1;
4346                 else
4347                 {
4348                     GetRangeSize(wxRichTextRange(range.GetStart(), maxPos), sz, descent, dc, wxRICHTEXT_UNFORMATTED);
4349                     if (sz.x > availableSpace)
4350                         breakPosition = maxPos-1;
4351                 }
4352                 break;
4353             }
4354             else
4355             {
4356                 long nextPos = minPos + ((maxPos - minPos) / 2);
4357
4358                 int descent = 0;
4359                 GetRangeSize(wxRichTextRange(range.GetStart(), nextPos), sz, descent, dc, wxRICHTEXT_UNFORMATTED);
4360
4361                 if (sz.x > availableSpace)
4362                 {
4363                     maxPos = nextPos;
4364                 }
4365                 else
4366                 {
4367                     minPos = nextPos;
4368                 }
4369             }
4370         }
4371     }
4372
4373     // Now we know the last position on the line.
4374     // Let's try to find a word break.
4375
4376     wxString plainText;
4377     if (GetContiguousPlainText(plainText, wxRichTextRange(range.GetStart(), breakPosition), false))
4378     {
4379         int newLinePos = plainText.Find(wxRichTextLineBreakChar);
4380         if (newLinePos != wxNOT_FOUND)
4381         {
4382             breakPosition = wxMax(0, range.GetStart() + newLinePos);
4383         }
4384         else
4385         {
4386             int spacePos = plainText.Find(wxT(' '), true);
4387             int tabPos = plainText.Find(wxT('\t'), true);
4388             int pos = wxMax(spacePos, tabPos);
4389             if (pos != wxNOT_FOUND)
4390             {
4391                 int positionsFromEndOfString = plainText.length() - pos - 1;
4392                 breakPosition = breakPosition - positionsFromEndOfString;
4393             }
4394         }
4395     }
4396
4397     wrapPosition = breakPosition;
4398
4399     return true;
4400 }
4401
4402 /// Get the bullet text for this paragraph.
4403 wxString wxRichTextParagraph::GetBulletText()
4404 {
4405     if (GetAttributes().GetBulletStyle() == wxTEXT_ATTR_BULLET_STYLE_NONE ||
4406         (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_BITMAP))
4407         return wxEmptyString;
4408
4409     int number = GetAttributes().GetBulletNumber();
4410
4411     wxString text;
4412     if ((GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ARABIC) || (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_OUTLINE))
4413     {
4414         text.Printf(wxT("%d"), number);
4415     }
4416     else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_LETTERS_UPPER)
4417     {
4418         // TODO: Unicode, and also check if number > 26
4419         text.Printf(wxT("%c"), (wxChar) (number+64));
4420     }
4421     else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_LETTERS_LOWER)
4422     {
4423         // TODO: Unicode, and also check if number > 26
4424         text.Printf(wxT("%c"), (wxChar) (number+96));
4425     }
4426     else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ROMAN_UPPER)
4427     {
4428         text = wxRichTextDecimalToRoman(number);
4429     }
4430     else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ROMAN_LOWER)
4431     {
4432         text = wxRichTextDecimalToRoman(number);
4433         text.MakeLower();
4434     }
4435     else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_SYMBOL)
4436     {
4437         text = GetAttributes().GetBulletText();
4438     }
4439
4440     if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_OUTLINE)
4441     {
4442         // The outline style relies on the text being computed statically,
4443         // since it depends on other levels points (e.g. 1.2.1.1). So normally the bullet text
4444         // should be stored in the attributes; if not, just use the number for this
4445         // level, as previously computed.
4446         if (!GetAttributes().GetBulletText().IsEmpty())
4447             text = GetAttributes().GetBulletText();
4448     }
4449
4450     if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_PARENTHESES)
4451     {
4452         text = wxT("(") + text + wxT(")");
4453     }
4454     else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_RIGHT_PARENTHESIS)
4455     {
4456         text = text + wxT(")");
4457     }
4458
4459     if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_PERIOD)
4460     {
4461         text += wxT(".");
4462     }
4463
4464     return text;
4465 }
4466
4467 /// Allocate or reuse a line object
4468 wxRichTextLine* wxRichTextParagraph::AllocateLine(int pos)
4469 {
4470     if (pos < (int) m_cachedLines.GetCount())
4471     {
4472         wxRichTextLine* line = m_cachedLines.Item(pos)->GetData();
4473         line->Init(this);
4474         return line;
4475     }
4476     else
4477     {
4478         wxRichTextLine* line = new wxRichTextLine(this);
4479         m_cachedLines.Append(line);
4480         return line;
4481     }
4482 }
4483
4484 /// Clear remaining unused line objects, if any
4485 bool wxRichTextParagraph::ClearUnusedLines(int lineCount)
4486 {
4487     int cachedLineCount = m_cachedLines.GetCount();
4488     if ((int) cachedLineCount > lineCount)
4489     {
4490         for (int i = 0; i < (int) (cachedLineCount - lineCount); i ++)
4491         {
4492             wxRichTextLineList::compatibility_iterator node = m_cachedLines.GetLast();
4493             wxRichTextLine* line = node->GetData();
4494             m_cachedLines.Erase(node);
4495             delete line;
4496         }
4497     }
4498     return true;
4499 }
4500
4501 /// Get combined attributes of the base style, paragraph style and character style. We use this to dynamically
4502 /// retrieve the actual style.
4503 wxRichTextAttr wxRichTextParagraph::GetCombinedAttributes(const wxRichTextAttr& contentStyle) const
4504 {
4505     wxRichTextAttr attr;
4506     wxRichTextBuffer* buf = wxDynamicCast(GetParent(), wxRichTextBuffer);
4507     if (buf)
4508     {
4509         attr = buf->GetBasicStyle();
4510         wxRichTextApplyStyle(attr, GetAttributes());
4511     }
4512     else
4513         attr = GetAttributes();
4514
4515     wxRichTextApplyStyle(attr, contentStyle);
4516     return attr;
4517 }
4518
4519 /// Get combined attributes of the base style and paragraph style.
4520 wxRichTextAttr wxRichTextParagraph::GetCombinedAttributes() const
4521 {
4522     wxRichTextAttr attr;
4523     wxRichTextBuffer* buf = wxDynamicCast(GetParent(), wxRichTextBuffer);
4524     if (buf)
4525     {
4526         attr = buf->GetBasicStyle();
4527         wxRichTextApplyStyle(attr, GetAttributes());
4528     }
4529     else
4530         attr = GetAttributes();
4531
4532     return attr;
4533 }
4534
4535 /// Create default tabstop array
4536 void wxRichTextParagraph::InitDefaultTabs()
4537 {
4538     // create a default tab list at 10 mm each.
4539     for (int i = 0; i < 20; ++i)
4540     {
4541         sm_defaultTabs.Add(i*100);
4542     }
4543 }
4544
4545 /// Clear default tabstop array
4546 void wxRichTextParagraph::ClearDefaultTabs()
4547 {
4548     sm_defaultTabs.Clear();
4549 }
4550
4551 void wxRichTextParagraph::LayoutFloat(wxDC& dc, const wxRect& rect, int style, wxRichTextFloatCollector* floatCollector)
4552 {
4553     wxRichTextObjectList::compatibility_iterator node = GetChildren().GetFirst();
4554     while (node)
4555     {
4556         wxRichTextAnchoredObject* anchored = wxDynamicCast(node->GetData(), wxRichTextAnchoredObject);
4557         if (anchored && anchored->IsFloating())
4558         {
4559             wxSize size;
4560             int descent, x = 0;
4561             anchored->GetRangeSize(anchored->GetRange(), size, descent, dc, style);
4562
4563             int offsetY = 0;
4564             if (anchored->GetAttributes().GetTextBoxAttr().GetTop().IsPresent())
4565             {
4566                 offsetY = anchored->GetAttributes().GetTextBoxAttr().GetTop().GetValue();
4567                 if (anchored->GetAttributes().GetTextBoxAttr().GetTop().GetUnits() == wxTEXT_ATTR_UNITS_TENTHS_MM)
4568                 {
4569                     offsetY = ConvertTenthsMMToPixels(dc, offsetY);
4570                 }
4571             }
4572
4573             int pos = floatCollector->GetFitPosition(anchored->GetAttributes().GetTextBoxAttr().GetFloatMode(), rect.y + offsetY, size.y);
4574
4575             /* Update the offset */
4576             int newOffsetY = pos - rect.y;
4577             if (newOffsetY != offsetY)
4578             {
4579                 if (anchored->GetAttributes().GetTextBoxAttr().GetTop().GetUnits() == wxTEXT_ATTR_UNITS_TENTHS_MM)
4580                     newOffsetY = ConvertPixelsToTenthsMM(dc, newOffsetY);
4581                 anchored->GetAttributes().GetTextBoxAttr().GetTop().SetValue(newOffsetY);
4582             }
4583
4584             // attr.m_offset = pos - rect.y;
4585             //anchored->SetAnchoredAttr(attr);
4586
4587             if (anchored->GetAttributes().GetTextBoxAttr().GetFloatMode() == wxTEXT_BOX_ATTR_FLOAT_LEFT)
4588                 x = 0;
4589             else if (anchored->GetAttributes().GetTextBoxAttr().GetFloatMode() == wxTEXT_BOX_ATTR_FLOAT_RIGHT)
4590                 x = rect.width - size.x;
4591
4592             anchored->SetPosition(wxPoint(x, pos));
4593             anchored->SetCachedSize(size);
4594             floatCollector->CollectFloat(this, anchored);
4595         }
4596
4597         node = node->GetNext();
4598     }
4599 }
4600
4601 /// Get the first position from pos that has a line break character.
4602 long wxRichTextParagraph::GetFirstLineBreakPosition(long pos)
4603 {
4604     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
4605     while (node)
4606     {
4607         wxRichTextObject* obj = node->GetData();
4608         if (pos >= obj->GetRange().GetStart() && pos <= obj->GetRange().GetEnd())
4609         {
4610             wxRichTextPlainText* textObj = wxDynamicCast(obj, wxRichTextPlainText);
4611             if (textObj)
4612             {
4613                 long breakPos = textObj->GetFirstLineBreakPosition(pos);
4614                 if (breakPos > -1)
4615                     return breakPos;
4616             }
4617         }
4618         node = node->GetNext();
4619     }
4620     return -1;
4621 }
4622
4623 /*!
4624  * wxRichTextLine
4625  * This object represents a line in a paragraph, and stores
4626  * offsets from the start of the paragraph representing the
4627  * start and end positions of the line.
4628  */
4629
4630 wxRichTextLine::wxRichTextLine(wxRichTextParagraph* parent)
4631 {
4632     Init(parent);
4633 }
4634
4635 /// Initialisation
4636 void wxRichTextLine::Init(wxRichTextParagraph* parent)
4637 {
4638     m_parent = parent;
4639     m_range.SetRange(-1, -1);
4640     m_pos = wxPoint(0, 0);
4641     m_size = wxSize(0, 0);
4642     m_descent = 0;
4643 #if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING
4644     m_objectSizes.Clear();
4645 #endif
4646 }
4647
4648 /// Copy
4649 void wxRichTextLine::Copy(const wxRichTextLine& obj)
4650 {
4651     m_range = obj.m_range;
4652 #if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING
4653     m_objectSizes = obj.m_objectSizes;
4654 #endif
4655 }
4656
4657 /// Get the absolute object position
4658 wxPoint wxRichTextLine::GetAbsolutePosition() const
4659 {
4660     return m_parent->GetPosition() + m_pos;
4661 }
4662
4663 /// Get the absolute range
4664 wxRichTextRange wxRichTextLine::GetAbsoluteRange() const
4665 {
4666     wxRichTextRange range(m_range.GetStart() + m_parent->GetRange().GetStart(), 0);
4667     range.SetEnd(range.GetStart() + m_range.GetLength()-1);
4668     return range;
4669 }
4670
4671 /*!
4672  * wxRichTextPlainText
4673  * This object represents a single piece of text.
4674  */
4675
4676 IMPLEMENT_DYNAMIC_CLASS(wxRichTextPlainText, wxRichTextObject)
4677
4678 wxRichTextPlainText::wxRichTextPlainText(const wxString& text, wxRichTextObject* parent, wxRichTextAttr* style):
4679     wxRichTextObject(parent)
4680 {
4681     if (style)
4682         SetAttributes(*style);
4683
4684     m_text = text;
4685 }
4686
4687 #define USE_KERNING_FIX 1
4688
4689 // If insufficient tabs are defined, this is the tab width used
4690 #define WIDTH_FOR_DEFAULT_TABS 50
4691
4692 /// Draw the item
4693 bool wxRichTextPlainText::Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int WXUNUSED(style))
4694 {
4695     wxRichTextParagraph* para = wxDynamicCast(GetParent(), wxRichTextParagraph);
4696     wxASSERT (para != NULL);
4697
4698     wxRichTextAttr textAttr(para ? para->GetCombinedAttributes(GetAttributes()) : GetAttributes());
4699
4700     int offset = GetRange().GetStart();
4701
4702     // Replace line break characters with spaces
4703     wxString str = m_text;
4704     wxString toRemove = wxRichTextLineBreakChar;
4705     str.Replace(toRemove, wxT(" "));
4706     if (textAttr.HasTextEffects() && (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_CAPITALS))
4707         str.MakeUpper();
4708
4709     long len = range.GetLength();
4710     wxString stringChunk = str.Mid(range.GetStart() - offset, (size_t) len);
4711
4712     // Test for the optimized situations where all is selected, or none
4713     // is selected.
4714
4715     wxFont textFont(GetBuffer()->GetFontTable().FindFont(textAttr));
4716     wxCheckSetFont(dc, textFont);
4717     int charHeight = dc.GetCharHeight();
4718
4719     int x, y;
4720     if ( textFont.Ok() )
4721     {
4722         if ( textAttr.HasTextEffects() && (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_SUPERSCRIPT) )
4723         {
4724             double size = static_cast<double>(textFont.GetPointSize()) / wxSCRIPT_MUL_FACTOR;
4725             textFont.SetPointSize( static_cast<int>(size) );
4726             x = rect.x;
4727             y = rect.y;
4728             wxCheckSetFont(dc, textFont);
4729         }
4730         else if ( textAttr.HasTextEffects() && (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_SUBSCRIPT) )
4731         {
4732             double size = static_cast<double>(textFont.GetPointSize()) / wxSCRIPT_MUL_FACTOR;
4733             textFont.SetPointSize( static_cast<int>(size) );
4734             x = rect.x;
4735             int sub_height = static_cast<int>( static_cast<double>(charHeight) / wxSCRIPT_MUL_FACTOR);
4736             y = rect.y + (rect.height - sub_height + (descent - m_descent));
4737             wxCheckSetFont(dc, textFont);
4738         }
4739         else
4740         {
4741             x = rect.x;
4742             y = rect.y + (rect.height - charHeight - (descent - m_descent));
4743         }
4744     }
4745     else
4746     {
4747         x = rect.x;
4748         y = rect.y + (rect.height - charHeight - (descent - m_descent));
4749     }
4750
4751     // (a) All selected.
4752     if (selectionRange.GetStart() <= range.GetStart() && selectionRange.GetEnd() >= range.GetEnd())
4753     {
4754         DrawTabbedString(dc, textAttr, rect, stringChunk, x, y, true);
4755     }
4756     // (b) None selected.
4757     else if (selectionRange.GetEnd() < range.GetStart() || selectionRange.GetStart() > range.GetEnd())
4758     {
4759         // Draw all unselected
4760         DrawTabbedString(dc, textAttr, rect, stringChunk, x, y, false);
4761     }
4762     else
4763     {
4764         // (c) Part selected, part not
4765         // Let's draw unselected chunk, selected chunk, then unselected chunk.
4766
4767         dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
4768
4769         // 1. Initial unselected chunk, if any, up until start of selection.
4770         if (selectionRange.GetStart() > range.GetStart() && selectionRange.GetStart() <= range.GetEnd())
4771         {
4772             int r1 = range.GetStart();
4773             int s1 = selectionRange.GetStart()-1;
4774             int fragmentLen = s1 - r1 + 1;
4775             if (fragmentLen < 0)
4776             {
4777                 wxLogDebug(wxT("Mid(%d, %d"), (int)(r1 - offset), (int)fragmentLen);
4778             }
4779             wxString stringFragment = str.Mid(r1 - offset, fragmentLen);
4780
4781             DrawTabbedString(dc, textAttr, rect, stringFragment, x, y, false);
4782
4783 #if USE_KERNING_FIX
4784             if (stringChunk.Find(wxT("\t")) == wxNOT_FOUND)
4785             {
4786                 // Compensate for kerning difference
4787                 wxString stringFragment2(str.Mid(r1 - offset, fragmentLen+1));
4788                 wxString stringFragment3(str.Mid(r1 - offset + fragmentLen, 1));
4789
4790                 wxCoord w1, h1, w2, h2, w3, h3;
4791                 dc.GetTextExtent(stringFragment,  & w1, & h1);
4792                 dc.GetTextExtent(stringFragment2, & w2, & h2);
4793                 dc.GetTextExtent(stringFragment3, & w3, & h3);
4794
4795                 int kerningDiff = (w1 + w3) - w2;
4796                 x = x - kerningDiff;
4797             }
4798 #endif
4799         }
4800
4801         // 2. Selected chunk, if any.
4802         if (selectionRange.GetEnd() >= range.GetStart())
4803         {
4804             int s1 = wxMax(selectionRange.GetStart(), range.GetStart());
4805             int s2 = wxMin(selectionRange.GetEnd(), range.GetEnd());
4806
4807             int fragmentLen = s2 - s1 + 1;
4808             if (fragmentLen < 0)
4809             {
4810                 wxLogDebug(wxT("Mid(%d, %d"), (int)(s1 - offset), (int)fragmentLen);
4811             }
4812             wxString stringFragment = str.Mid(s1 - offset, fragmentLen);
4813
4814             DrawTabbedString(dc, textAttr, rect, stringFragment, x, y, true);
4815
4816 #if USE_KERNING_FIX
4817             if (stringChunk.Find(wxT("\t")) == wxNOT_FOUND)
4818             {
4819                 // Compensate for kerning difference
4820                 wxString stringFragment2(str.Mid(s1 - offset, fragmentLen+1));
4821                 wxString stringFragment3(str.Mid(s1 - offset + fragmentLen, 1));
4822
4823                 wxCoord w1, h1, w2, h2, w3, h3;
4824                 dc.GetTextExtent(stringFragment,  & w1, & h1);
4825                 dc.GetTextExtent(stringFragment2, & w2, & h2);
4826                 dc.GetTextExtent(stringFragment3, & w3, & h3);
4827
4828                 int kerningDiff = (w1 + w3) - w2;
4829                 x = x - kerningDiff;
4830             }
4831 #endif
4832         }
4833
4834         // 3. Remaining unselected chunk, if any
4835         if (selectionRange.GetEnd() < range.GetEnd())
4836         {
4837             int s2 = wxMin(selectionRange.GetEnd()+1, range.GetEnd());
4838             int r2 = range.GetEnd();
4839
4840             int fragmentLen = r2 - s2 + 1;
4841             if (fragmentLen < 0)
4842             {
4843                 wxLogDebug(wxT("Mid(%d, %d"), (int)(s2 - offset), (int)fragmentLen);
4844             }
4845             wxString stringFragment = str.Mid(s2 - offset, fragmentLen);
4846
4847             DrawTabbedString(dc, textAttr, rect, stringFragment, x, y, false);
4848         }
4849     }
4850
4851     return true;
4852 }
4853
4854 bool wxRichTextPlainText::DrawTabbedString(wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect,wxString& str, wxCoord& x, wxCoord& y, bool selected)
4855 {
4856     bool hasTabs = (str.Find(wxT('\t')) != wxNOT_FOUND);
4857
4858     wxArrayInt tabArray;
4859     int tabCount;
4860     if (hasTabs)
4861     {
4862         if (attr.GetTabs().IsEmpty())
4863             tabArray = wxRichTextParagraph::GetDefaultTabs();
4864         else
4865             tabArray = attr.GetTabs();
4866         tabCount = tabArray.GetCount();
4867
4868         for (int i = 0; i < tabCount; ++i)
4869         {
4870             int pos = tabArray[i];
4871             pos = ConvertTenthsMMToPixels(dc, pos);
4872             tabArray[i] = pos;
4873         }
4874     }
4875     else
4876         tabCount = 0;
4877
4878     int nextTabPos = -1;
4879     int tabPos = -1;
4880     wxCoord w, h;
4881
4882     if (selected)
4883     {
4884         wxColour highlightColour(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT));
4885         wxColour highlightTextColour(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT));
4886
4887         wxCheckSetBrush(dc, wxBrush(highlightColour));
4888         wxCheckSetPen(dc, wxPen(highlightColour));
4889         dc.SetTextForeground(highlightTextColour);
4890         dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
4891     }
4892     else
4893     {
4894         dc.SetTextForeground(attr.GetTextColour());
4895
4896         if (attr.HasFlag(wxTEXT_ATTR_BACKGROUND_COLOUR) && attr.GetBackgroundColour().IsOk())
4897         {
4898             dc.SetBackgroundMode(wxBRUSHSTYLE_SOLID);
4899             dc.SetTextBackground(attr.GetBackgroundColour());
4900         }
4901         else
4902             dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
4903     }
4904
4905     wxCoord x_orig = x;
4906     while (hasTabs)
4907     {
4908         // the string has a tab
4909         // break up the string at the Tab
4910         wxString stringChunk = str.BeforeFirst(wxT('\t'));
4911         str = str.AfterFirst(wxT('\t'));
4912         dc.GetTextExtent(stringChunk, & w, & h);
4913         tabPos = x + w;
4914         bool not_found = true;
4915         for (int i = 0; i < tabCount && not_found; ++i)
4916         {
4917             nextTabPos = tabArray.Item(i) + x_orig;
4918
4919             // Find the next tab position.
4920             // Even if we're at the end of the tab array, we must still draw the chunk.
4921
4922             if (nextTabPos > tabPos || (i == (tabCount - 1)))
4923             {
4924                 if (nextTabPos <= tabPos)
4925                 {
4926                     int defaultTabWidth = ConvertTenthsMMToPixels(dc, WIDTH_FOR_DEFAULT_TABS);
4927                     nextTabPos = tabPos + defaultTabWidth;
4928                 }
4929
4930                 not_found = false;
4931                 if (selected)
4932                 {
4933                     w = nextTabPos - x;
4934                     wxRect selRect(x, rect.y, w, rect.GetHeight());
4935                     dc.DrawRectangle(selRect);
4936                 }
4937                 dc.DrawText(stringChunk, x, y);
4938
4939                 if (attr.HasTextEffects() && (attr.GetTextEffects() & wxTEXT_ATTR_EFFECT_STRIKETHROUGH))
4940                 {
4941                     wxPen oldPen = dc.GetPen();
4942                     wxCheckSetPen(dc, wxPen(attr.GetTextColour(), 1));
4943                     dc.DrawLine(x, (int) (y+(h/2)+0.5), x+w, (int) (y+(h/2)+0.5));
4944                     wxCheckSetPen(dc, oldPen);
4945                 }
4946
4947                 x = nextTabPos;
4948             }
4949         }
4950         hasTabs = (str.Find(wxT('\t')) != wxNOT_FOUND);
4951     }
4952
4953     if (!str.IsEmpty())
4954     {
4955         dc.GetTextExtent(str, & w, & h);
4956         if (selected)
4957         {
4958             wxRect selRect(x, rect.y, w, rect.GetHeight());
4959             dc.DrawRectangle(selRect);
4960         }
4961         dc.DrawText(str, x, y);
4962
4963         if (attr.HasTextEffects() && (attr.GetTextEffects() & wxTEXT_ATTR_EFFECT_STRIKETHROUGH))
4964         {
4965             wxPen oldPen = dc.GetPen();
4966             wxCheckSetPen(dc, wxPen(attr.GetTextColour(), 1));
4967             dc.DrawLine(x, (int) (y+(h/2)+0.5), x+w, (int) (y+(h/2)+0.5));
4968             wxCheckSetPen(dc, oldPen);
4969         }
4970
4971         x += w;
4972     }
4973     return true;
4974
4975 }
4976
4977 /// Lay the item out
4978 bool wxRichTextPlainText::Layout(wxDC& dc, const wxRect& WXUNUSED(rect), int WXUNUSED(style))
4979 {
4980     // Only lay out if we haven't already cached the size
4981     if (m_size.x == -1)
4982         GetRangeSize(GetRange(), m_size, m_descent, dc, 0, wxPoint(0, 0));
4983
4984     return true;
4985 }
4986
4987 /// Copy
4988 void wxRichTextPlainText::Copy(const wxRichTextPlainText& obj)
4989 {
4990     wxRichTextObject::Copy(obj);
4991
4992     m_text = obj.m_text;
4993 }
4994
4995 /// Get/set the object size for the given range. Returns false if the range
4996 /// is invalid for this object.
4997 bool wxRichTextPlainText::GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int WXUNUSED(flags), wxPoint position, wxArrayInt* partialExtents) const
4998 {
4999     if (!range.IsWithin(GetRange()))
5000         return false;
5001
5002     wxRichTextParagraph* para = wxDynamicCast(GetParent(), wxRichTextParagraph);
5003     wxASSERT (para != NULL);
5004
5005     wxRichTextAttr textAttr(para ? para->GetCombinedAttributes(GetAttributes()) : GetAttributes());
5006
5007     // Always assume unformatted text, since at this level we have no knowledge
5008     // of line breaks - and we don't need it, since we'll calculate size within
5009     // formatted text by doing it in chunks according to the line ranges
5010
5011     bool bScript(false);
5012     wxFont font(GetBuffer()->GetFontTable().FindFont(textAttr));
5013     if (font.Ok())
5014     {
5015         if ( textAttr.HasTextEffects() && ( (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_SUPERSCRIPT)
5016             || (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_SUBSCRIPT) ) )
5017         {
5018             wxFont textFont = font;
5019             double size = static_cast<double>(textFont.GetPointSize()) / wxSCRIPT_MUL_FACTOR;
5020             textFont.SetPointSize( static_cast<int>(size) );
5021             wxCheckSetFont(dc, textFont);
5022             bScript = true;
5023         }
5024         else
5025         {
5026             wxCheckSetFont(dc, font);
5027         }
5028     }
5029
5030     bool haveDescent = false;
5031     int startPos = range.GetStart() - GetRange().GetStart();
5032     long len = range.GetLength();
5033
5034     wxString str(m_text);
5035     wxString toReplace = wxRichTextLineBreakChar;
5036     str.Replace(toReplace, wxT(" "));
5037
5038     wxString stringChunk = str.Mid(startPos, (size_t) len);
5039
5040     if (textAttr.HasTextEffects() && (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_CAPITALS))
5041         stringChunk.MakeUpper();
5042
5043     wxCoord w, h;
5044     int width = 0;
5045     if (stringChunk.Find(wxT('\t')) != wxNOT_FOUND)
5046     {
5047         // the string has a tab
5048         wxArrayInt tabArray;
5049         if (textAttr.GetTabs().IsEmpty())
5050             tabArray = wxRichTextParagraph::GetDefaultTabs();
5051         else
5052             tabArray = textAttr.GetTabs();
5053
5054         int tabCount = tabArray.GetCount();
5055
5056         for (int i = 0; i < tabCount; ++i)
5057         {
5058             int pos = tabArray[i];
5059             pos = ((wxRichTextPlainText*) this)->ConvertTenthsMMToPixels(dc, pos);
5060             tabArray[i] = pos;
5061         }
5062
5063         int nextTabPos = -1;
5064
5065         while (stringChunk.Find(wxT('\t')) >= 0)
5066         {
5067             int absoluteWidth = 0;
5068
5069             // the string has a tab
5070             // break up the string at the Tab
5071             wxString stringFragment = stringChunk.BeforeFirst(wxT('\t'));
5072             stringChunk = stringChunk.AfterFirst(wxT('\t'));
5073
5074             if (partialExtents)
5075             {
5076                 int oldWidth;
5077                 if (partialExtents->GetCount() > 0)
5078                     oldWidth = (*partialExtents)[partialExtents->GetCount()-1];
5079                 else
5080                     oldWidth = 0;
5081
5082                 // Add these partial extents
5083                 wxArrayInt p;
5084                 dc.GetPartialTextExtents(stringFragment, p);
5085                 size_t j;
5086                 for (j = 0; j < p.GetCount(); j++)
5087                     partialExtents->Add(oldWidth + p[j]);
5088
5089                 if (partialExtents->GetCount() > 0)
5090                     absoluteWidth = (*partialExtents)[(*partialExtents).GetCount()-1] + position.x;
5091                 else
5092                     absoluteWidth = position.x;
5093             }
5094             else
5095             {
5096                 dc.GetTextExtent(stringFragment, & w, & h);
5097                 width += w;
5098                 absoluteWidth = width + position.x;
5099                 haveDescent = true;
5100             }
5101
5102             bool notFound = true;
5103             for (int i = 0; i < tabCount && notFound; ++i)
5104             {
5105                 nextTabPos = tabArray.Item(i);
5106
5107                 // Find the next tab position.
5108                 // Even if we're at the end of the tab array, we must still process the chunk.
5109
5110                 if (nextTabPos > absoluteWidth || (i == (tabCount - 1)))
5111                 {
5112                     if (nextTabPos <= absoluteWidth)
5113                     {
5114                         int defaultTabWidth = ((wxRichTextPlainText*) this)->ConvertTenthsMMToPixels(dc, WIDTH_FOR_DEFAULT_TABS);
5115                         nextTabPos = absoluteWidth + defaultTabWidth;
5116                     }
5117
5118                     notFound = false;
5119                     width = nextTabPos - position.x;
5120
5121                     if (partialExtents)
5122                         partialExtents->Add(width);
5123                 }
5124             }
5125         }
5126     }
5127
5128     if (!stringChunk.IsEmpty())
5129     {
5130         if (partialExtents)
5131         {
5132             int oldWidth;
5133             if (partialExtents->GetCount() > 0)
5134                 oldWidth = (*partialExtents)[partialExtents->GetCount()-1];
5135             else
5136                 oldWidth = 0;
5137
5138             // Add these partial extents
5139             wxArrayInt p;
5140             dc.GetPartialTextExtents(stringChunk, p);
5141             size_t j;
5142             for (j = 0; j < p.GetCount(); j++)
5143                 partialExtents->Add(oldWidth + p[j]);
5144         }
5145         else
5146         {
5147             dc.GetTextExtent(stringChunk, & w, & h, & descent);
5148             width += w;
5149             haveDescent = true;
5150         }
5151     }
5152
5153     if (partialExtents)
5154     {
5155         int charHeight = dc.GetCharHeight();
5156         if ((*partialExtents).GetCount() > 0)
5157             w = (*partialExtents)[partialExtents->GetCount()-1];
5158         else
5159             w = 0;
5160         size = wxSize(w, charHeight);
5161     }
5162     else
5163     {
5164         size = wxSize(width, dc.GetCharHeight());
5165     }
5166
5167     if (!haveDescent)
5168         dc.GetTextExtent(wxT("X"), & w, & h, & descent);
5169
5170     if ( bScript )
5171         dc.SetFont(font);
5172
5173     return true;
5174 }
5175
5176 /// Do a split, returning an object containing the second part, and setting
5177 /// the first part in 'this'.
5178 wxRichTextObject* wxRichTextPlainText::DoSplit(long pos)
5179 {
5180     long index = pos - GetRange().GetStart();
5181
5182     if (index < 0 || index >= (int) m_text.length())
5183         return NULL;
5184
5185     wxString firstPart = m_text.Mid(0, index);
5186     wxString secondPart = m_text.Mid(index);
5187
5188     m_text = firstPart;
5189
5190     wxRichTextPlainText* newObject = new wxRichTextPlainText(secondPart);
5191     newObject->SetAttributes(GetAttributes());
5192
5193     newObject->SetRange(wxRichTextRange(pos, GetRange().GetEnd()));
5194     GetRange().SetEnd(pos-1);
5195
5196     return newObject;
5197 }
5198
5199 /// Calculate range
5200 void wxRichTextPlainText::CalculateRange(long start, long& end)
5201 {
5202     end = start + m_text.length() - 1;
5203     m_range.SetRange(start, end);
5204 }
5205
5206 /// Delete range
5207 bool wxRichTextPlainText::DeleteRange(const wxRichTextRange& range)
5208 {
5209     wxRichTextRange r = range;
5210
5211     r.LimitTo(GetRange());
5212
5213     if (r.GetStart() == GetRange().GetStart() && r.GetEnd() == GetRange().GetEnd())
5214     {
5215         m_text.Empty();
5216         return true;
5217     }
5218
5219     long startIndex = r.GetStart() - GetRange().GetStart();
5220     long len = r.GetLength();
5221
5222     m_text = m_text.Mid(0, startIndex) + m_text.Mid(startIndex+len);
5223     return true;
5224 }
5225
5226 /// Get text for the given range.
5227 wxString wxRichTextPlainText::GetTextForRange(const wxRichTextRange& range) const
5228 {
5229     wxRichTextRange r = range;
5230
5231     r.LimitTo(GetRange());
5232
5233     long startIndex = r.GetStart() - GetRange().GetStart();
5234     long len = r.GetLength();
5235
5236     return m_text.Mid(startIndex, len);
5237 }
5238
5239 /// Returns true if this object can merge itself with the given one.
5240 bool wxRichTextPlainText::CanMerge(wxRichTextObject* object) const
5241 {
5242     return object->GetClassInfo() == CLASSINFO(wxRichTextPlainText) &&
5243         (m_text.empty() || wxTextAttrEq(GetAttributes(), object->GetAttributes()));
5244 }
5245
5246 /// Returns true if this object merged itself with the given one.
5247 /// The calling code will then delete the given object.
5248 bool wxRichTextPlainText::Merge(wxRichTextObject* object)
5249 {
5250     wxRichTextPlainText* textObject = wxDynamicCast(object, wxRichTextPlainText);
5251     wxASSERT( textObject != NULL );
5252
5253     if (textObject)
5254     {
5255         m_text += textObject->GetText();
5256         wxRichTextApplyStyle(m_attributes, textObject->GetAttributes());
5257         return true;
5258     }
5259     else
5260         return false;
5261 }
5262
5263 /// Dump to output stream for debugging
5264 void wxRichTextPlainText::Dump(wxTextOutputStream& stream)
5265 {
5266     wxRichTextObject::Dump(stream);
5267     stream << m_text << wxT("\n");
5268 }
5269
5270 /// Get the first position from pos that has a line break character.
5271 long wxRichTextPlainText::GetFirstLineBreakPosition(long pos)
5272 {
5273     int i;
5274     int len = m_text.length();
5275     int startPos = pos - m_range.GetStart();
5276     for (i = startPos; i < len; i++)
5277     {
5278         wxChar ch = m_text[i];
5279         if (ch == wxRichTextLineBreakChar)
5280         {
5281             return i + m_range.GetStart();
5282         }
5283     }
5284     return -1;
5285 }
5286
5287 /*!
5288  * wxRichTextBuffer
5289  * This is a kind of box, used to represent the whole buffer
5290  */
5291
5292 IMPLEMENT_DYNAMIC_CLASS(wxRichTextBuffer, wxRichTextParagraphLayoutBox)
5293
5294 wxList                  wxRichTextBuffer::sm_handlers;
5295 wxRichTextRenderer*     wxRichTextBuffer::sm_renderer = NULL;
5296 int                     wxRichTextBuffer::sm_bulletRightMargin = 20;
5297 float                   wxRichTextBuffer::sm_bulletProportion = (float) 0.3;
5298
5299 /// Initialisation
5300 void wxRichTextBuffer::Init()
5301 {
5302     m_commandProcessor = new wxCommandProcessor;
5303     m_styleSheet = NULL;
5304     m_modified = false;
5305     m_batchedCommandDepth = 0;
5306     m_batchedCommand = NULL;
5307     m_suppressUndo = 0;
5308     m_handlerFlags = 0;
5309     m_scale = 1.0;
5310 }
5311
5312 /// Initialisation
5313 wxRichTextBuffer::~wxRichTextBuffer()
5314 {
5315     delete m_commandProcessor;
5316     delete m_batchedCommand;
5317
5318     ClearStyleStack();
5319     ClearEventHandlers();
5320 }
5321
5322 void wxRichTextBuffer::ResetAndClearCommands()
5323 {
5324     Reset();
5325
5326     GetCommandProcessor()->ClearCommands();
5327
5328     Modify(false);
5329     Invalidate(wxRICHTEXT_ALL);
5330 }
5331
5332 void wxRichTextBuffer::Copy(const wxRichTextBuffer& obj)
5333 {
5334     wxRichTextParagraphLayoutBox::Copy(obj);
5335
5336     m_styleSheet = obj.m_styleSheet;
5337     m_modified = obj.m_modified;
5338     m_batchedCommandDepth = obj.m_batchedCommandDepth;
5339     m_batchedCommand = obj.m_batchedCommand;
5340     m_suppressUndo = obj.m_suppressUndo;
5341 }
5342
5343 /// Push style sheet to top of stack
5344 bool wxRichTextBuffer::PushStyleSheet(wxRichTextStyleSheet* styleSheet)
5345 {
5346     if (m_styleSheet)
5347         styleSheet->InsertSheet(m_styleSheet);
5348
5349     SetStyleSheet(styleSheet);
5350
5351     return true;
5352 }
5353
5354 /// Pop style sheet from top of stack
5355 wxRichTextStyleSheet* wxRichTextBuffer::PopStyleSheet()
5356 {
5357     if (m_styleSheet)
5358     {
5359         wxRichTextStyleSheet* oldSheet = m_styleSheet;
5360         m_styleSheet = oldSheet->GetNextSheet();
5361         oldSheet->Unlink();
5362
5363         return oldSheet;
5364     }
5365     else
5366         return NULL;
5367 }
5368
5369 /// Submit command to insert paragraphs
5370 bool wxRichTextBuffer::InsertParagraphsWithUndo(long pos, const wxRichTextParagraphLayoutBox& paragraphs, wxRichTextCtrl* ctrl, int flags)
5371 {
5372     wxRichTextAction* action = new wxRichTextAction(NULL, _("Insert Text"), wxRICHTEXT_INSERT, this, ctrl, false);
5373
5374     wxRichTextAttr attr(GetDefaultStyle());
5375
5376     wxRichTextAttr* p = NULL;
5377     wxRichTextAttr paraAttr;
5378     if (flags & wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE)
5379     {
5380         paraAttr = GetStyleForNewParagraph(pos);
5381         if (!paraAttr.IsDefault())
5382             p = & paraAttr;
5383     }
5384     else
5385         p = & attr;
5386
5387     action->GetNewParagraphs() = paragraphs;
5388
5389     if (p && !p->IsDefault())
5390     {
5391         for (wxRichTextObjectList::compatibility_iterator node = action->GetNewParagraphs().GetChildren().GetFirst(); node; node = node->GetNext())
5392         {
5393             wxRichTextObject* child = node->GetData();
5394             child->SetAttributes(*p);
5395         }
5396     }
5397
5398     action->SetPosition(pos);
5399
5400     wxRichTextRange range = wxRichTextRange(pos, pos + paragraphs.GetRange().GetEnd() - 1);
5401     if (!paragraphs.GetPartialParagraph())
5402         range.SetEnd(range.GetEnd()+1);
5403
5404     // Set the range we'll need to delete in Undo
5405     action->SetRange(range);
5406
5407     SubmitAction(action);
5408
5409     return true;
5410 }
5411
5412 /// Submit command to insert the given text
5413 bool wxRichTextBuffer::InsertTextWithUndo(long pos, const wxString& text, wxRichTextCtrl* ctrl, int flags)
5414 {
5415     wxRichTextAction* action = new wxRichTextAction(NULL, _("Insert Text"), wxRICHTEXT_INSERT, this, ctrl, false);
5416
5417     wxRichTextAttr* p = NULL;
5418     wxRichTextAttr paraAttr;
5419     if (flags & wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE)
5420     {
5421         // Get appropriate paragraph style
5422         paraAttr = GetStyleForNewParagraph(pos, false, false);
5423         if (!paraAttr.IsDefault())
5424             p = & paraAttr;
5425     }
5426
5427     action->GetNewParagraphs().AddParagraphs(text, p);
5428
5429     int length = action->GetNewParagraphs().GetRange().GetLength();
5430
5431     if (text.length() > 0 && text.Last() != wxT('\n'))
5432     {
5433         // Don't count the newline when undoing
5434         length --;
5435         action->GetNewParagraphs().SetPartialParagraph(true);
5436     }
5437     else if (text.length() > 0 && text.Last() == wxT('\n'))
5438         length --;
5439
5440     action->SetPosition(pos);
5441
5442     // Set the range we'll need to delete in Undo
5443     action->SetRange(wxRichTextRange(pos, pos + length - 1));
5444
5445     SubmitAction(action);
5446
5447     return true;
5448 }
5449
5450 /// Submit command to insert the given text
5451 bool wxRichTextBuffer::InsertNewlineWithUndo(long pos, wxRichTextCtrl* ctrl, int flags)
5452 {
5453     wxRichTextAction* action = new wxRichTextAction(NULL, _("Insert Text"), wxRICHTEXT_INSERT, this, ctrl, false);
5454
5455     wxRichTextAttr* p = NULL;
5456     wxRichTextAttr paraAttr;
5457     if (flags & wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE)
5458     {
5459         paraAttr = GetStyleForNewParagraph(pos, false, true /* look for next paragraph style */);
5460         if (!paraAttr.IsDefault())
5461             p = & paraAttr;
5462     }
5463
5464     wxRichTextAttr attr(GetDefaultStyle());
5465
5466     wxRichTextParagraph* newPara = new wxRichTextParagraph(wxEmptyString, this, & attr);
5467     action->GetNewParagraphs().AppendChild(newPara);
5468     action->GetNewParagraphs().UpdateRanges();
5469     action->GetNewParagraphs().SetPartialParagraph(false);
5470     wxRichTextParagraph* para = GetParagraphAtPosition(pos, false);
5471     long pos1 = pos;
5472
5473     if (p)
5474         newPara->SetAttributes(*p);
5475
5476     if (flags & wxRICHTEXT_INSERT_INTERACTIVE)
5477     {
5478         if (para && para->GetRange().GetEnd() == pos)
5479             pos1 ++;
5480
5481         // Now see if we need to number the paragraph.
5482         if (newPara->GetAttributes().HasBulletNumber())
5483         {
5484             wxRichTextAttr numberingAttr;
5485             if (FindNextParagraphNumber(para, numberingAttr))
5486                 wxRichTextApplyStyle(newPara->GetAttributes(), (const wxRichTextAttr&) numberingAttr);
5487         }
5488     }
5489
5490     action->SetPosition(pos);
5491
5492     // Use the default character style
5493     // Use the default character style
5494     if (!GetDefaultStyle().IsDefault() && newPara->GetChildren().GetFirst())
5495     {
5496         // Check whether the default style merely reflects the paragraph/basic style,
5497         // in which case don't apply it.
5498         wxRichTextAttr defaultStyle(GetDefaultStyle());
5499         wxRichTextAttr toApply;
5500         if (para)
5501         {
5502             wxRichTextAttr combinedAttr = para->GetCombinedAttributes();
5503             wxRichTextAttr newAttr;
5504             // This filters out attributes that are accounted for by the current
5505             // paragraph/basic style
5506             wxRichTextApplyStyle(toApply, defaultStyle, & combinedAttr);
5507         }
5508         else
5509             toApply = defaultStyle;
5510
5511         if (!toApply.IsDefault())
5512             newPara->GetChildren().GetFirst()->GetData()->SetAttributes(toApply);
5513     }
5514
5515     // Set the range we'll need to delete in Undo
5516     action->SetRange(wxRichTextRange(pos1, pos1));
5517
5518     SubmitAction(action);
5519
5520     return true;
5521 }
5522
5523 /// Submit command to insert the given image
5524 bool wxRichTextBuffer::InsertImageWithUndo(long pos, const wxRichTextImageBlock& imageBlock, wxRichTextCtrl* ctrl, int flags,
5525                                             const wxRichTextAttr& textAttr)
5526 {
5527     wxRichTextAction* action = new wxRichTextAction(NULL, _("Insert Image"), wxRICHTEXT_INSERT, this, ctrl, false);
5528
5529     wxRichTextAttr* p = NULL;
5530     wxRichTextAttr paraAttr;
5531     if (flags & wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE)
5532     {
5533         paraAttr = GetStyleForNewParagraph(pos);
5534         if (!paraAttr.IsDefault())
5535             p = & paraAttr;
5536     }
5537
5538     wxRichTextAttr attr(GetDefaultStyle());
5539
5540     wxRichTextParagraph* newPara = new wxRichTextParagraph(this, & attr);
5541     if (p)
5542         newPara->SetAttributes(*p);
5543
5544     wxRichTextImage* imageObject = new wxRichTextImage(imageBlock, newPara);
5545     newPara->AppendChild(imageObject);
5546     imageObject->SetAttributes(textAttr);
5547     //imageObject->SetAnchoredAttr(floatAttr);
5548     action->GetNewParagraphs().AppendChild(newPara);
5549     action->GetNewParagraphs().UpdateRanges();
5550
5551     action->GetNewParagraphs().SetPartialParagraph(true);
5552
5553     action->SetPosition(pos);
5554
5555     // Set the range we'll need to delete in Undo
5556     action->SetRange(wxRichTextRange(pos, pos));
5557
5558     SubmitAction(action);
5559
5560     return true;
5561 }
5562
5563 // Insert an object with no change of it
5564 bool wxRichTextBuffer::InsertObjectWithUndo(long pos, wxRichTextObject *object, wxRichTextCtrl* ctrl, int flags)
5565 {
5566     wxRichTextAction* action = new wxRichTextAction(NULL, _("Insert object"), wxRICHTEXT_INSERT, this, ctrl, false);
5567
5568     wxRichTextAttr* p = NULL;
5569     wxRichTextAttr paraAttr;
5570     if (flags & wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE)
5571     {
5572         paraAttr = GetStyleForNewParagraph(pos);
5573         if (!paraAttr.IsDefault())
5574             p = & paraAttr;
5575     }
5576
5577     wxRichTextAttr attr(GetDefaultStyle());
5578
5579     wxRichTextParagraph* newPara = new wxRichTextParagraph(this, & attr);
5580     if (p)
5581         newPara->SetAttributes(*p);
5582
5583     newPara->AppendChild(object);
5584     action->GetNewParagraphs().AppendChild(newPara);
5585     action->GetNewParagraphs().UpdateRanges();
5586
5587     action->GetNewParagraphs().SetPartialParagraph(true);
5588
5589     action->SetPosition(pos);
5590
5591     // Set the range we'll need to delete in Undo
5592     action->SetRange(wxRichTextRange(pos, pos));
5593
5594     SubmitAction(action);
5595
5596     return true;
5597 }
5598 /// Get the style that is appropriate for a new paragraph at this position.
5599 /// If the previous paragraph has a paragraph style name, look up the next-paragraph
5600 /// style.
5601 wxRichTextAttr wxRichTextBuffer::GetStyleForNewParagraph(long pos, bool caretPosition, bool lookUpNewParaStyle) const
5602 {
5603     wxRichTextParagraph* para = GetParagraphAtPosition(pos, caretPosition);
5604     if (para)
5605     {
5606         wxRichTextAttr attr;
5607         bool foundAttributes = false;
5608
5609         // Look for a matching paragraph style
5610         if (lookUpNewParaStyle && !para->GetAttributes().GetParagraphStyleName().IsEmpty() && GetStyleSheet())
5611         {
5612             wxRichTextParagraphStyleDefinition* paraDef = GetStyleSheet()->FindParagraphStyle(para->GetAttributes().GetParagraphStyleName());
5613             if (paraDef)
5614             {
5615                 // If we're not at the end of the paragraph, then we apply THIS style, and not the designated next style.
5616                 if (para->GetRange().GetEnd() == pos && !paraDef->GetNextStyle().IsEmpty())
5617                 {
5618                     wxRichTextParagraphStyleDefinition* nextParaDef = GetStyleSheet()->FindParagraphStyle(paraDef->GetNextStyle());
5619                     if (nextParaDef)
5620                     {
5621                         foundAttributes = true;
5622                         attr = nextParaDef->GetStyleMergedWithBase(GetStyleSheet());
5623                     }
5624                 }
5625
5626                 // If we didn't find the 'next style', use this style instead.
5627                 if (!foundAttributes)
5628                 {
5629                     foundAttributes = true;
5630                     attr = paraDef->GetStyleMergedWithBase(GetStyleSheet());
5631                 }
5632             }
5633         }
5634
5635         // Also apply list style if present
5636         if (lookUpNewParaStyle && !para->GetAttributes().GetListStyleName().IsEmpty() && GetStyleSheet())
5637         {
5638             wxRichTextListStyleDefinition* listDef = GetStyleSheet()->FindListStyle(para->GetAttributes().GetListStyleName());
5639             if (listDef)
5640             {
5641                 int thisIndent = para->GetAttributes().GetLeftIndent();
5642                 int thisLevel = para->GetAttributes().HasOutlineLevel() ? para->GetAttributes().GetOutlineLevel() : listDef->FindLevelForIndent(thisIndent);
5643
5644                 // Apply the overall list style, and item style for this level
5645                 wxRichTextAttr listStyle(listDef->GetCombinedStyleForLevel(thisLevel, GetStyleSheet()));
5646                 wxRichTextApplyStyle(attr, listStyle);
5647                 attr.SetOutlineLevel(thisLevel);
5648                 if (para->GetAttributes().HasBulletNumber())
5649                     attr.SetBulletNumber(para->GetAttributes().GetBulletNumber());
5650             }
5651         }
5652
5653         if (!foundAttributes)
5654         {
5655             attr = para->GetAttributes();
5656             int flags = attr.GetFlags();
5657
5658             // Eliminate character styles
5659             flags &= ( (~ wxTEXT_ATTR_FONT) |
5660                     (~ wxTEXT_ATTR_TEXT_COLOUR) |
5661                     (~ wxTEXT_ATTR_BACKGROUND_COLOUR) );
5662             attr.SetFlags(flags);
5663         }
5664
5665         return attr;
5666     }
5667     else
5668         return wxRichTextAttr();
5669 }
5670
5671 /// Submit command to delete this range
5672 bool wxRichTextBuffer::DeleteRangeWithUndo(const wxRichTextRange& range, wxRichTextCtrl* ctrl)
5673 {
5674     wxRichTextAction* action = new wxRichTextAction(NULL, _("Delete"), wxRICHTEXT_DELETE, this, ctrl);
5675
5676     action->SetPosition(ctrl->GetCaretPosition());
5677
5678     // Set the range to delete
5679     action->SetRange(range);
5680
5681     // Copy the fragment that we'll need to restore in Undo
5682     CopyFragment(range, action->GetOldParagraphs());
5683
5684     // See if we're deleting a paragraph marker, in which case we need to
5685     // make a note not to copy the attributes from the 2nd paragraph to the 1st.
5686     if (range.GetStart() == range.GetEnd())
5687     {
5688         wxRichTextParagraph* para = GetParagraphAtPosition(range.GetStart());
5689         if (para && para->GetRange().GetEnd() == range.GetEnd())
5690         {
5691             wxRichTextParagraph* nextPara = GetParagraphAtPosition(range.GetStart()+1);
5692             if (nextPara && nextPara != para)
5693             {
5694                 action->GetOldParagraphs().GetChildren().GetFirst()->GetData()->SetAttributes(nextPara->GetAttributes());
5695                 action->GetOldParagraphs().GetAttributes().SetFlags(action->GetOldParagraphs().GetAttributes().GetFlags() | wxTEXT_ATTR_KEEP_FIRST_PARA_STYLE);
5696             }
5697         }
5698     }
5699
5700     SubmitAction(action);
5701
5702     return true;
5703 }
5704
5705 /// Collapse undo/redo commands
5706 bool wxRichTextBuffer::BeginBatchUndo(const wxString& cmdName)
5707 {
5708     if (m_batchedCommandDepth == 0)
5709     {
5710         wxASSERT(m_batchedCommand == NULL);
5711         if (m_batchedCommand)
5712         {
5713             GetCommandProcessor()->Store(m_batchedCommand);
5714         }
5715         m_batchedCommand = new wxRichTextCommand(cmdName);
5716     }
5717
5718     m_batchedCommandDepth ++;
5719
5720     return true;
5721 }
5722
5723 /// Collapse undo/redo commands
5724 bool wxRichTextBuffer::EndBatchUndo()
5725 {
5726     m_batchedCommandDepth --;
5727
5728     wxASSERT(m_batchedCommandDepth >= 0);
5729     wxASSERT(m_batchedCommand != NULL);
5730
5731     if (m_batchedCommandDepth == 0)
5732     {
5733         GetCommandProcessor()->Store(m_batchedCommand);
5734         m_batchedCommand = NULL;
5735     }
5736
5737     return true;
5738 }
5739
5740 /// Submit immediately, or delay according to whether collapsing is on
5741 bool wxRichTextBuffer::SubmitAction(wxRichTextAction* action)
5742 {
5743     if (BatchingUndo() && m_batchedCommand && !SuppressingUndo())
5744     {
5745         wxRichTextCommand* cmd = new wxRichTextCommand(action->GetName());
5746         cmd->AddAction(action);
5747         cmd->Do();
5748         cmd->GetActions().Clear();
5749         delete cmd;
5750
5751         m_batchedCommand->AddAction(action);
5752     }
5753     else
5754     {
5755         wxRichTextCommand* cmd = new wxRichTextCommand(action->GetName());
5756         cmd->AddAction(action);
5757
5758         // Only store it if we're not suppressing undo.
5759         return GetCommandProcessor()->Submit(cmd, !SuppressingUndo());
5760     }
5761
5762     return true;
5763 }
5764
5765 /// Begin suppressing undo/redo commands.
5766 bool wxRichTextBuffer::BeginSuppressUndo()
5767 {
5768     m_suppressUndo ++;
5769
5770     return true;
5771 }
5772
5773 /// End suppressing undo/redo commands.
5774 bool wxRichTextBuffer::EndSuppressUndo()
5775 {
5776     m_suppressUndo --;
5777
5778     return true;
5779 }
5780
5781 /// Begin using a style
5782 bool wxRichTextBuffer::BeginStyle(const wxRichTextAttr& style)
5783 {
5784     wxRichTextAttr newStyle(GetDefaultStyle());
5785
5786     // Save the old default style
5787     m_attributeStack.Append((wxObject*) new wxRichTextAttr(GetDefaultStyle()));
5788
5789     wxRichTextApplyStyle(newStyle, style);
5790     newStyle.SetFlags(style.GetFlags()|newStyle.GetFlags());
5791
5792     SetDefaultStyle(newStyle);
5793
5794     return true;
5795 }
5796
5797 /// End the style
5798 bool wxRichTextBuffer::EndStyle()
5799 {
5800     if (!m_attributeStack.GetFirst())
5801     {
5802         wxLogDebug(_("Too many EndStyle calls!"));
5803         return false;
5804     }
5805
5806     wxList::compatibility_iterator node = m_attributeStack.GetLast();
5807     wxRichTextAttr* attr = (wxRichTextAttr*)node->GetData();
5808     m_attributeStack.Erase(node);
5809
5810     SetDefaultStyle(*attr);
5811
5812     delete attr;
5813     return true;
5814 }
5815
5816 /// End all styles
5817 bool wxRichTextBuffer::EndAllStyles()
5818 {
5819     while (m_attributeStack.GetCount() != 0)
5820         EndStyle();
5821     return true;
5822 }
5823
5824 /// Clear the style stack
5825 void wxRichTextBuffer::ClearStyleStack()
5826 {
5827     for (wxList::compatibility_iterator node = m_attributeStack.GetFirst(); node; node = node->GetNext())
5828         delete (wxRichTextAttr*) node->GetData();
5829     m_attributeStack.Clear();
5830 }
5831
5832 /// Begin using bold
5833 bool wxRichTextBuffer::BeginBold()
5834 {
5835     wxRichTextAttr attr;
5836     attr.SetFontWeight(wxFONTWEIGHT_BOLD);
5837
5838     return BeginStyle(attr);
5839 }
5840
5841 /// Begin using italic
5842 bool wxRichTextBuffer::BeginItalic()
5843 {
5844     wxRichTextAttr attr;
5845     attr.SetFontStyle(wxFONTSTYLE_ITALIC);
5846
5847     return BeginStyle(attr);
5848 }
5849
5850 /// Begin using underline
5851 bool wxRichTextBuffer::BeginUnderline()
5852 {
5853     wxRichTextAttr attr;
5854     attr.SetFontUnderlined(true);
5855
5856     return BeginStyle(attr);
5857 }
5858
5859 /// Begin using point size
5860 bool wxRichTextBuffer::BeginFontSize(int pointSize)
5861 {
5862     wxRichTextAttr attr;
5863     attr.SetFontSize(pointSize);
5864
5865     return BeginStyle(attr);
5866 }
5867
5868 /// Begin using this font
5869 bool wxRichTextBuffer::BeginFont(const wxFont& font)
5870 {
5871     wxRichTextAttr attr;
5872     attr.SetFont(font);
5873
5874     return BeginStyle(attr);
5875 }
5876
5877 /// Begin using this colour
5878 bool wxRichTextBuffer::BeginTextColour(const wxColour& colour)
5879 {
5880     wxRichTextAttr attr;
5881     attr.SetFlags(wxTEXT_ATTR_TEXT_COLOUR);
5882     attr.SetTextColour(colour);
5883
5884     return BeginStyle(attr);
5885 }
5886
5887 /// Begin using alignment
5888 bool wxRichTextBuffer::BeginAlignment(wxTextAttrAlignment alignment)
5889 {
5890     wxRichTextAttr attr;
5891     attr.SetFlags(wxTEXT_ATTR_ALIGNMENT);
5892     attr.SetAlignment(alignment);
5893
5894     return BeginStyle(attr);
5895 }
5896
5897 /// Begin left indent
5898 bool wxRichTextBuffer::BeginLeftIndent(int leftIndent, int leftSubIndent)
5899 {
5900     wxRichTextAttr attr;
5901     attr.SetFlags(wxTEXT_ATTR_LEFT_INDENT);
5902     attr.SetLeftIndent(leftIndent, leftSubIndent);
5903
5904     return BeginStyle(attr);
5905 }
5906
5907 /// Begin right indent
5908 bool wxRichTextBuffer::BeginRightIndent(int rightIndent)
5909 {
5910     wxRichTextAttr attr;
5911     attr.SetFlags(wxTEXT_ATTR_RIGHT_INDENT);
5912     attr.SetRightIndent(rightIndent);
5913
5914     return BeginStyle(attr);
5915 }
5916
5917 /// Begin paragraph spacing
5918 bool wxRichTextBuffer::BeginParagraphSpacing(int before, int after)
5919 {
5920     long flags = 0;
5921     if (before != 0)
5922         flags |= wxTEXT_ATTR_PARA_SPACING_BEFORE;
5923     if (after != 0)
5924         flags |= wxTEXT_ATTR_PARA_SPACING_AFTER;
5925
5926     wxRichTextAttr attr;
5927     attr.SetFlags(flags);
5928     attr.SetParagraphSpacingBefore(before);
5929     attr.SetParagraphSpacingAfter(after);
5930
5931     return BeginStyle(attr);
5932 }
5933
5934 /// Begin line spacing
5935 bool wxRichTextBuffer::BeginLineSpacing(int lineSpacing)
5936 {
5937     wxRichTextAttr attr;
5938     attr.SetFlags(wxTEXT_ATTR_LINE_SPACING);
5939     attr.SetLineSpacing(lineSpacing);
5940
5941     return BeginStyle(attr);
5942 }
5943
5944 /// Begin numbered bullet
5945 bool wxRichTextBuffer::BeginNumberedBullet(int bulletNumber, int leftIndent, int leftSubIndent, int bulletStyle)
5946 {
5947     wxRichTextAttr attr;
5948     attr.SetFlags(wxTEXT_ATTR_BULLET_STYLE|wxTEXT_ATTR_LEFT_INDENT);
5949     attr.SetBulletStyle(bulletStyle);
5950     attr.SetBulletNumber(bulletNumber);
5951     attr.SetLeftIndent(leftIndent, leftSubIndent);
5952
5953     return BeginStyle(attr);
5954 }
5955
5956 /// Begin symbol bullet
5957 bool wxRichTextBuffer::BeginSymbolBullet(const wxString& symbol, int leftIndent, int leftSubIndent, int bulletStyle)
5958 {
5959     wxRichTextAttr attr;
5960     attr.SetFlags(wxTEXT_ATTR_BULLET_STYLE|wxTEXT_ATTR_LEFT_INDENT);
5961     attr.SetBulletStyle(bulletStyle);
5962     attr.SetLeftIndent(leftIndent, leftSubIndent);
5963     attr.SetBulletText(symbol);
5964
5965     return BeginStyle(attr);
5966 }
5967
5968 /// Begin standard bullet
5969 bool wxRichTextBuffer::BeginStandardBullet(const wxString& bulletName, int leftIndent, int leftSubIndent, int bulletStyle)
5970 {
5971     wxRichTextAttr attr;
5972     attr.SetFlags(wxTEXT_ATTR_BULLET_STYLE|wxTEXT_ATTR_LEFT_INDENT);
5973     attr.SetBulletStyle(bulletStyle);
5974     attr.SetLeftIndent(leftIndent, leftSubIndent);
5975     attr.SetBulletName(bulletName);
5976
5977     return BeginStyle(attr);
5978 }
5979
5980 /// Begin named character style
5981 bool wxRichTextBuffer::BeginCharacterStyle(const wxString& characterStyle)
5982 {
5983     if (GetStyleSheet())
5984     {
5985         wxRichTextCharacterStyleDefinition* def = GetStyleSheet()->FindCharacterStyle(characterStyle);
5986         if (def)
5987         {
5988             wxRichTextAttr attr = def->GetStyleMergedWithBase(GetStyleSheet());
5989             return BeginStyle(attr);
5990         }
5991     }
5992     return false;
5993 }
5994
5995 /// Begin named paragraph style
5996 bool wxRichTextBuffer::BeginParagraphStyle(const wxString& paragraphStyle)
5997 {
5998     if (GetStyleSheet())
5999     {
6000         wxRichTextParagraphStyleDefinition* def = GetStyleSheet()->FindParagraphStyle(paragraphStyle);
6001         if (def)
6002         {
6003             wxRichTextAttr attr = def->GetStyleMergedWithBase(GetStyleSheet());
6004             return BeginStyle(attr);
6005         }
6006     }
6007     return false;
6008 }
6009
6010 /// Begin named list style
6011 bool wxRichTextBuffer::BeginListStyle(const wxString& listStyle, int level, int number)
6012 {
6013     if (GetStyleSheet())
6014     {
6015         wxRichTextListStyleDefinition* def = GetStyleSheet()->FindListStyle(listStyle);
6016         if (def)
6017         {
6018             wxRichTextAttr attr(def->GetCombinedStyleForLevel(level));
6019
6020             attr.SetBulletNumber(number);
6021
6022             return BeginStyle(attr);
6023         }
6024     }
6025     return false;
6026 }
6027
6028 /// Begin URL
6029 bool wxRichTextBuffer::BeginURL(const wxString& url, const wxString& characterStyle)
6030 {
6031     wxRichTextAttr attr;
6032
6033     if (!characterStyle.IsEmpty() && GetStyleSheet())
6034     {
6035         wxRichTextCharacterStyleDefinition* def = GetStyleSheet()->FindCharacterStyle(characterStyle);
6036         if (def)
6037         {
6038             attr = def->GetStyleMergedWithBase(GetStyleSheet());
6039         }
6040     }
6041     attr.SetURL(url);
6042
6043     return BeginStyle(attr);
6044 }
6045
6046 /// Adds a handler to the end
6047 void wxRichTextBuffer::AddHandler(wxRichTextFileHandler *handler)
6048 {
6049     sm_handlers.Append(handler);
6050 }
6051
6052 /// Inserts a handler at the front
6053 void wxRichTextBuffer::InsertHandler(wxRichTextFileHandler *handler)
6054 {
6055     sm_handlers.Insert( handler );
6056 }
6057
6058 /// Removes a handler
6059 bool wxRichTextBuffer::RemoveHandler(const wxString& name)
6060 {
6061     wxRichTextFileHandler *handler = FindHandler(name);
6062     if (handler)
6063     {
6064         sm_handlers.DeleteObject(handler);
6065         delete handler;
6066         return true;
6067     }
6068     else
6069         return false;
6070 }
6071
6072 /// Finds a handler by filename or, if supplied, type
6073 wxRichTextFileHandler *wxRichTextBuffer::FindHandlerFilenameOrType(const wxString& filename,
6074                                                                    wxRichTextFileType imageType)
6075 {
6076     if (imageType != wxRICHTEXT_TYPE_ANY)
6077         return FindHandler(imageType);
6078     else if (!filename.IsEmpty())
6079     {
6080         wxString path, file, ext;
6081         wxFileName::SplitPath(filename, & path, & file, & ext);
6082         return FindHandler(ext, imageType);
6083     }
6084     else
6085         return NULL;
6086 }
6087
6088
6089 /// Finds a handler by name
6090 wxRichTextFileHandler* wxRichTextBuffer::FindHandler(const wxString& name)
6091 {
6092     wxList::compatibility_iterator node = sm_handlers.GetFirst();
6093     while (node)
6094     {
6095         wxRichTextFileHandler *handler = (wxRichTextFileHandler*)node->GetData();
6096         if (handler->GetName().Lower() == name.Lower()) return handler;
6097
6098         node = node->GetNext();
6099     }
6100     return NULL;
6101 }
6102
6103 /// Finds a handler by extension and type
6104 wxRichTextFileHandler* wxRichTextBuffer::FindHandler(const wxString& extension, wxRichTextFileType type)
6105 {
6106     wxList::compatibility_iterator node = sm_handlers.GetFirst();
6107     while (node)
6108     {
6109         wxRichTextFileHandler *handler = (wxRichTextFileHandler*)node->GetData();
6110         if ( handler->GetExtension().Lower() == extension.Lower() &&
6111             (type == wxRICHTEXT_TYPE_ANY || handler->GetType() == type) )
6112             return handler;
6113         node = node->GetNext();
6114     }
6115     return 0;
6116 }
6117
6118 /// Finds a handler by type
6119 wxRichTextFileHandler* wxRichTextBuffer::FindHandler(wxRichTextFileType type)
6120 {
6121     wxList::compatibility_iterator node = sm_handlers.GetFirst();
6122     while (node)
6123     {
6124         wxRichTextFileHandler *handler = (wxRichTextFileHandler *)node->GetData();
6125         if (handler->GetType() == type) return handler;
6126         node = node->GetNext();
6127     }
6128     return NULL;
6129 }
6130
6131 void wxRichTextBuffer::InitStandardHandlers()
6132 {
6133     if (!FindHandler(wxRICHTEXT_TYPE_TEXT))
6134         AddHandler(new wxRichTextPlainTextHandler);
6135 }
6136
6137 void wxRichTextBuffer::CleanUpHandlers()
6138 {
6139     wxList::compatibility_iterator node = sm_handlers.GetFirst();
6140     while (node)
6141     {
6142         wxRichTextFileHandler* handler = (wxRichTextFileHandler*)node->GetData();
6143         wxList::compatibility_iterator next = node->GetNext();
6144         delete handler;
6145         node = next;
6146     }
6147
6148     sm_handlers.Clear();
6149 }
6150
6151 wxString wxRichTextBuffer::GetExtWildcard(bool combine, bool save, wxArrayInt* types)
6152 {
6153     if (types)
6154         types->Clear();
6155
6156     wxString wildcard;
6157
6158     wxList::compatibility_iterator node = GetHandlers().GetFirst();
6159     int count = 0;
6160     while (node)
6161     {
6162         wxRichTextFileHandler* handler = (wxRichTextFileHandler*) node->GetData();
6163         if (handler->IsVisible() && ((save && handler->CanSave()) || (!save && handler->CanLoad())))
6164         {
6165             if (combine)
6166             {
6167                 if (count > 0)
6168                     wildcard += wxT(";");
6169                 wildcard += wxT("*.") + handler->GetExtension();
6170             }
6171             else
6172             {
6173                 if (count > 0)
6174                     wildcard += wxT("|");
6175                 wildcard += handler->GetName();
6176                 wildcard += wxT(" ");
6177                 wildcard += _("files");
6178                 wildcard += wxT(" (*.");
6179                 wildcard += handler->GetExtension();
6180                 wildcard += wxT(")|*.");
6181                 wildcard += handler->GetExtension();
6182                 if (types)
6183                     types->Add(handler->GetType());
6184             }
6185             count ++;
6186         }
6187
6188         node = node->GetNext();
6189     }
6190
6191     if (combine)
6192         wildcard = wxT("(") + wildcard + wxT(")|") + wildcard;
6193     return wildcard;
6194 }
6195
6196 /// Load a file
6197 bool wxRichTextBuffer::LoadFile(const wxString& filename, wxRichTextFileType type)
6198 {
6199     wxRichTextFileHandler* handler = FindHandlerFilenameOrType(filename, type);
6200     if (handler)
6201     {
6202         SetDefaultStyle(wxRichTextAttr());
6203         handler->SetFlags(GetHandlerFlags());
6204         bool success = handler->LoadFile(this, filename);
6205         Invalidate(wxRICHTEXT_ALL);
6206         return success;
6207     }
6208     else
6209         return false;
6210 }
6211
6212 /// Save a file
6213 bool wxRichTextBuffer::SaveFile(const wxString& filename, wxRichTextFileType type)
6214 {
6215     wxRichTextFileHandler* handler = FindHandlerFilenameOrType(filename, type);
6216     if (handler)
6217     {
6218         handler->SetFlags(GetHandlerFlags());
6219         return handler->SaveFile(this, filename);
6220     }
6221     else
6222         return false;
6223 }
6224
6225 /// Load from a stream
6226 bool wxRichTextBuffer::LoadFile(wxInputStream& stream, wxRichTextFileType type)
6227 {
6228     wxRichTextFileHandler* handler = FindHandler(type);
6229     if (handler)
6230     {
6231         SetDefaultStyle(wxRichTextAttr());
6232         handler->SetFlags(GetHandlerFlags());
6233         bool success = handler->LoadFile(this, stream);
6234         Invalidate(wxRICHTEXT_ALL);
6235         return success;
6236     }
6237     else
6238         return false;
6239 }
6240
6241 /// Save to a stream
6242 bool wxRichTextBuffer::SaveFile(wxOutputStream& stream, wxRichTextFileType type)
6243 {
6244     wxRichTextFileHandler* handler = FindHandler(type);
6245     if (handler)
6246     {
6247         handler->SetFlags(GetHandlerFlags());
6248         return handler->SaveFile(this, stream);
6249     }
6250     else
6251         return false;
6252 }
6253
6254 /// Copy the range to the clipboard
6255 bool wxRichTextBuffer::CopyToClipboard(const wxRichTextRange& range)
6256 {
6257     bool success = false;
6258 #if wxUSE_CLIPBOARD && wxUSE_DATAOBJ
6259
6260     if (!wxTheClipboard->IsOpened() && wxTheClipboard->Open())
6261     {
6262         wxTheClipboard->Clear();
6263
6264         // Add composite object
6265
6266         wxDataObjectComposite* compositeObject = new wxDataObjectComposite();
6267
6268         {
6269             wxString text = GetTextForRange(range);
6270
6271 #ifdef __WXMSW__
6272             text = wxTextFile::Translate(text, wxTextFileType_Dos);
6273 #endif
6274
6275             compositeObject->Add(new wxTextDataObject(text), false /* not preferred */);
6276         }
6277
6278         // Add rich text buffer data object. This needs the XML handler to be present.
6279
6280         if (FindHandler(wxRICHTEXT_TYPE_XML))
6281         {
6282             wxRichTextBuffer* richTextBuf = new wxRichTextBuffer;
6283             CopyFragment(range, *richTextBuf);
6284
6285             compositeObject->Add(new wxRichTextBufferDataObject(richTextBuf), true /* preferred */);
6286         }
6287
6288         if (wxTheClipboard->SetData(compositeObject))
6289             success = true;
6290
6291         wxTheClipboard->Close();
6292     }
6293
6294 #else
6295     wxUnusedVar(range);
6296 #endif
6297     return success;
6298 }
6299
6300 /// Paste the clipboard content to the buffer
6301 bool wxRichTextBuffer::PasteFromClipboard(long position)
6302 {
6303     bool success = false;
6304 #if wxUSE_CLIPBOARD && wxUSE_DATAOBJ
6305     if (CanPasteFromClipboard())
6306     {
6307         if (wxTheClipboard->Open())
6308         {
6309             if (wxTheClipboard->IsSupported(wxDataFormat(wxRichTextBufferDataObject::GetRichTextBufferFormatId())))
6310             {
6311                 wxRichTextBufferDataObject data;
6312                 wxTheClipboard->GetData(data);
6313                 wxRichTextBuffer* richTextBuffer = data.GetRichTextBuffer();
6314                 if (richTextBuffer)
6315                 {
6316                     InsertParagraphsWithUndo(position+1, *richTextBuffer, GetRichTextCtrl(), 0);
6317                     if (GetRichTextCtrl())
6318                         GetRichTextCtrl()->ShowPosition(position + richTextBuffer->GetRange().GetEnd());
6319                     delete richTextBuffer;
6320                 }
6321             }
6322             else if (wxTheClipboard->IsSupported(wxDF_TEXT) || wxTheClipboard->IsSupported(wxDF_UNICODETEXT))
6323             {
6324                 wxTextDataObject data;
6325                 wxTheClipboard->GetData(data);
6326                 wxString text(data.GetText());
6327 #ifdef __WXMSW__
6328                 wxString text2;
6329                 text2.Alloc(text.Length()+1);
6330                 size_t i;
6331                 for (i = 0; i < text.Length(); i++)
6332                 {
6333                     wxChar ch = text[i];
6334                     if (ch != wxT('\r'))
6335                         text2 += ch;
6336                 }
6337 #else
6338                 wxString text2 = text;
6339 #endif
6340                 InsertTextWithUndo(position+1, text2, GetRichTextCtrl(), wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE);
6341
6342                 if (GetRichTextCtrl())
6343                     GetRichTextCtrl()->ShowPosition(position + text2.Length());
6344
6345                 success = true;
6346             }
6347             else if (wxTheClipboard->IsSupported(wxDF_BITMAP))
6348             {
6349                 wxBitmapDataObject data;
6350                 wxTheClipboard->GetData(data);
6351                 wxBitmap bitmap(data.GetBitmap());
6352                 wxImage image(bitmap.ConvertToImage());
6353
6354                 wxRichTextAction* action = new wxRichTextAction(NULL, _("Insert Image"), wxRICHTEXT_INSERT, this, GetRichTextCtrl(), false);
6355
6356                 action->GetNewParagraphs().AddImage(image);
6357
6358                 if (action->GetNewParagraphs().GetChildCount() == 1)
6359                     action->GetNewParagraphs().SetPartialParagraph(true);
6360
6361                 action->SetPosition(position+1);
6362
6363                 // Set the range we'll need to delete in Undo
6364                 action->SetRange(wxRichTextRange(position+1, position+1));
6365
6366                 SubmitAction(action);
6367
6368                 success = true;
6369             }
6370             wxTheClipboard->Close();
6371         }
6372     }
6373 #else
6374     wxUnusedVar(position);
6375 #endif
6376     return success;
6377 }
6378
6379 /// Can we paste from the clipboard?
6380 bool wxRichTextBuffer::CanPasteFromClipboard() const
6381 {
6382     bool canPaste = false;
6383 #if wxUSE_CLIPBOARD && wxUSE_DATAOBJ
6384     if (!wxTheClipboard->IsOpened() && wxTheClipboard->Open())
6385     {
6386         if (wxTheClipboard->IsSupported(wxDF_TEXT) || wxTheClipboard->IsSupported(wxDF_UNICODETEXT) ||
6387             wxTheClipboard->IsSupported(wxDataFormat(wxRichTextBufferDataObject::GetRichTextBufferFormatId())) ||
6388             wxTheClipboard->IsSupported(wxDF_BITMAP))
6389         {
6390             canPaste = true;
6391         }
6392         wxTheClipboard->Close();
6393     }
6394 #endif
6395     return canPaste;
6396 }
6397
6398 /// Dumps contents of buffer for debugging purposes
6399 void wxRichTextBuffer::Dump()
6400 {
6401     wxString text;
6402     {
6403         wxStringOutputStream stream(& text);
6404         wxTextOutputStream textStream(stream);
6405         Dump(textStream);
6406     }
6407
6408     wxLogDebug(text);
6409 }
6410
6411 /// Add an event handler
6412 bool wxRichTextBuffer::AddEventHandler(wxEvtHandler* handler)
6413 {
6414     m_eventHandlers.Append(handler);
6415     return true;
6416 }
6417
6418 /// Remove an event handler
6419 bool wxRichTextBuffer::RemoveEventHandler(wxEvtHandler* handler, bool deleteHandler)
6420 {
6421     wxList::compatibility_iterator node = m_eventHandlers.Find(handler);
6422     if (node)
6423     {
6424         m_eventHandlers.Erase(node);
6425         if (deleteHandler)
6426             delete handler;
6427
6428         return true;
6429     }
6430     else
6431         return false;
6432 }
6433
6434 /// Clear event handlers
6435 void wxRichTextBuffer::ClearEventHandlers()
6436 {
6437     m_eventHandlers.Clear();
6438 }
6439
6440 /// Send event to event handlers. If sendToAll is true, will send to all event handlers,
6441 /// otherwise will stop at the first successful one.
6442 bool wxRichTextBuffer::SendEvent(wxEvent& event, bool sendToAll)
6443 {
6444     bool success = false;
6445     for (wxList::compatibility_iterator node = m_eventHandlers.GetFirst(); node; node = node->GetNext())
6446     {
6447         wxEvtHandler* handler = (wxEvtHandler*) node->GetData();
6448         if (handler->ProcessEvent(event))
6449         {
6450             success = true;
6451             if (!sendToAll)
6452                 return true;
6453         }
6454     }
6455     return success;
6456 }
6457
6458 /// Set style sheet and notify of the change
6459 bool wxRichTextBuffer::SetStyleSheetAndNotify(wxRichTextStyleSheet* sheet)
6460 {
6461     wxRichTextStyleSheet* oldSheet = GetStyleSheet();
6462
6463     wxWindowID id = wxID_ANY;
6464     if (GetRichTextCtrl())
6465         id = GetRichTextCtrl()->GetId();
6466
6467     wxRichTextEvent event(wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACING, id);
6468     event.SetEventObject(GetRichTextCtrl());
6469     event.SetOldStyleSheet(oldSheet);
6470     event.SetNewStyleSheet(sheet);
6471     event.Allow();
6472
6473     if (SendEvent(event) && !event.IsAllowed())
6474     {
6475         if (sheet != oldSheet)
6476             delete sheet;
6477
6478         return false;
6479     }
6480
6481     if (oldSheet && oldSheet != sheet)
6482         delete oldSheet;
6483
6484     SetStyleSheet(sheet);
6485
6486     event.SetEventType(wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACED);
6487     event.SetOldStyleSheet(NULL);
6488     event.Allow();
6489
6490     return SendEvent(event);
6491 }
6492
6493 /// Set renderer, deleting old one
6494 void wxRichTextBuffer::SetRenderer(wxRichTextRenderer* renderer)
6495 {
6496     if (sm_renderer)
6497         delete sm_renderer;
6498     sm_renderer = renderer;
6499 }
6500
6501 bool wxRichTextStdRenderer::DrawStandardBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& bulletAttr, const wxRect& rect)
6502 {
6503     if (bulletAttr.GetTextColour().Ok())
6504     {
6505         wxCheckSetPen(dc, wxPen(bulletAttr.GetTextColour()));
6506         wxCheckSetBrush(dc, wxBrush(bulletAttr.GetTextColour()));
6507     }
6508     else
6509     {
6510         wxCheckSetPen(dc, *wxBLACK_PEN);
6511         wxCheckSetBrush(dc, *wxBLACK_BRUSH);
6512     }
6513
6514     wxFont font;
6515     if (bulletAttr.HasFont())
6516     {
6517         font = paragraph->GetBuffer()->GetFontTable().FindFont(bulletAttr);
6518     }
6519     else
6520         font = (*wxNORMAL_FONT);
6521
6522     wxCheckSetFont(dc, font);
6523
6524     int charHeight = dc.GetCharHeight();
6525
6526     int bulletWidth = (int) (((float) charHeight) * wxRichTextBuffer::GetBulletProportion());
6527     int bulletHeight = bulletWidth;
6528
6529     int x = rect.x;
6530
6531     // Calculate the top position of the character (as opposed to the whole line height)
6532     int y = rect.y + (rect.height - charHeight);
6533
6534     // Calculate where the bullet should be positioned
6535     y = y + (charHeight+1)/2 - (bulletHeight+1)/2;
6536
6537     // The margin between a bullet and text.
6538     int margin = paragraph->ConvertTenthsMMToPixels(dc, wxRichTextBuffer::GetBulletRightMargin());
6539
6540     if (bulletAttr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ALIGN_RIGHT)
6541         x = rect.x + rect.width - bulletWidth - margin;
6542     else if (bulletAttr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ALIGN_CENTRE)
6543         x = x + (rect.width)/2 - bulletWidth/2;
6544
6545     if (bulletAttr.GetBulletName() == wxT("standard/square"))
6546     {
6547         dc.DrawRectangle(x, y, bulletWidth, bulletHeight);
6548     }
6549     else if (bulletAttr.GetBulletName() == wxT("standard/diamond"))
6550     {
6551         wxPoint pts[5];
6552         pts[0].x = x;                   pts[0].y = y + bulletHeight/2;
6553         pts[1].x = x + bulletWidth/2;   pts[1].y = y;
6554         pts[2].x = x + bulletWidth;     pts[2].y = y + bulletHeight/2;
6555         pts[3].x = x + bulletWidth/2;   pts[3].y = y + bulletHeight;
6556
6557         dc.DrawPolygon(4, pts);
6558     }
6559     else if (bulletAttr.GetBulletName() == wxT("standard/triangle"))
6560     {
6561         wxPoint pts[3];
6562         pts[0].x = x;                   pts[0].y = y;
6563         pts[1].x = x + bulletWidth;     pts[1].y = y + bulletHeight/2;
6564         pts[2].x = x;                   pts[2].y = y + bulletHeight;
6565
6566         dc.DrawPolygon(3, pts);
6567     }
6568     else // "standard/circle", and catch-all
6569     {
6570         dc.DrawEllipse(x, y, bulletWidth, bulletHeight);
6571     }
6572
6573     return true;
6574 }
6575
6576 bool wxRichTextStdRenderer::DrawTextBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect, const wxString& text)
6577 {
6578     if (!text.empty())
6579     {
6580         wxFont font;
6581         if ((attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_SYMBOL) && !attr.GetBulletFont().IsEmpty() && attr.HasFont())
6582         {
6583             wxRichTextAttr fontAttr;
6584             fontAttr.SetFontSize(attr.GetFontSize());
6585             fontAttr.SetFontStyle(attr.GetFontStyle());
6586             fontAttr.SetFontWeight(attr.GetFontWeight());
6587             fontAttr.SetFontUnderlined(attr.GetFontUnderlined());
6588             fontAttr.SetFontFaceName(attr.GetBulletFont());
6589             font = paragraph->GetBuffer()->GetFontTable().FindFont(fontAttr);
6590         }
6591         else if (attr.HasFont())
6592             font = paragraph->GetBuffer()->GetFontTable().FindFont(attr);
6593         else
6594             font = (*wxNORMAL_FONT);
6595
6596         wxCheckSetFont(dc, font);
6597
6598         if (attr.GetTextColour().Ok())
6599             dc.SetTextForeground(attr.GetTextColour());
6600
6601         dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
6602
6603         int charHeight = dc.GetCharHeight();
6604         wxCoord tw, th;
6605         dc.GetTextExtent(text, & tw, & th);
6606
6607         int x = rect.x;
6608
6609         // Calculate the top position of the character (as opposed to the whole line height)
6610         int y = rect.y + (rect.height - charHeight);
6611
6612         // The margin between a bullet and text.
6613         int margin = paragraph->ConvertTenthsMMToPixels(dc, wxRichTextBuffer::GetBulletRightMargin());
6614
6615         if (attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ALIGN_RIGHT)
6616             x = (rect.x + rect.width) - tw - margin;
6617         else if (attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ALIGN_CENTRE)
6618             x = x + (rect.width)/2 - tw/2;
6619
6620         dc.DrawText(text, x, y);
6621
6622         return true;
6623     }
6624     else
6625         return false;
6626 }
6627
6628 bool wxRichTextStdRenderer::DrawBitmapBullet(wxRichTextParagraph* WXUNUSED(paragraph), wxDC& WXUNUSED(dc), const wxRichTextAttr& WXUNUSED(attr), const wxRect& WXUNUSED(rect))
6629 {
6630     // Currently unimplemented. The intention is to store bitmaps by name in a media store associated
6631     // with the buffer. The store will allow retrieval from memory, disk or other means.
6632     return false;
6633 }
6634
6635 /// Enumerate the standard bullet names currently supported
6636 bool wxRichTextStdRenderer::EnumerateStandardBulletNames(wxArrayString& bulletNames)
6637 {
6638     bulletNames.Add(wxTRANSLATE("standard/circle"));
6639     bulletNames.Add(wxTRANSLATE("standard/square"));
6640     bulletNames.Add(wxTRANSLATE("standard/diamond"));
6641     bulletNames.Add(wxTRANSLATE("standard/triangle"));
6642
6643     return true;
6644 }
6645
6646 /*
6647  * Module to initialise and clean up handlers
6648  */
6649
6650 class wxRichTextModule: public wxModule
6651 {
6652 DECLARE_DYNAMIC_CLASS(wxRichTextModule)
6653 public:
6654     wxRichTextModule() {}
6655     bool OnInit()
6656     {
6657         wxRichTextBuffer::SetRenderer(new wxRichTextStdRenderer);
6658         wxRichTextBuffer::InitStandardHandlers();
6659         wxRichTextParagraph::InitDefaultTabs();
6660         return true;
6661     }
6662     void OnExit()
6663     {
6664         wxRichTextBuffer::CleanUpHandlers();
6665         wxRichTextDecimalToRoman(-1);
6666         wxRichTextParagraph::ClearDefaultTabs();
6667         wxRichTextCtrl::ClearAvailableFontNames();
6668         wxRichTextBuffer::SetRenderer(NULL);
6669     }
6670 };
6671
6672 IMPLEMENT_DYNAMIC_CLASS(wxRichTextModule, wxModule)
6673
6674
6675 // If the richtext lib is dynamically loaded after the app has already started
6676 // (such as from wxPython) then the built-in module system will not init this
6677 // module.  Provide this function to do it manually.
6678 void wxRichTextModuleInit()
6679 {
6680     wxModule* module = new wxRichTextModule;
6681     module->Init();
6682     wxModule::RegisterModule(module);
6683 }
6684
6685
6686 /*!
6687  * Commands for undo/redo
6688  *
6689  */
6690
6691 wxRichTextCommand::wxRichTextCommand(const wxString& name, wxRichTextCommandId id, wxRichTextBuffer* buffer,
6692                                      wxRichTextCtrl* ctrl, bool ignoreFirstTime): wxCommand(true, name)
6693 {
6694     /* wxRichTextAction* action = */ new wxRichTextAction(this, name, id, buffer, ctrl, ignoreFirstTime);
6695 }
6696
6697 wxRichTextCommand::wxRichTextCommand(const wxString& name): wxCommand(true, name)
6698 {
6699 }
6700
6701 wxRichTextCommand::~wxRichTextCommand()
6702 {
6703     ClearActions();
6704 }
6705
6706 void wxRichTextCommand::AddAction(wxRichTextAction* action)
6707 {
6708     if (!m_actions.Member(action))
6709         m_actions.Append(action);
6710 }
6711
6712 bool wxRichTextCommand::Do()
6713 {
6714     for (wxList::compatibility_iterator node = m_actions.GetFirst(); node; node = node->GetNext())
6715     {
6716         wxRichTextAction* action = (wxRichTextAction*) node->GetData();
6717         action->Do();
6718     }
6719
6720     return true;
6721 }
6722
6723 bool wxRichTextCommand::Undo()
6724 {
6725     for (wxList::compatibility_iterator node = m_actions.GetLast(); node; node = node->GetPrevious())
6726     {
6727         wxRichTextAction* action = (wxRichTextAction*) node->GetData();
6728         action->Undo();
6729     }
6730
6731     return true;
6732 }
6733
6734 void wxRichTextCommand::ClearActions()
6735 {
6736     WX_CLEAR_LIST(wxList, m_actions);
6737 }
6738
6739 /*!
6740  * Individual action
6741  *
6742  */
6743
6744 wxRichTextAction::wxRichTextAction(wxRichTextCommand* cmd, const wxString& name, wxRichTextCommandId id, wxRichTextBuffer* buffer,
6745                                      wxRichTextCtrl* ctrl, bool ignoreFirstTime)
6746 {
6747     m_buffer = buffer;
6748     m_ignoreThis = ignoreFirstTime;
6749     m_cmdId = id;
6750     m_position = -1;
6751     m_ctrl = ctrl;
6752     m_name = name;
6753     m_newParagraphs.SetDefaultStyle(buffer->GetDefaultStyle());
6754     m_newParagraphs.SetBasicStyle(buffer->GetBasicStyle());
6755     if (cmd)
6756         cmd->AddAction(this);
6757 }
6758
6759 wxRichTextAction::~wxRichTextAction()
6760 {
6761 }
6762
6763 void wxRichTextAction::CalculateRefreshOptimizations(wxArrayInt& optimizationLineCharPositions, wxArrayInt& optimizationLineYPositions)
6764 {
6765     // Store a list of line start character and y positions so we can figure out which area
6766     // we need to refresh
6767
6768 #if wxRICHTEXT_USE_OPTIMIZED_DRAWING
6769     // NOTE: we're assuming that the buffer is laid out correctly at this point.
6770     // If we had several actions, which only invalidate and leave layout until the
6771     // paint handler is called, then this might not be true. So we may need to switch
6772     // optimisation on only when we're simply adding text and not simultaneously
6773     // deleting a selection, for example. Or, we make sure the buffer is laid out correctly
6774     // first, but of course this means we'll be doing it twice.
6775     if (!m_buffer->GetDirty() && m_ctrl) // can only do optimisation if the buffer is already laid out correctly
6776     {
6777         wxSize clientSize = m_ctrl->GetClientSize();
6778         wxPoint firstVisiblePt = m_ctrl->GetFirstVisiblePoint();
6779         int lastY = firstVisiblePt.y + clientSize.y;
6780
6781         wxRichTextParagraph* para = m_buffer->GetParagraphAtPosition(GetRange().GetStart());
6782         wxRichTextObjectList::compatibility_iterator node = m_buffer->GetChildren().Find(para);
6783         while (node)
6784         {
6785             wxRichTextParagraph* child = (wxRichTextParagraph*) node->GetData();
6786             wxRichTextLineList::compatibility_iterator node2 = child->GetLines().GetFirst();
6787             while (node2)
6788             {
6789                 wxRichTextLine* line = node2->GetData();
6790                 wxPoint pt = line->GetAbsolutePosition();
6791                 wxRichTextRange range = line->GetAbsoluteRange();
6792
6793                 if (pt.y > lastY)
6794                 {
6795                     node2 = wxRichTextLineList::compatibility_iterator();
6796                     node = wxRichTextObjectList::compatibility_iterator();
6797                 }
6798                 else if (range.GetStart() > GetPosition() && pt.y >= firstVisiblePt.y)
6799                 {
6800                     optimizationLineCharPositions.Add(range.GetStart());
6801                     optimizationLineYPositions.Add(pt.y);
6802                 }
6803
6804                 if (node2)
6805                     node2 = node2->GetNext();
6806             }
6807
6808             if (node)
6809                 node = node->GetNext();
6810         }
6811     }
6812 #endif
6813 }
6814
6815 bool wxRichTextAction::Do()
6816 {
6817     m_buffer->Modify(true);
6818
6819     switch (m_cmdId)
6820     {
6821     case wxRICHTEXT_INSERT:
6822         {
6823             // Store a list of line start character and y positions so we can figure out which area
6824             // we need to refresh
6825             wxArrayInt optimizationLineCharPositions;
6826             wxArrayInt optimizationLineYPositions;
6827
6828 #if wxRICHTEXT_USE_OPTIMIZED_DRAWING
6829             CalculateRefreshOptimizations(optimizationLineCharPositions, optimizationLineYPositions);
6830 #endif
6831
6832             m_buffer->InsertFragment(GetRange().GetStart(), m_newParagraphs);
6833             m_buffer->UpdateRanges();
6834             m_buffer->Invalidate(wxRichTextRange(wxMax(0, GetRange().GetStart()-1), GetRange().GetEnd()));
6835
6836             long newCaretPosition = GetPosition() + m_newParagraphs.GetRange().GetLength();
6837
6838             // Character position to caret position
6839             newCaretPosition --;
6840
6841             // Don't take into account the last newline
6842             if (m_newParagraphs.GetPartialParagraph())
6843                 newCaretPosition --;
6844             else
6845                 if (m_newParagraphs.GetChildren().GetCount() > 1)
6846                 {
6847                     wxRichTextObject* p = (wxRichTextObject*) m_newParagraphs.GetChildren().GetLast()->GetData();
6848                     if (p->GetRange().GetLength() == 1)
6849                         newCaretPosition --;
6850                 }
6851
6852             newCaretPosition = wxMin(newCaretPosition, (m_buffer->GetRange().GetEnd()-1));
6853
6854             UpdateAppearance(newCaretPosition, true /* send update event */, & optimizationLineCharPositions, & optimizationLineYPositions, true /* do */);
6855
6856             wxRichTextEvent cmdEvent(
6857                 wxEVT_COMMAND_RICHTEXT_CONTENT_INSERTED,
6858                 m_ctrl ? m_ctrl->GetId() : -1);
6859             cmdEvent.SetEventObject(m_ctrl ? (wxObject*) m_ctrl : (wxObject*) m_buffer);
6860             cmdEvent.SetRange(GetRange());
6861             cmdEvent.SetPosition(GetRange().GetStart());
6862
6863             m_buffer->SendEvent(cmdEvent);
6864
6865             break;
6866         }
6867     case wxRICHTEXT_DELETE:
6868         {
6869             wxArrayInt optimizationLineCharPositions;
6870             wxArrayInt optimizationLineYPositions;
6871
6872 #if wxRICHTEXT_USE_OPTIMIZED_DRAWING
6873             CalculateRefreshOptimizations(optimizationLineCharPositions, optimizationLineYPositions);
6874 #endif
6875
6876             m_buffer->DeleteRange(GetRange());
6877             m_buffer->UpdateRanges();
6878             m_buffer->Invalidate(wxRichTextRange(GetRange().GetStart(), GetRange().GetStart()));
6879
6880             long caretPos = GetRange().GetStart()-1;
6881             if (caretPos >= m_buffer->GetRange().GetEnd())
6882                 caretPos --;
6883
6884             UpdateAppearance(caretPos, true /* send update event */, & optimizationLineCharPositions, & optimizationLineYPositions, true /* do */);
6885
6886             wxRichTextEvent cmdEvent(
6887                 wxEVT_COMMAND_RICHTEXT_CONTENT_DELETED,
6888                 m_ctrl ? m_ctrl->GetId() : -1);
6889             cmdEvent.SetEventObject(m_ctrl ? (wxObject*) m_ctrl : (wxObject*) m_buffer);
6890             cmdEvent.SetRange(GetRange());
6891             cmdEvent.SetPosition(GetRange().GetStart());
6892
6893             m_buffer->SendEvent(cmdEvent);
6894
6895             break;
6896         }
6897     case wxRICHTEXT_CHANGE_STYLE:
6898         {
6899             ApplyParagraphs(GetNewParagraphs());
6900             m_buffer->Invalidate(GetRange());
6901
6902             UpdateAppearance(GetPosition());
6903
6904             wxRichTextEvent cmdEvent(
6905                 wxEVT_COMMAND_RICHTEXT_STYLE_CHANGED,
6906                 m_ctrl ? m_ctrl->GetId() : -1);
6907             cmdEvent.SetEventObject(m_ctrl ? (wxObject*) m_ctrl : (wxObject*) m_buffer);
6908             cmdEvent.SetRange(GetRange());
6909             cmdEvent.SetPosition(GetRange().GetStart());
6910
6911             m_buffer->SendEvent(cmdEvent);
6912
6913             break;
6914         }
6915     default:
6916         break;
6917     }
6918
6919     return true;
6920 }
6921
6922 bool wxRichTextAction::Undo()
6923 {
6924     m_buffer->Modify(true);
6925
6926     switch (m_cmdId)
6927     {
6928     case wxRICHTEXT_INSERT:
6929         {
6930             wxArrayInt optimizationLineCharPositions;
6931             wxArrayInt optimizationLineYPositions;
6932
6933 #if wxRICHTEXT_USE_OPTIMIZED_DRAWING
6934             CalculateRefreshOptimizations(optimizationLineCharPositions, optimizationLineYPositions);
6935 #endif
6936
6937             m_buffer->DeleteRange(GetRange());
6938             m_buffer->UpdateRanges();
6939             m_buffer->Invalidate(wxRichTextRange(GetRange().GetStart(), GetRange().GetStart()));
6940
6941             long newCaretPosition = GetPosition() - 1;
6942
6943             UpdateAppearance(newCaretPosition, true, /* send update event */ & optimizationLineCharPositions, & optimizationLineYPositions, false /* undo */);
6944
6945             wxRichTextEvent cmdEvent(
6946                 wxEVT_COMMAND_RICHTEXT_CONTENT_DELETED,
6947                 m_ctrl ? m_ctrl->GetId() : -1);
6948             cmdEvent.SetEventObject(m_ctrl ? (wxObject*) m_ctrl : (wxObject*) m_buffer);
6949             cmdEvent.SetRange(GetRange());
6950             cmdEvent.SetPosition(GetRange().GetStart());
6951
6952             m_buffer->SendEvent(cmdEvent);
6953
6954             break;
6955         }
6956     case wxRICHTEXT_DELETE:
6957         {
6958             wxArrayInt optimizationLineCharPositions;
6959             wxArrayInt optimizationLineYPositions;
6960
6961 #if wxRICHTEXT_USE_OPTIMIZED_DRAWING
6962             CalculateRefreshOptimizations(optimizationLineCharPositions, optimizationLineYPositions);
6963 #endif
6964
6965             m_buffer->InsertFragment(GetRange().GetStart(), m_oldParagraphs);
6966             m_buffer->UpdateRanges();
6967             m_buffer->Invalidate(GetRange());
6968
6969             UpdateAppearance(GetPosition(), true, /* send update event */ & optimizationLineCharPositions, & optimizationLineYPositions, false /* undo */);
6970
6971             wxRichTextEvent cmdEvent(
6972                 wxEVT_COMMAND_RICHTEXT_CONTENT_INSERTED,
6973                 m_ctrl ? m_ctrl->GetId() : -1);
6974             cmdEvent.SetEventObject(m_ctrl ? (wxObject*) m_ctrl : (wxObject*) m_buffer);
6975             cmdEvent.SetRange(GetRange());
6976             cmdEvent.SetPosition(GetRange().GetStart());
6977
6978             m_buffer->SendEvent(cmdEvent);
6979
6980             break;
6981         }
6982     case wxRICHTEXT_CHANGE_STYLE:
6983         {
6984             ApplyParagraphs(GetOldParagraphs());
6985             m_buffer->Invalidate(GetRange());
6986
6987             UpdateAppearance(GetPosition());
6988
6989             wxRichTextEvent cmdEvent(
6990                 wxEVT_COMMAND_RICHTEXT_STYLE_CHANGED,
6991                 m_ctrl ? m_ctrl->GetId() : -1);
6992             cmdEvent.SetEventObject(m_ctrl ? (wxObject*) m_ctrl : (wxObject*) m_buffer);
6993             cmdEvent.SetRange(GetRange());
6994             cmdEvent.SetPosition(GetRange().GetStart());
6995
6996             m_buffer->SendEvent(cmdEvent);
6997
6998             break;
6999         }
7000     default:
7001         break;
7002     }
7003
7004     return true;
7005 }
7006
7007 /// Update the control appearance
7008 void wxRichTextAction::UpdateAppearance(long caretPosition, bool sendUpdateEvent, wxArrayInt* WXUNUSED(optimizationLineCharPositions), wxArrayInt* WXUNUSED(optimizationLineYPositions), bool WXUNUSED(isDoCmd))
7009 {
7010     if (m_ctrl)
7011     {
7012         m_ctrl->SetCaretPosition(caretPosition);
7013         if (!m_ctrl->IsFrozen())
7014         {
7015             m_ctrl->LayoutContent();
7016             // TODO Refresh the whole client area now
7017             m_ctrl->Refresh(false);
7018
7019 #if wxRICHTEXT_USE_OWN_CARET
7020             m_ctrl->PositionCaret();
7021 #endif
7022             if (sendUpdateEvent)
7023                 wxTextCtrl::SendTextUpdatedEvent(m_ctrl);
7024         }
7025     }
7026 }
7027
7028 /// Replace the buffer paragraphs with the new ones.
7029 void wxRichTextAction::ApplyParagraphs(const wxRichTextParagraphLayoutBox& fragment)
7030 {
7031     wxRichTextObjectList::compatibility_iterator node = fragment.GetChildren().GetFirst();
7032     while (node)
7033     {
7034         wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
7035         wxASSERT (para != NULL);
7036
7037         // We'll replace the existing paragraph by finding the paragraph at this position,
7038         // delete its node data, and setting a copy as the new node data.
7039         // TODO: make more efficient by simply swapping old and new paragraph objects.
7040
7041         wxRichTextParagraph* existingPara = m_buffer->GetParagraphAtPosition(para->GetRange().GetStart());
7042         if (existingPara)
7043         {
7044             wxRichTextObjectList::compatibility_iterator bufferParaNode = m_buffer->GetChildren().Find(existingPara);
7045             if (bufferParaNode)
7046             {
7047                 wxRichTextParagraph* newPara = new wxRichTextParagraph(*para);
7048                 newPara->SetParent(m_buffer);
7049
7050                 bufferParaNode->SetData(newPara);
7051
7052                 delete existingPara;
7053             }
7054         }
7055
7056         node = node->GetNext();
7057     }
7058 }
7059
7060
7061 /*!
7062  * wxRichTextRange
7063  * This stores beginning and end positions for a range of data.
7064  */
7065
7066 /// Limit this range to be within 'range'
7067 bool wxRichTextRange::LimitTo(const wxRichTextRange& range)
7068 {
7069     if (m_start < range.m_start)
7070         m_start = range.m_start;
7071
7072     if (m_end > range.m_end)
7073         m_end = range.m_end;
7074
7075     return true;
7076 }
7077
7078 /*!
7079  * wxRichTextAnchoredObject implementation
7080  */
7081 IMPLEMENT_CLASS(wxRichTextAnchoredObject, wxRichTextObject)
7082
7083 wxRichTextAnchoredObject::wxRichTextAnchoredObject(wxRichTextObject* parent, const wxRichTextAttr& attr):
7084     wxRichTextObject(parent)
7085 {
7086     SetAttributes(attr);
7087 }
7088
7089 wxRichTextAnchoredObject::~wxRichTextAnchoredObject()
7090 {
7091 }
7092
7093 void wxRichTextAnchoredObject::Copy(const wxRichTextAnchoredObject& obj)
7094 {
7095     wxRichTextObject::Copy(obj);
7096 }
7097
7098 void wxRichTextAnchoredObject::SetParent(wxRichTextObject* parent)
7099 {
7100     wxRichTextObject::SetParent(parent);
7101 }
7102
7103 /*!
7104  * wxRichTextImage implementation
7105  * This object represents an image.
7106  */
7107
7108 IMPLEMENT_DYNAMIC_CLASS(wxRichTextImage, wxRichTextAnchoredObject)
7109
7110 wxRichTextImage::wxRichTextImage(const wxImage& image, wxRichTextObject* parent, wxRichTextAttr* charStyle):
7111     wxRichTextAnchoredObject(parent)
7112 {
7113     m_imageBlock.MakeImageBlockDefaultQuality(image, wxBITMAP_TYPE_PNG);
7114     if (charStyle)
7115         SetAttributes(*charStyle);
7116 }
7117
7118 wxRichTextImage::wxRichTextImage(const wxRichTextImageBlock& imageBlock, wxRichTextObject* parent, wxRichTextAttr* charStyle):
7119     wxRichTextAnchoredObject(parent)
7120 {
7121     m_imageBlock = imageBlock;
7122     if (charStyle)
7123         SetAttributes(*charStyle);
7124 }
7125
7126 /// Create a cached image at the required size
7127 bool wxRichTextImage::LoadImageCache(wxDC& dc, bool resetCache)
7128 {
7129     if (resetCache || !m_imageCache.IsOk() /* || m_imageCache.GetWidth() != size.x || m_imageCache.GetHeight() != size.y */)
7130     {
7131         if (!m_imageBlock.IsOk())
7132             return false;
7133
7134         wxImage image;
7135         m_imageBlock.Load(image);
7136         if (!image.IsOk())
7137             return false;
7138
7139         int width = image.GetWidth();
7140         int height = image.GetHeight();
7141
7142         if (GetAttributes().GetTextBoxAttr().GetWidth().IsPresent() && GetAttributes().GetTextBoxAttr().GetWidth().GetValue() > 0)
7143         {
7144             if (GetAttributes().GetTextBoxAttr().GetWidth().GetUnits() == wxTEXT_ATTR_UNITS_TENTHS_MM)
7145                 width = ConvertTenthsMMToPixels(dc, GetAttributes().GetTextBoxAttr().GetWidth().GetValue());
7146             else
7147                 width = GetAttributes().GetTextBoxAttr().GetWidth().GetValue();
7148         }
7149         if (GetAttributes().GetTextBoxAttr().GetHeight().IsPresent() && GetAttributes().GetTextBoxAttr().GetHeight().GetValue() > 0)
7150         {
7151             if (GetAttributes().GetTextBoxAttr().GetHeight().GetUnits() == wxTEXT_ATTR_UNITS_TENTHS_MM)
7152                 height = ConvertTenthsMMToPixels(dc, GetAttributes().GetTextBoxAttr().GetHeight().GetValue());
7153             else
7154                 height = GetAttributes().GetTextBoxAttr().GetHeight().GetValue();
7155         }
7156
7157         if (image.GetWidth() == width && image.GetHeight() == height)
7158             m_imageCache = wxBitmap(image);
7159         else
7160         {
7161             // If the original width and height is small, e.g. 400 or below,
7162             // scale up and then down to improve image quality. This can make
7163             // a big difference, with not much performance hit.
7164             int upscaleThreshold = 400;
7165             wxImage img;
7166             if (image.GetWidth() <= upscaleThreshold || image.GetHeight() <= upscaleThreshold)
7167             {
7168                 img = image.Scale(image.GetWidth()*2, image.GetHeight()*2);
7169                 img.Rescale(width, height, wxIMAGE_QUALITY_HIGH);
7170             }
7171             else
7172                 img = image.Scale(width, height, wxIMAGE_QUALITY_HIGH);
7173             m_imageCache = wxBitmap(img);
7174         }
7175     }
7176
7177     return m_imageCache.IsOk();
7178 }
7179
7180 /// Draw the item
7181 bool wxRichTextImage::Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int WXUNUSED(descent), int WXUNUSED(style))
7182 {
7183     // Don't need cached size AFAIK
7184     // wxSize size = GetCachedSize();
7185     if (!LoadImageCache(dc))
7186         return false;
7187
7188     int y = rect.y + (rect.height - m_imageCache.GetHeight());
7189
7190     dc.DrawBitmap(m_imageCache, rect.x, y, true);
7191
7192     if (selectionRange.Contains(range.GetStart()))
7193     {
7194         wxCheckSetBrush(dc, *wxBLACK_BRUSH);
7195         wxCheckSetPen(dc, *wxBLACK_PEN);
7196         dc.SetLogicalFunction(wxINVERT);
7197         dc.DrawRectangle(rect);
7198         dc.SetLogicalFunction(wxCOPY);
7199     }
7200
7201     return true;
7202 }
7203
7204 /// Lay the item out
7205 bool wxRichTextImage::Layout(wxDC& dc, const wxRect& rect, int WXUNUSED(style))
7206 {
7207     if (!LoadImageCache(dc))
7208         return false;
7209
7210     SetCachedSize(wxSize(m_imageCache.GetWidth(), m_imageCache.GetHeight()));
7211     SetPosition(rect.GetPosition());
7212
7213     return true;
7214 }
7215
7216 /// Get/set the object size for the given range. Returns false if the range
7217 /// is invalid for this object.
7218 bool wxRichTextImage::GetRangeSize(const wxRichTextRange& range, wxSize& size, int& WXUNUSED(descent), wxDC& dc, int WXUNUSED(flags), wxPoint WXUNUSED(position), wxArrayInt* partialExtents) const
7219 {
7220     if (!range.IsWithin(GetRange()))
7221         return false;
7222
7223     if (!((wxRichTextImage*)this)->LoadImageCache(dc))
7224     {
7225         size.x = 0; size.y = 0;
7226         if (partialExtents)
7227             partialExtents->Add(0);
7228         return false;
7229     }
7230
7231     int width = m_imageCache.GetWidth();
7232     int height = m_imageCache.GetHeight();
7233
7234     if (partialExtents)
7235         partialExtents->Add(width);
7236
7237     size.x = width;
7238     size.y = height;
7239
7240     return true;
7241 }
7242
7243 /// Copy
7244 void wxRichTextImage::Copy(const wxRichTextImage& obj)
7245 {
7246     wxRichTextAnchoredObject::Copy(obj);
7247
7248     m_imageBlock = obj.m_imageBlock;
7249 }
7250
7251 /// Edit properties via a GUI
7252 bool wxRichTextImage::EditProperties(wxWindow* parent, wxRichTextBuffer* buffer)
7253 {
7254     wxRichTextImageDialog imageDlg(wxGetTopLevelParent(parent));
7255     imageDlg.SetImageObject(this, buffer);
7256
7257     if (imageDlg.ShowModal() == wxID_OK)
7258     {
7259         imageDlg.ApplyImageAttr();
7260         return true;
7261     }
7262     else
7263         return false;
7264 }
7265
7266 /*!
7267  * Utilities
7268  *
7269  */
7270
7271 /// Compare two attribute objects
7272 bool wxTextAttrEq(const wxRichTextAttr& attr1, const wxRichTextAttr& attr2)
7273 {
7274     return (attr1 == attr2);
7275 }
7276
7277 // Partial equality test taking flags into account
7278 bool wxTextAttrEqPartial(const wxRichTextAttr& attr1, const wxRichTextAttr& attr2)
7279 {
7280     return attr1.EqPartial(attr2);
7281 }
7282
7283 /// Compare tabs
7284 bool wxRichTextTabsEq(const wxArrayInt& tabs1, const wxArrayInt& tabs2)
7285 {
7286     if (tabs1.GetCount() != tabs2.GetCount())
7287         return false;
7288
7289     size_t i;
7290     for (i = 0; i < tabs1.GetCount(); i++)
7291     {
7292         if (tabs1[i] != tabs2[i])
7293             return false;
7294     }
7295     return true;
7296 }
7297
7298 bool wxRichTextApplyStyle(wxRichTextAttr& destStyle, const wxRichTextAttr& style, wxRichTextAttr* compareWith)
7299 {
7300     return destStyle.Apply(style, compareWith);
7301 }
7302
7303 // Remove attributes
7304 bool wxRichTextRemoveStyle(wxRichTextAttr& destStyle, const wxRichTextAttr& style)
7305 {
7306     return destStyle.RemoveStyle(style);
7307 }
7308
7309 /// Combine two bitlists, specifying the bits of interest with separate flags.
7310 bool wxRichTextCombineBitlists(int& valueA, int valueB, int& flagsA, int flagsB)
7311 {
7312     return wxRichTextAttr::CombineBitlists(valueA, valueB, flagsA, flagsB);
7313 }
7314
7315 /// Compare two bitlists
7316 bool wxRichTextBitlistsEqPartial(int valueA, int valueB, int flags)
7317 {
7318     return wxRichTextAttr::BitlistsEqPartial(valueA, valueB, flags);
7319 }
7320
7321 /// Split into paragraph and character styles
7322 bool wxRichTextSplitParaCharStyles(const wxRichTextAttr& style, wxRichTextAttr& parStyle, wxRichTextAttr& charStyle)
7323 {
7324     return wxRichTextAttr::SplitParaCharStyles(style, parStyle, charStyle);
7325 }
7326
7327 /// Convert a decimal to Roman numerals
7328 wxString wxRichTextDecimalToRoman(long n)
7329 {
7330     static wxArrayInt decimalNumbers;
7331     static wxArrayString romanNumbers;
7332
7333     // Clean up arrays
7334     if (n == -1)
7335     {
7336         decimalNumbers.Clear();
7337         romanNumbers.Clear();
7338         return wxEmptyString;
7339     }
7340
7341     if (decimalNumbers.GetCount() == 0)
7342     {
7343         #define wxRichTextAddDecRom(n, r) decimalNumbers.Add(n); romanNumbers.Add(r);
7344
7345         wxRichTextAddDecRom(1000, wxT("M"));
7346         wxRichTextAddDecRom(900, wxT("CM"));
7347         wxRichTextAddDecRom(500, wxT("D"));
7348         wxRichTextAddDecRom(400, wxT("CD"));
7349         wxRichTextAddDecRom(100, wxT("C"));
7350         wxRichTextAddDecRom(90, wxT("XC"));
7351         wxRichTextAddDecRom(50, wxT("L"));
7352         wxRichTextAddDecRom(40, wxT("XL"));
7353         wxRichTextAddDecRom(10, wxT("X"));
7354         wxRichTextAddDecRom(9, wxT("IX"));
7355         wxRichTextAddDecRom(5, wxT("V"));
7356         wxRichTextAddDecRom(4, wxT("IV"));
7357         wxRichTextAddDecRom(1, wxT("I"));
7358     }
7359
7360     int i = 0;
7361     wxString roman;
7362
7363     while (n > 0 && i < 13)
7364     {
7365         if (n >= decimalNumbers[i])
7366         {
7367             n -= decimalNumbers[i];
7368             roman += romanNumbers[i];
7369         }
7370         else
7371         {
7372             i ++;
7373         }
7374     }
7375     if (roman.IsEmpty())
7376         roman = wxT("0");
7377     return roman;
7378 }
7379
7380 /*!
7381  * wxRichTextFileHandler
7382  * Base class for file handlers
7383  */
7384
7385 IMPLEMENT_CLASS(wxRichTextFileHandler, wxObject)
7386
7387 #if wxUSE_FFILE && wxUSE_STREAMS
7388 bool wxRichTextFileHandler::LoadFile(wxRichTextBuffer *buffer, const wxString& filename)
7389 {
7390     wxFFileInputStream stream(filename);
7391     if (stream.Ok())
7392         return LoadFile(buffer, stream);
7393
7394     return false;
7395 }
7396
7397 bool wxRichTextFileHandler::SaveFile(wxRichTextBuffer *buffer, const wxString& filename)
7398 {
7399     wxFFileOutputStream stream(filename);
7400     if (stream.Ok())
7401         return SaveFile(buffer, stream);
7402
7403     return false;
7404 }
7405 #endif // wxUSE_FFILE && wxUSE_STREAMS
7406
7407 /// Can we handle this filename (if using files)? By default, checks the extension.
7408 bool wxRichTextFileHandler::CanHandle(const wxString& filename) const
7409 {
7410     wxString path, file, ext;
7411     wxFileName::SplitPath(filename, & path, & file, & ext);
7412
7413     return (ext.Lower() == GetExtension());
7414 }
7415
7416 /*!
7417  * wxRichTextTextHandler
7418  * Plain text handler
7419  */
7420
7421 IMPLEMENT_CLASS(wxRichTextPlainTextHandler, wxRichTextFileHandler)
7422
7423 #if wxUSE_STREAMS
7424 bool wxRichTextPlainTextHandler::DoLoadFile(wxRichTextBuffer *buffer, wxInputStream& stream)
7425 {
7426     if (!stream.IsOk())
7427         return false;
7428
7429     wxString str;
7430     int lastCh = 0;
7431
7432     while (!stream.Eof())
7433     {
7434         int ch = stream.GetC();
7435
7436         if (!stream.Eof())
7437         {
7438             if (ch == 10 && lastCh != 13)
7439                 str += wxT('\n');
7440
7441             if (ch > 0 && ch != 10)
7442                 str += wxChar(ch);
7443
7444             lastCh = ch;
7445         }
7446     }
7447
7448     buffer->ResetAndClearCommands();
7449     buffer->Clear();
7450     buffer->AddParagraphs(str);
7451     buffer->UpdateRanges();
7452
7453     return true;
7454 }
7455
7456 bool wxRichTextPlainTextHandler::DoSaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream)
7457 {
7458     if (!stream.IsOk())
7459         return false;
7460
7461     wxString text = buffer->GetText();
7462
7463     wxString newLine = wxRichTextLineBreakChar;
7464     text.Replace(newLine, wxT("\n"));
7465
7466     wxCharBuffer buf = text.ToAscii();
7467
7468     stream.Write((const char*) buf, text.length());
7469     return true;
7470 }
7471 #endif // wxUSE_STREAMS
7472
7473 /*
7474  * Stores information about an image, in binary in-memory form
7475  */
7476
7477 wxRichTextImageBlock::wxRichTextImageBlock()
7478 {
7479     Init();
7480 }
7481
7482 wxRichTextImageBlock::wxRichTextImageBlock(const wxRichTextImageBlock& block):wxObject()
7483 {
7484     Init();
7485     Copy(block);
7486 }
7487
7488 wxRichTextImageBlock::~wxRichTextImageBlock()
7489 {
7490     wxDELETEA(m_data);
7491 }
7492
7493 void wxRichTextImageBlock::Init()
7494 {
7495     m_data = NULL;
7496     m_dataSize = 0;
7497     m_imageType = wxBITMAP_TYPE_INVALID;
7498 }
7499
7500 void wxRichTextImageBlock::Clear()
7501 {
7502     wxDELETEA(m_data);
7503     m_dataSize = 0;
7504     m_imageType = wxBITMAP_TYPE_INVALID;
7505 }
7506
7507
7508 // Load the original image into a memory block.
7509 // If the image is not a JPEG, we must convert it into a JPEG
7510 // to conserve space.
7511 // If it's not a JPEG we can make use of 'image', already scaled, so we don't have to
7512 // load the image a 2nd time.
7513
7514 bool wxRichTextImageBlock::MakeImageBlock(const wxString& filename, wxBitmapType imageType,
7515                                           wxImage& image, bool convertToJPEG)
7516 {
7517     m_imageType = imageType;
7518
7519     wxString filenameToRead(filename);
7520     bool removeFile = false;
7521
7522     if (imageType == wxBITMAP_TYPE_INVALID)
7523         return false; // Could not determine image type
7524
7525     if ((imageType != wxBITMAP_TYPE_JPEG) && convertToJPEG)
7526     {
7527         wxString tempFile =
7528             wxFileName::CreateTempFileName(_("image"));
7529
7530         wxASSERT(!tempFile.IsEmpty());
7531
7532         image.SaveFile(tempFile, wxBITMAP_TYPE_JPEG);
7533         filenameToRead = tempFile;
7534         removeFile = true;
7535
7536         m_imageType = wxBITMAP_TYPE_JPEG;
7537     }
7538     wxFile file;
7539     if (!file.Open(filenameToRead))
7540         return false;
7541
7542     m_dataSize = (size_t) file.Length();
7543     file.Close();
7544
7545     if (m_data)
7546         delete[] m_data;
7547     m_data = ReadBlock(filenameToRead, m_dataSize);
7548
7549     if (removeFile)
7550         wxRemoveFile(filenameToRead);
7551
7552     return (m_data != NULL);
7553 }
7554
7555 // Make an image block from the wxImage in the given
7556 // format.
7557 bool wxRichTextImageBlock::MakeImageBlock(wxImage& image, wxBitmapType imageType, int quality)
7558 {
7559     image.SetOption(wxT("quality"), quality);
7560
7561     if (imageType == wxBITMAP_TYPE_INVALID)
7562         return false; // Could not determine image type
7563
7564     return DoMakeImageBlock(image, imageType);
7565 }
7566
7567 // Uses a const wxImage for efficiency, but can't set quality (only relevant for JPEG)
7568 bool wxRichTextImageBlock::MakeImageBlockDefaultQuality(const wxImage& image, wxBitmapType imageType)
7569 {
7570     if (imageType == wxBITMAP_TYPE_INVALID)
7571         return false; // Could not determine image type
7572
7573     return DoMakeImageBlock(image, imageType);
7574 }
7575
7576 // Makes the image block
7577 bool wxRichTextImageBlock::DoMakeImageBlock(const wxImage& image, wxBitmapType imageType)
7578 {
7579     wxMemoryOutputStream memStream;
7580     if (!image.SaveFile(memStream, imageType))
7581     {
7582         return false;
7583     }
7584
7585     unsigned char* block = new unsigned char[memStream.GetSize()];
7586     if (!block)
7587         return NULL;
7588
7589     if (m_data)
7590         delete[] m_data;
7591     m_data = block;
7592
7593     m_imageType = imageType;
7594     m_dataSize = memStream.GetSize();
7595
7596     memStream.CopyTo(m_data, m_dataSize);
7597
7598     return (m_data != NULL);
7599 }
7600
7601 // Write to a file
7602 bool wxRichTextImageBlock::Write(const wxString& filename)
7603 {
7604     return WriteBlock(filename, m_data, m_dataSize);
7605 }
7606
7607 void wxRichTextImageBlock::Copy(const wxRichTextImageBlock& block)
7608 {
7609     m_imageType = block.m_imageType;
7610     wxDELETEA(m_data);
7611     m_dataSize = block.m_dataSize;
7612     if (m_dataSize == 0)
7613         return;
7614
7615     m_data = new unsigned char[m_dataSize];
7616     unsigned int i;
7617     for (i = 0; i < m_dataSize; i++)
7618         m_data[i] = block.m_data[i];
7619 }
7620
7621 //// Operators
7622 void wxRichTextImageBlock::operator=(const wxRichTextImageBlock& block)
7623 {
7624     Copy(block);
7625 }
7626
7627 // Load a wxImage from the block
7628 bool wxRichTextImageBlock::Load(wxImage& image)
7629 {
7630     if (!m_data)
7631         return false;
7632
7633     // Read in the image.
7634 #if wxUSE_STREAMS
7635     wxMemoryInputStream mstream(m_data, m_dataSize);
7636     bool success = image.LoadFile(mstream, GetImageType());
7637 #else
7638     wxString tempFile = wxFileName::CreateTempFileName(_("image"));
7639     wxASSERT(!tempFile.IsEmpty());
7640
7641     if (!WriteBlock(tempFile, m_data, m_dataSize))
7642     {
7643         return false;
7644     }
7645     success = image.LoadFile(tempFile, GetImageType());
7646     wxRemoveFile(tempFile);
7647 #endif
7648
7649     return success;
7650 }
7651
7652 // Write data in hex to a stream
7653 bool wxRichTextImageBlock::WriteHex(wxOutputStream& stream)
7654 {
7655     const int bufSize = 512;
7656     char buf[bufSize+1];
7657
7658     int left = m_dataSize;
7659     int n, i, j;
7660     j = 0;
7661     while (left > 0)
7662     {
7663         if (left*2 > bufSize)
7664         {
7665             n = bufSize; left -= (bufSize/2);
7666         }
7667         else
7668         {
7669             n = left*2; left = 0;
7670         }
7671
7672         char* b = buf;
7673         for (i = 0; i < (n/2); i++)
7674         {
7675             wxDecToHex(m_data[j], b, b+1);
7676             b += 2; j ++;
7677         }
7678
7679         buf[n] = 0;
7680         stream.Write((const char*) buf, n);
7681     }
7682     return true;
7683 }
7684
7685 // Read data in hex from a stream
7686 bool wxRichTextImageBlock::ReadHex(wxInputStream& stream, int length, wxBitmapType imageType)
7687 {
7688     int dataSize = length/2;
7689
7690     if (m_data)
7691         delete[] m_data;
7692
7693     // create a null terminated temporary string:
7694     char str[3];
7695     str[2] = '\0';
7696
7697     m_data = new unsigned char[dataSize];
7698     int i;
7699     for (i = 0; i < dataSize; i ++)
7700     {
7701         str[0] = (char)stream.GetC();
7702         str[1] = (char)stream.GetC();
7703
7704         m_data[i] = (unsigned char)wxHexToDec(str);
7705     }
7706
7707     m_dataSize = dataSize;
7708     m_imageType = imageType;
7709
7710     return true;
7711 }
7712
7713 // Allocate and read from stream as a block of memory
7714 unsigned char* wxRichTextImageBlock::ReadBlock(wxInputStream& stream, size_t size)
7715 {
7716     unsigned char* block = new unsigned char[size];
7717     if (!block)
7718         return NULL;
7719
7720     stream.Read(block, size);
7721
7722     return block;
7723 }
7724
7725 unsigned char* wxRichTextImageBlock::ReadBlock(const wxString& filename, size_t size)
7726 {
7727     wxFileInputStream stream(filename);
7728     if (!stream.Ok())
7729         return NULL;
7730
7731     return ReadBlock(stream, size);
7732 }
7733
7734 // Write memory block to stream
7735 bool wxRichTextImageBlock::WriteBlock(wxOutputStream& stream, unsigned char* block, size_t size)
7736 {
7737     stream.Write((void*) block, size);
7738     return stream.IsOk();
7739
7740 }
7741
7742 // Write memory block to file
7743 bool wxRichTextImageBlock::WriteBlock(const wxString& filename, unsigned char* block, size_t size)
7744 {
7745     wxFileOutputStream outStream(filename);
7746     if (!outStream.Ok())
7747         return false;
7748
7749     return WriteBlock(outStream, block, size);
7750 }
7751
7752 // Gets the extension for the block's type
7753 wxString wxRichTextImageBlock::GetExtension() const
7754 {
7755     wxImageHandler* handler = wxImage::FindHandler(GetImageType());
7756     if (handler)
7757         return handler->GetExtension();
7758     else
7759         return wxEmptyString;
7760 }
7761
7762 #if wxUSE_DATAOBJ
7763
7764 /*!
7765  * The data object for a wxRichTextBuffer
7766  */
7767
7768 const wxChar *wxRichTextBufferDataObject::ms_richTextBufferFormatId = wxT("wxShape");
7769
7770 wxRichTextBufferDataObject::wxRichTextBufferDataObject(wxRichTextBuffer* richTextBuffer)
7771 {
7772     m_richTextBuffer = richTextBuffer;
7773
7774     // this string should uniquely identify our format, but is otherwise
7775     // arbitrary
7776     m_formatRichTextBuffer.SetId(GetRichTextBufferFormatId());
7777
7778     SetFormat(m_formatRichTextBuffer);
7779 }
7780
7781 wxRichTextBufferDataObject::~wxRichTextBufferDataObject()
7782 {
7783     delete m_richTextBuffer;
7784 }
7785
7786 // after a call to this function, the richTextBuffer is owned by the caller and it
7787 // is responsible for deleting it!
7788 wxRichTextBuffer* wxRichTextBufferDataObject::GetRichTextBuffer()
7789 {
7790     wxRichTextBuffer* richTextBuffer = m_richTextBuffer;
7791     m_richTextBuffer = NULL;
7792
7793     return richTextBuffer;
7794 }
7795
7796 wxDataFormat wxRichTextBufferDataObject::GetPreferredFormat(Direction WXUNUSED(dir)) const
7797 {
7798     return m_formatRichTextBuffer;
7799 }
7800
7801 size_t wxRichTextBufferDataObject::GetDataSize() const
7802 {
7803     if (!m_richTextBuffer)
7804         return 0;
7805
7806     wxString bufXML;
7807
7808     {
7809         wxStringOutputStream stream(& bufXML);
7810         if (!m_richTextBuffer->SaveFile(stream, wxRICHTEXT_TYPE_XML))
7811         {
7812             wxLogError(wxT("Could not write the buffer to an XML stream.\nYou may have forgotten to add the XML file handler."));
7813             return 0;
7814         }
7815     }
7816
7817 #if wxUSE_UNICODE
7818     wxCharBuffer buffer = bufXML.mb_str(wxConvUTF8);
7819     return strlen(buffer) + 1;
7820 #else
7821     return bufXML.Length()+1;
7822 #endif
7823 }
7824
7825 bool wxRichTextBufferDataObject::GetDataHere(void *pBuf) const
7826 {
7827     if (!pBuf || !m_richTextBuffer)
7828         return false;
7829
7830     wxString bufXML;
7831
7832     {
7833         wxStringOutputStream stream(& bufXML);
7834         if (!m_richTextBuffer->SaveFile(stream, wxRICHTEXT_TYPE_XML))
7835         {
7836             wxLogError(wxT("Could not write the buffer to an XML stream.\nYou may have forgotten to add the XML file handler."));
7837             return 0;
7838         }
7839     }
7840
7841 #if wxUSE_UNICODE
7842     wxCharBuffer buffer = bufXML.mb_str(wxConvUTF8);
7843     size_t len = strlen(buffer);
7844     memcpy((char*) pBuf, (const char*) buffer, len);
7845     ((char*) pBuf)[len] = 0;
7846 #else
7847     size_t len = bufXML.Length();
7848     memcpy((char*) pBuf, (const char*) bufXML.c_str(), len);
7849     ((char*) pBuf)[len] = 0;
7850 #endif
7851
7852     return true;
7853 }
7854
7855 bool wxRichTextBufferDataObject::SetData(size_t WXUNUSED(len), const void *buf)
7856 {
7857     wxDELETE(m_richTextBuffer);
7858
7859     wxString bufXML((const char*) buf, wxConvUTF8);
7860
7861     m_richTextBuffer = new wxRichTextBuffer;
7862
7863     wxStringInputStream stream(bufXML);
7864     if (!m_richTextBuffer->LoadFile(stream, wxRICHTEXT_TYPE_XML))
7865     {
7866         wxLogError(wxT("Could not read the buffer from an XML stream.\nYou may have forgotten to add the XML file handler."));
7867
7868         wxDELETE(m_richTextBuffer);
7869
7870         return false;
7871     }
7872     return true;
7873 }
7874
7875 #endif
7876     // wxUSE_DATAOBJ
7877
7878
7879 /*
7880  * wxRichTextFontTable
7881  * Manages quick access to a pool of fonts for rendering rich text
7882  */
7883
7884 WX_DECLARE_STRING_HASH_MAP_WITH_DECL(wxFont, wxRichTextFontTableHashMap, class WXDLLIMPEXP_RICHTEXT);
7885
7886 class wxRichTextFontTableData: public wxObjectRefData
7887 {
7888 public:
7889     wxRichTextFontTableData() {}
7890
7891     wxFont FindFont(const wxRichTextAttr& fontSpec);
7892
7893     wxRichTextFontTableHashMap  m_hashMap;
7894 };
7895
7896 wxFont wxRichTextFontTableData::FindFont(const wxRichTextAttr& fontSpec)
7897 {
7898     wxString facename(fontSpec.GetFontFaceName());
7899     wxString spec(wxString::Format(wxT("%d-%d-%d-%d-%s-%d"), fontSpec.GetFontSize(), fontSpec.GetFontStyle(), fontSpec.GetFontWeight(), (int) fontSpec.GetFontUnderlined(), facename.c_str(), (int) fontSpec.GetFontEncoding()));
7900     wxRichTextFontTableHashMap::iterator entry = m_hashMap.find(spec);
7901
7902     if ( entry == m_hashMap.end() )
7903     {
7904         wxFont font(fontSpec.GetFontSize(), wxDEFAULT, fontSpec.GetFontStyle(), fontSpec.GetFontWeight(), fontSpec.GetFontUnderlined(), facename.c_str());
7905         m_hashMap[spec] = font;
7906         return font;
7907     }
7908     else
7909     {
7910         return entry->second;
7911     }
7912 }
7913
7914 IMPLEMENT_DYNAMIC_CLASS(wxRichTextFontTable, wxObject)
7915
7916 wxRichTextFontTable::wxRichTextFontTable()
7917 {
7918     m_refData = new wxRichTextFontTableData;
7919 }
7920
7921 wxRichTextFontTable::wxRichTextFontTable(const wxRichTextFontTable& table)
7922     : wxObject()
7923 {
7924     (*this) = table;
7925 }
7926
7927 wxRichTextFontTable::~wxRichTextFontTable()
7928 {
7929     UnRef();
7930 }
7931
7932 bool wxRichTextFontTable::operator == (const wxRichTextFontTable& table) const
7933 {
7934     return (m_refData == table.m_refData);
7935 }
7936
7937 void wxRichTextFontTable::operator= (const wxRichTextFontTable& table)
7938 {
7939     Ref(table);
7940 }
7941
7942 wxFont wxRichTextFontTable::FindFont(const wxRichTextAttr& fontSpec)
7943 {
7944     wxRichTextFontTableData* data = (wxRichTextFontTableData*) m_refData;
7945     if (data)
7946         return data->FindFont(fontSpec);
7947     else
7948         return wxFont();
7949 }
7950
7951 void wxRichTextFontTable::Clear()
7952 {
7953     wxRichTextFontTableData* data = (wxRichTextFontTableData*) m_refData;
7954     if (data)
7955         data->m_hashMap.clear();
7956 }
7957
7958 // wxTextBoxAttr
7959
7960
7961 void wxTextBoxAttr::Reset()
7962 {
7963     m_flags = 0;
7964     m_floatMode = 0;
7965     m_clearMode = 0;
7966     m_collapseMode = 0;
7967
7968     m_margins.Reset();
7969     m_padding.Reset();
7970     m_position.Reset();
7971
7972     m_width.Reset();
7973     m_height.Reset();
7974
7975     m_border.Reset();
7976     m_outline.Reset();
7977 }
7978
7979 // Equality test
7980 bool wxTextBoxAttr::operator== (const wxTextBoxAttr& attr) const
7981 {
7982     return (
7983         m_flags == attr.m_flags &&
7984         m_floatMode == attr.m_floatMode &&
7985         m_clearMode == attr.m_clearMode &&
7986         m_collapseMode == attr.m_collapseMode &&
7987
7988         m_margins == attr.m_margins &&
7989         m_padding == attr.m_padding &&
7990         m_position == attr.m_position &&
7991
7992         m_width == attr.m_width &&
7993         m_height == attr.m_height &&
7994
7995         m_border == attr.m_border &&
7996         m_outline == attr.m_outline
7997         );
7998 }
7999
8000 // Partial equality test
8001 bool wxTextBoxAttr::EqPartial(const wxTextBoxAttr& attr) const
8002 {
8003     if (attr.HasFloatMode() && HasFloatMode() && (GetFloatMode() != attr.GetFloatMode()))
8004         return false;
8005
8006     if (attr.HasClearMode() && HasClearMode() && (GetClearMode() != attr.GetClearMode()))
8007         return false;
8008
8009     if (attr.HasCollapseBorders() && HasCollapseBorders() && (attr.GetCollapseBorders() != GetCollapseBorders()))
8010         return false;
8011
8012     // Position
8013
8014     if (!m_position.EqPartial(attr.m_position))
8015         return false;
8016
8017     // Margins
8018
8019     if (!m_margins.EqPartial(attr.m_margins))
8020         return false;
8021
8022     // Padding
8023
8024     if (!m_padding.EqPartial(attr.m_padding))
8025         return false;
8026
8027     // Border
8028
8029     if (!GetBorder().EqPartial(attr.GetBorder()))
8030         return false;
8031
8032     // Outline
8033
8034     if (!GetOutline().EqPartial(attr.GetOutline()))
8035         return false;
8036
8037     return true;
8038 }
8039
8040 // Merges the given attributes. If compareWith
8041 // is non-NULL, then it will be used to mask out those attributes that are the same in style
8042 // and compareWith, for situations where we don't want to explicitly set inherited attributes.
8043 bool wxTextBoxAttr::Apply(const wxTextBoxAttr& attr, const wxTextBoxAttr* compareWith)
8044 {
8045     if (attr.HasFloatMode())
8046     {
8047         if (!(compareWith && compareWith->HasFloatMode() && compareWith->GetFloatMode() == attr.GetFloatMode()))
8048             SetFloatMode(attr.GetFloatMode());
8049     }
8050
8051     if (attr.HasClearMode())
8052     {
8053         if (!(compareWith && compareWith->HasClearMode() && compareWith->GetClearMode() == attr.GetClearMode()))
8054             SetClearMode(attr.GetClearMode());
8055     }
8056
8057     if (attr.HasCollapseBorders())
8058     {
8059         if (!(compareWith && compareWith->HasCollapseBorders() && compareWith->GetCollapseBorders() == attr.GetCollapseBorders()))
8060             SetCollapseBorders(true);
8061     }
8062
8063     m_margins.Apply(attr.m_margins, compareWith ? (& attr.m_margins) : (const wxTextBoxAttrDimensions*) NULL);
8064     m_padding.Apply(attr.m_padding, compareWith ? (& attr.m_padding) : (const wxTextBoxAttrDimensions*) NULL);
8065     m_position.Apply(attr.m_position, compareWith ? (& attr.m_position) : (const wxTextBoxAttrDimensions*) NULL);
8066
8067     m_width.Apply(attr.m_width, compareWith ? (& attr.m_width) : (const wxTextAttrDimension*) NULL);
8068     m_height.Apply(attr.m_height, compareWith ? (& attr.m_height) : (const wxTextAttrDimension*) NULL);
8069
8070     m_border.Apply(attr.m_border, compareWith ? (& attr.m_border) : (const wxTextBoxAttrBorders*) NULL);
8071     m_outline.Apply(attr.m_outline, compareWith ? (& attr.m_outline) : (const wxTextBoxAttrBorders*) NULL);
8072
8073     return true;
8074 }
8075
8076 // Remove specified attributes from this object
8077 bool wxTextBoxAttr::RemoveStyle(const wxTextBoxAttr& attr)
8078 {
8079     if (attr.HasFloatMode())
8080         RemoveFlag(wxTEXT_BOX_ATTR_FLOAT);
8081
8082     if (attr.HasClearMode())
8083         RemoveFlag(wxTEXT_BOX_ATTR_CLEAR);
8084
8085     if (attr.HasCollapseBorders())
8086         RemoveFlag(wxTEXT_BOX_ATTR_COLLAPSE_BORDERS);
8087
8088     m_margins.RemoveStyle(attr.m_margins);
8089     m_padding.RemoveStyle(attr.m_padding);
8090     m_position.RemoveStyle(attr.m_position);
8091
8092     if (attr.m_width.IsPresent())
8093         m_width.Reset();
8094     if (attr.m_height.IsPresent())
8095         m_height.Reset();
8096
8097     m_border.RemoveStyle(attr.m_border);
8098     m_outline.RemoveStyle(attr.m_outline);
8099
8100     return true;
8101 }
8102
8103 // Collects the attributes that are common to a range of content, building up a note of
8104 // which attributes are absent in some objects and which clash in some objects.
8105 void wxTextBoxAttr::CollectCommonAttributes(const wxTextBoxAttr& attr, wxTextBoxAttr& clashingAttr, wxTextBoxAttr& absentAttr)
8106 {
8107     if (attr.HasFloatMode())
8108     {
8109         if (!clashingAttr.HasFloatMode() && !absentAttr.HasFloatMode())
8110         {
8111             if (HasFloatMode())
8112             {
8113                 if (GetFloatMode() != attr.GetFloatMode())
8114                 {
8115                     clashingAttr.AddFlag(wxTEXT_BOX_ATTR_FLOAT);
8116                     RemoveFlag(wxTEXT_BOX_ATTR_FLOAT);
8117                 }
8118             }
8119             else
8120                 SetFloatMode(attr.GetFloatMode());
8121         }
8122     }
8123     else
8124         absentAttr.AddFlag(wxTEXT_BOX_ATTR_FLOAT);
8125
8126     if (attr.HasClearMode())
8127     {
8128         if (!clashingAttr.HasClearMode() && !absentAttr.HasClearMode())
8129         {
8130             if (HasClearMode())
8131             {
8132                 if (GetClearMode() != attr.GetClearMode())
8133                 {
8134                     clashingAttr.AddFlag(wxTEXT_BOX_ATTR_CLEAR);
8135                     RemoveFlag(wxTEXT_BOX_ATTR_CLEAR);
8136                 }
8137             }
8138             else
8139                 SetClearMode(attr.GetClearMode());
8140         }
8141     }
8142     else
8143         absentAttr.AddFlag(wxTEXT_BOX_ATTR_CLEAR);
8144
8145     if (attr.HasCollapseBorders())
8146     {
8147         if (!clashingAttr.HasCollapseBorders() && !absentAttr.HasCollapseBorders())
8148         {
8149             if (HasCollapseBorders())
8150             {
8151                 if (GetCollapseBorders() != attr.GetCollapseBorders())
8152                 {
8153                     clashingAttr.AddFlag(wxTEXT_BOX_ATTR_COLLAPSE_BORDERS);
8154                     RemoveFlag(wxTEXT_BOX_ATTR_COLLAPSE_BORDERS);
8155                 }
8156             }
8157             else
8158                 SetCollapseBorders(attr.GetCollapseBorders());
8159         }
8160     }
8161     else
8162         absentAttr.AddFlag(wxTEXT_BOX_ATTR_COLLAPSE_BORDERS);
8163
8164     m_margins.CollectCommonAttributes(attr.m_margins, clashingAttr.m_margins, absentAttr.m_margins);
8165     m_padding.CollectCommonAttributes(attr.m_padding, clashingAttr.m_padding, absentAttr.m_padding);
8166     m_position.CollectCommonAttributes(attr.m_position, clashingAttr.m_position, absentAttr.m_position);
8167
8168     m_width.CollectCommonAttributes(attr.m_width, clashingAttr.m_width, absentAttr.m_width);
8169     m_height.CollectCommonAttributes(attr.m_height, clashingAttr.m_height, absentAttr.m_height);
8170
8171     m_border.CollectCommonAttributes(attr.m_border, clashingAttr.m_border, absentAttr.m_border);
8172     m_outline.CollectCommonAttributes(attr.m_outline, clashingAttr.m_outline, absentAttr.m_outline);
8173 }
8174
8175 // wxRichTextAttr
8176
8177 void wxRichTextAttr::Copy(const wxRichTextAttr& attr)
8178 {
8179     wxTextAttr::Copy(attr);
8180
8181     m_textBoxAttr = attr.m_textBoxAttr;
8182 }
8183
8184 bool wxRichTextAttr::operator==(const wxRichTextAttr& attr) const
8185 {
8186     if (!(wxTextAttr::operator==(attr)))
8187         return false;
8188
8189     return (m_textBoxAttr == attr.m_textBoxAttr);
8190 }
8191
8192 // Partial equality test taking comparison object into account
8193 bool wxRichTextAttr::EqPartial(const wxRichTextAttr& attr) const
8194 {
8195     if (!(wxTextAttr::EqPartial(attr)))
8196         return false;
8197
8198     return m_textBoxAttr.EqPartial(attr.m_textBoxAttr);
8199 }
8200
8201 // Merges the given attributes. If compareWith
8202 // is non-NULL, then it will be used to mask out those attributes that are the same in style
8203 // and compareWith, for situations where we don't want to explicitly set inherited attributes.
8204 bool wxRichTextAttr::Apply(const wxRichTextAttr& style, const wxRichTextAttr* compareWith)
8205 {
8206     wxTextAttr::Apply(style, compareWith);
8207
8208     return m_textBoxAttr.Apply(style.m_textBoxAttr, compareWith ? (& compareWith->m_textBoxAttr) : (const wxTextBoxAttr*) NULL);
8209 }
8210
8211 // Remove specified attributes from this object
8212 bool wxRichTextAttr::RemoveStyle(const wxRichTextAttr& attr)
8213 {
8214     wxTextAttr::RemoveStyle(*this, attr);
8215
8216     return m_textBoxAttr.RemoveStyle(attr.m_textBoxAttr);
8217 }
8218
8219 // Collects the attributes that are common to a range of content, building up a note of
8220 // which attributes are absent in some objects and which clash in some objects.
8221 void wxRichTextAttr::CollectCommonAttributes(const wxRichTextAttr& attr, wxRichTextAttr& clashingAttr, wxRichTextAttr& absentAttr)
8222 {
8223     wxTextAttrCollectCommonAttributes(*this, attr, clashingAttr, absentAttr);
8224
8225     m_textBoxAttr.CollectCommonAttributes(attr.m_textBoxAttr, clashingAttr.m_textBoxAttr, absentAttr.m_textBoxAttr);
8226 }
8227
8228 // Partial equality test
8229 bool wxTextBoxAttrBorder::EqPartial(const wxTextBoxAttrBorder& border) const
8230 {
8231     if (border.HasStyle() && !HasStyle() && (border.GetStyle() != GetStyle()))
8232         return false;
8233
8234     if (border.HasColour() && !HasColour() && (border.GetColourLong() != GetColourLong()))
8235         return false;
8236
8237     if (border.HasWidth() && !HasWidth() && !(border.GetWidth() == GetWidth()))
8238         return false;
8239
8240     return true;
8241 }
8242
8243 // Apply border to 'this', but not if the same as compareWith
8244 bool wxTextBoxAttrBorder::Apply(const wxTextBoxAttrBorder& border, const wxTextBoxAttrBorder* compareWith)
8245 {
8246     if (border.HasStyle())
8247     {
8248         if (!(compareWith && (border.GetStyle() == compareWith->GetStyle())))
8249             SetStyle(border.GetStyle());
8250     }
8251     if (border.HasColour())
8252     {
8253         if (!(compareWith && (border.GetColourLong() == compareWith->GetColourLong())))
8254             SetColour(border.GetColourLong());
8255     }
8256     if (border.HasWidth())
8257     {
8258         if (!(compareWith && (border.GetWidth() == compareWith->GetWidth())))
8259             SetWidth(border.GetWidth());
8260     }
8261
8262     return true;
8263 }
8264
8265 // Remove specified attributes from this object
8266 bool wxTextBoxAttrBorder::RemoveStyle(const wxTextBoxAttrBorder& attr)
8267 {
8268     if (attr.HasStyle() && HasStyle())
8269         SetFlags(GetFlags() & ~wxTEXT_BOX_ATTR_BORDER_STYLE);
8270     if (attr.HasColour() && HasColour())
8271         SetFlags(GetFlags() & ~wxTEXT_BOX_ATTR_BORDER_COLOUR);
8272     if (attr.HasWidth() && HasWidth())
8273         m_borderWidth.Reset();
8274
8275     return true;
8276 }
8277
8278 // Collects the attributes that are common to a range of content, building up a note of
8279 // which attributes are absent in some objects and which clash in some objects.
8280 void wxTextBoxAttrBorder::CollectCommonAttributes(const wxTextBoxAttrBorder& attr, wxTextBoxAttrBorder& clashingAttr, wxTextBoxAttrBorder& absentAttr)
8281 {
8282     if (attr.HasStyle())
8283     {
8284         if (!clashingAttr.HasStyle() && !absentAttr.HasStyle())
8285         {
8286             if (HasStyle())
8287             {
8288                 if (GetStyle() != attr.GetStyle())
8289                 {
8290                     clashingAttr.AddFlag(wxTEXT_BOX_ATTR_BORDER_STYLE);
8291                     RemoveFlag(wxTEXT_BOX_ATTR_BORDER_STYLE);
8292                 }
8293             }
8294             else
8295                 SetStyle(attr.GetStyle());
8296         }
8297     }
8298     else
8299         absentAttr.AddFlag(wxTEXT_BOX_ATTR_BORDER_STYLE);
8300
8301     if (attr.HasColour())
8302     {
8303         if (!clashingAttr.HasColour() && !absentAttr.HasColour())
8304         {
8305             if (HasColour())
8306             {
8307                 if (GetColour() != attr.GetColour())
8308                 {
8309                     clashingAttr.AddFlag(wxTEXT_BOX_ATTR_BORDER_COLOUR);
8310                     RemoveFlag(wxTEXT_BOX_ATTR_BORDER_COLOUR);
8311                 }
8312             }
8313             else
8314                 SetColour(attr.GetColourLong());
8315         }
8316     }
8317     else
8318         absentAttr.AddFlag(wxTEXT_BOX_ATTR_BORDER_COLOUR);
8319
8320     m_borderWidth.CollectCommonAttributes(attr.m_borderWidth, clashingAttr.m_borderWidth, absentAttr.m_borderWidth);
8321 }
8322
8323 // Partial equality test
8324 bool wxTextBoxAttrBorders::EqPartial(const wxTextBoxAttrBorders& borders) const
8325 {
8326     return m_left.EqPartial(borders.m_left) && m_right.EqPartial(borders.m_right) &&
8327             m_top.EqPartial(borders.m_top) && m_bottom.EqPartial(borders.m_bottom);
8328 }
8329
8330 // Apply border to 'this', but not if the same as compareWith
8331 bool wxTextBoxAttrBorders::Apply(const wxTextBoxAttrBorders& borders, const wxTextBoxAttrBorders* compareWith)
8332 {
8333     m_left.Apply(borders.m_left, compareWith ? (& compareWith->m_left) : (const wxTextBoxAttrBorder*) NULL);
8334     m_right.Apply(borders.m_right, compareWith ? (& compareWith->m_right) : (const wxTextBoxAttrBorder*) NULL);
8335     m_top.Apply(borders.m_top, compareWith ? (& compareWith->m_top) : (const wxTextBoxAttrBorder*) NULL);
8336     m_bottom.Apply(borders.m_bottom, compareWith ? (& compareWith->m_bottom) : (const wxTextBoxAttrBorder*) NULL);
8337     return true;
8338 }
8339
8340 // Remove specified attributes from this object
8341 bool wxTextBoxAttrBorders::RemoveStyle(const wxTextBoxAttrBorders& attr)
8342 {
8343     m_left.RemoveStyle(attr.m_left);
8344     m_right.RemoveStyle(attr.m_right);
8345     m_top.RemoveStyle(attr.m_top);
8346     m_bottom.RemoveStyle(attr.m_bottom);
8347     return true;
8348 }
8349
8350 // Collects the attributes that are common to a range of content, building up a note of
8351 // which attributes are absent in some objects and which clash in some objects.
8352 void wxTextBoxAttrBorders::CollectCommonAttributes(const wxTextBoxAttrBorders& attr, wxTextBoxAttrBorders& clashingAttr, wxTextBoxAttrBorders& absentAttr)
8353 {
8354     m_left.CollectCommonAttributes(attr.m_left, clashingAttr.m_left, absentAttr.m_left);
8355     m_right.CollectCommonAttributes(attr.m_right, clashingAttr.m_right, absentAttr.m_right);
8356     m_top.CollectCommonAttributes(attr.m_top, clashingAttr.m_top, absentAttr.m_top);
8357     m_bottom.CollectCommonAttributes(attr.m_bottom, clashingAttr.m_bottom, absentAttr.m_bottom);
8358 }
8359
8360 // Set style of all borders
8361 void wxTextBoxAttrBorders::SetStyle(int style)
8362 {
8363     m_left.SetStyle(style);
8364     m_right.SetStyle(style);
8365     m_top.SetStyle(style);
8366     m_bottom.SetStyle(style);
8367 }
8368
8369 // Set colour of all borders
8370 void wxTextBoxAttrBorders::SetColour(unsigned long colour)
8371 {
8372     m_left.SetColour(colour);
8373     m_right.SetColour(colour);
8374     m_top.SetColour(colour);
8375     m_bottom.SetColour(colour);
8376 }
8377
8378 void wxTextBoxAttrBorders::SetColour(const wxColour& colour)
8379 {
8380     m_left.SetColour(colour);
8381     m_right.SetColour(colour);
8382     m_top.SetColour(colour);
8383     m_bottom.SetColour(colour);
8384 }
8385
8386 // Set width of all borders
8387 void wxTextBoxAttrBorders::SetWidth(const wxTextAttrDimension& width)
8388 {
8389     m_left.SetWidth(width);
8390     m_right.SetWidth(width);
8391     m_top.SetWidth(width);
8392     m_bottom.SetWidth(width);
8393 }
8394
8395 // Partial equality test
8396 bool wxTextAttrDimension::EqPartial(const wxTextAttrDimension& dim) const
8397 {
8398     if (dim.IsPresent() && IsPresent() && !((*this) == dim))
8399         return false;
8400     else
8401         return true;
8402 }
8403
8404 bool wxTextAttrDimension::Apply(const wxTextAttrDimension& dim, const wxTextAttrDimension* compareWith)
8405 {
8406     if (dim.IsPresent())
8407     {
8408         if (!(compareWith && dim == (*compareWith)))
8409             (*this) = dim;
8410     }
8411
8412     return true;
8413 }
8414
8415 // Collects the attributes that are common to a range of content, building up a note of
8416 // which attributes are absent in some objects and which clash in some objects.
8417 void wxTextAttrDimension::CollectCommonAttributes(const wxTextAttrDimension& attr, wxTextAttrDimension& clashingAttr, wxTextAttrDimension& absentAttr)
8418 {
8419     if (attr.IsPresent())
8420     {
8421         if (!clashingAttr.IsPresent() && !absentAttr.IsPresent())
8422         {
8423             if (IsPresent())
8424             {
8425                 if (!((*this) == attr))
8426                 {
8427                     clashingAttr.SetPresent(true);
8428                     SetPresent(false);
8429                 }
8430             }
8431             else
8432                 (*this) = attr;
8433         }
8434     }
8435     else
8436         absentAttr.SetPresent(true);
8437 }
8438
8439 // Partial equality test
8440 bool wxTextBoxAttrDimensions::EqPartial(const wxTextBoxAttrDimensions& dims) const
8441 {
8442     if (!m_left.EqPartial(dims.m_left))
8443         return false;
8444
8445     if (!m_right.EqPartial(dims.m_right))
8446         return false;
8447
8448     if (!m_top.EqPartial(dims.m_top))
8449         return false;
8450
8451     if (!m_bottom.EqPartial(dims.m_bottom))
8452         return false;
8453
8454     return true;
8455 }
8456
8457 // Apply border to 'this', but not if the same as compareWith
8458 bool wxTextBoxAttrDimensions::Apply(const wxTextBoxAttrDimensions& dims, const wxTextBoxAttrDimensions* compareWith)
8459 {
8460     m_left.Apply(dims.m_left, compareWith ? (& compareWith->m_left) : (const wxTextAttrDimension*) NULL);
8461     m_right.Apply(dims.m_right, compareWith ? (& compareWith->m_right): (const wxTextAttrDimension*) NULL);
8462     m_top.Apply(dims.m_top, compareWith ? (& compareWith->m_top): (const wxTextAttrDimension*) NULL);
8463     m_bottom.Apply(dims.m_bottom, compareWith ? (& compareWith->m_bottom): (const wxTextAttrDimension*) NULL);
8464
8465     return true;
8466 }
8467
8468 // Remove specified attributes from this object
8469 bool wxTextBoxAttrDimensions::RemoveStyle(const wxTextBoxAttrDimensions& attr)
8470 {
8471     if (attr.m_left.IsPresent())
8472         m_left.Reset();
8473     if (attr.m_right.IsPresent())
8474         m_right.Reset();
8475     if (attr.m_top.IsPresent())
8476         m_top.Reset();
8477     if (attr.m_bottom.IsPresent())
8478         m_bottom.Reset();
8479
8480     return true;
8481 }
8482
8483 // Collects the attributes that are common to a range of content, building up a note of
8484 // which attributes are absent in some objects and which clash in some objects.
8485 void wxTextBoxAttrDimensions::CollectCommonAttributes(const wxTextBoxAttrDimensions& attr, wxTextBoxAttrDimensions& clashingAttr, wxTextBoxAttrDimensions& absentAttr)
8486 {
8487     m_left.CollectCommonAttributes(attr.m_left, clashingAttr.m_left, absentAttr.m_left);
8488     m_right.CollectCommonAttributes(attr.m_right, clashingAttr.m_right, absentAttr.m_right);
8489     m_top.CollectCommonAttributes(attr.m_top, clashingAttr.m_top, absentAttr.m_top);
8490     m_bottom.CollectCommonAttributes(attr.m_bottom, clashingAttr.m_bottom, absentAttr.m_bottom);
8491 }
8492
8493 // Collects the attributes that are common to a range of content, building up a note of
8494 // which attributes are absent in some objects and which clash in some objects.
8495 void wxTextAttrCollectCommonAttributes(wxTextAttr& currentStyle, const wxTextAttr& attr, wxTextAttr& clashingAttr, wxTextAttr& absentAttr)
8496 {
8497     absentAttr.SetFlags(absentAttr.GetFlags() | (~attr.GetFlags() & wxTEXT_ATTR_ALL));
8498     absentAttr.SetTextEffectFlags(absentAttr.GetTextEffectFlags() | (~attr.GetTextEffectFlags() & 0xFFFF));
8499
8500     long forbiddenFlags = clashingAttr.GetFlags()|absentAttr.GetFlags();
8501
8502     if (attr.HasFont())
8503     {
8504         if (attr.HasFontSize() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_SIZE))
8505         {
8506             if (currentStyle.HasFontSize())
8507             {
8508                 if (currentStyle.GetFontSize() != attr.GetFontSize())
8509                 {
8510                     // Clash of attr - mark as such
8511                     clashingAttr.AddFlag(wxTEXT_ATTR_FONT_SIZE);
8512                     currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_SIZE);
8513                 }
8514             }
8515             else
8516                 currentStyle.SetFontSize(attr.GetFontSize());
8517         }
8518
8519         if (attr.HasFontItalic() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_ITALIC))
8520         {
8521             if (currentStyle.HasFontItalic())
8522             {
8523                 if (currentStyle.GetFontStyle() != attr.GetFontStyle())
8524                 {
8525                     // Clash of attr - mark as such
8526                     clashingAttr.AddFlag(wxTEXT_ATTR_FONT_ITALIC);
8527                     currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_ITALIC);
8528                 }
8529             }
8530             else
8531                 currentStyle.SetFontStyle(attr.GetFontStyle());
8532         }
8533
8534         if (attr.HasFontFamily() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_FAMILY))
8535         {
8536             if (currentStyle.HasFontFamily())
8537             {
8538                 if (currentStyle.GetFontFamily() != attr.GetFontFamily())
8539                 {
8540                     // Clash of attr - mark as such
8541                     clashingAttr.AddFlag(wxTEXT_ATTR_FONT_FAMILY);
8542                     currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_FAMILY);
8543                 }
8544             }
8545             else
8546                 currentStyle.SetFontFamily(attr.GetFontFamily());
8547         }
8548
8549         if (attr.HasFontWeight() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_WEIGHT))
8550         {
8551             if (currentStyle.HasFontWeight())
8552             {
8553                 if (currentStyle.GetFontWeight() != attr.GetFontWeight())
8554                 {
8555                     // Clash of attr - mark as such
8556                     clashingAttr.AddFlag(wxTEXT_ATTR_FONT_WEIGHT);
8557                     currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_WEIGHT);
8558                 }
8559             }
8560             else
8561                 currentStyle.SetFontWeight(attr.GetFontWeight());
8562         }
8563
8564         if (attr.HasFontFaceName() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_FACE))
8565         {
8566             if (currentStyle.HasFontFaceName())
8567             {
8568                 wxString faceName1(currentStyle.GetFontFaceName());
8569                 wxString faceName2(attr.GetFontFaceName());
8570
8571                 if (faceName1 != faceName2)
8572                 {
8573                     // Clash of attr - mark as such
8574                     clashingAttr.AddFlag(wxTEXT_ATTR_FONT_FACE);
8575                     currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_FACE);
8576                 }
8577             }
8578             else
8579                 currentStyle.SetFontFaceName(attr.GetFontFaceName());
8580         }
8581
8582         if (attr.HasFontUnderlined() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_UNDERLINE))
8583         {
8584             if (currentStyle.HasFontUnderlined())
8585             {
8586                 if (currentStyle.GetFontUnderlined() != attr.GetFontUnderlined())
8587                 {
8588                     // Clash of attr - mark as such
8589                     clashingAttr.AddFlag(wxTEXT_ATTR_FONT_UNDERLINE);
8590                     currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_UNDERLINE);
8591                 }
8592             }
8593             else
8594                 currentStyle.SetFontUnderlined(attr.GetFontUnderlined());
8595         }
8596     }
8597
8598     if (attr.HasTextColour() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_TEXT_COLOUR))
8599     {
8600         if (currentStyle.HasTextColour())
8601         {
8602             if (currentStyle.GetTextColour() != attr.GetTextColour())
8603             {
8604                 // Clash of attr - mark as such
8605                 clashingAttr.AddFlag(wxTEXT_ATTR_TEXT_COLOUR);
8606                 currentStyle.RemoveFlag(wxTEXT_ATTR_TEXT_COLOUR);
8607             }
8608         }
8609         else
8610             currentStyle.SetTextColour(attr.GetTextColour());
8611     }
8612
8613     if (attr.HasBackgroundColour() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_BACKGROUND_COLOUR))
8614     {
8615         if (currentStyle.HasBackgroundColour())
8616         {
8617             if (currentStyle.GetBackgroundColour() != attr.GetBackgroundColour())
8618             {
8619                 // Clash of attr - mark as such
8620                 clashingAttr.AddFlag(wxTEXT_ATTR_BACKGROUND_COLOUR);
8621                 currentStyle.RemoveFlag(wxTEXT_ATTR_BACKGROUND_COLOUR);
8622             }
8623         }
8624         else
8625             currentStyle.SetBackgroundColour(attr.GetBackgroundColour());
8626     }
8627
8628     if (attr.HasAlignment() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_ALIGNMENT))
8629     {
8630         if (currentStyle.HasAlignment())
8631         {
8632             if (currentStyle.GetAlignment() != attr.GetAlignment())
8633             {
8634                 // Clash of attr - mark as such
8635                 clashingAttr.AddFlag(wxTEXT_ATTR_ALIGNMENT);
8636                 currentStyle.RemoveFlag(wxTEXT_ATTR_ALIGNMENT);
8637             }
8638         }
8639         else
8640             currentStyle.SetAlignment(attr.GetAlignment());
8641     }
8642
8643     if (attr.HasTabs() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_TABS))
8644     {
8645         if (currentStyle.HasTabs())
8646         {
8647             if (!wxRichTextTabsEq(currentStyle.GetTabs(), attr.GetTabs()))
8648             {
8649                 // Clash of attr - mark as such
8650                 clashingAttr.AddFlag(wxTEXT_ATTR_TABS);
8651                 currentStyle.RemoveFlag(wxTEXT_ATTR_TABS);
8652             }
8653         }
8654         else
8655             currentStyle.SetTabs(attr.GetTabs());
8656     }
8657
8658     if (attr.HasLeftIndent() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_LEFT_INDENT))
8659     {
8660         if (currentStyle.HasLeftIndent())
8661         {
8662             if (currentStyle.GetLeftIndent() != attr.GetLeftIndent() || currentStyle.GetLeftSubIndent() != attr.GetLeftSubIndent())
8663             {
8664                 // Clash of attr - mark as such
8665                 clashingAttr.AddFlag(wxTEXT_ATTR_LEFT_INDENT);
8666                 currentStyle.RemoveFlag(wxTEXT_ATTR_LEFT_INDENT);
8667             }
8668         }
8669         else
8670             currentStyle.SetLeftIndent(attr.GetLeftIndent(), attr.GetLeftSubIndent());
8671     }
8672
8673     if (attr.HasRightIndent() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_RIGHT_INDENT))
8674     {
8675         if (currentStyle.HasRightIndent())
8676         {
8677             if (currentStyle.GetRightIndent() != attr.GetRightIndent())
8678             {
8679                 // Clash of attr - mark as such
8680                 clashingAttr.AddFlag(wxTEXT_ATTR_RIGHT_INDENT);
8681                 currentStyle.RemoveFlag(wxTEXT_ATTR_RIGHT_INDENT);
8682             }
8683         }
8684         else
8685             currentStyle.SetRightIndent(attr.GetRightIndent());
8686     }
8687
8688     if (attr.HasParagraphSpacingAfter() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_PARA_SPACING_AFTER))
8689     {
8690         if (currentStyle.HasParagraphSpacingAfter())
8691         {
8692             if (currentStyle.GetParagraphSpacingAfter() != attr.GetParagraphSpacingAfter())
8693             {
8694                 // Clash of attr - mark as such
8695                 clashingAttr.AddFlag(wxTEXT_ATTR_PARA_SPACING_AFTER);
8696                 currentStyle.RemoveFlag(wxTEXT_ATTR_PARA_SPACING_AFTER);
8697             }
8698         }
8699         else
8700             currentStyle.SetParagraphSpacingAfter(attr.GetParagraphSpacingAfter());
8701     }
8702
8703     if (attr.HasParagraphSpacingBefore() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_PARA_SPACING_BEFORE))
8704     {
8705         if (currentStyle.HasParagraphSpacingBefore())
8706         {
8707             if (currentStyle.GetParagraphSpacingBefore() != attr.GetParagraphSpacingBefore())
8708             {
8709                 // Clash of attr - mark as such
8710                 clashingAttr.AddFlag(wxTEXT_ATTR_PARA_SPACING_BEFORE);
8711                 currentStyle.RemoveFlag(wxTEXT_ATTR_PARA_SPACING_BEFORE);
8712             }
8713         }
8714         else
8715             currentStyle.SetParagraphSpacingBefore(attr.GetParagraphSpacingBefore());
8716     }
8717
8718     if (attr.HasLineSpacing() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_LINE_SPACING))
8719     {
8720         if (currentStyle.HasLineSpacing())
8721         {
8722             if (currentStyle.GetLineSpacing() != attr.GetLineSpacing())
8723             {
8724                 // Clash of attr - mark as such
8725                 clashingAttr.AddFlag(wxTEXT_ATTR_LINE_SPACING);
8726                 currentStyle.RemoveFlag(wxTEXT_ATTR_LINE_SPACING);
8727             }
8728         }
8729         else
8730             currentStyle.SetLineSpacing(attr.GetLineSpacing());
8731     }
8732
8733     if (attr.HasCharacterStyleName() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_CHARACTER_STYLE_NAME))
8734     {
8735         if (currentStyle.HasCharacterStyleName())
8736         {
8737             if (currentStyle.GetCharacterStyleName() != attr.GetCharacterStyleName())
8738             {
8739                 // Clash of attr - mark as such
8740                 clashingAttr.AddFlag(wxTEXT_ATTR_CHARACTER_STYLE_NAME);
8741                 currentStyle.RemoveFlag(wxTEXT_ATTR_CHARACTER_STYLE_NAME);
8742             }
8743         }
8744         else
8745             currentStyle.SetCharacterStyleName(attr.GetCharacterStyleName());
8746     }
8747
8748     if (attr.HasParagraphStyleName() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_PARAGRAPH_STYLE_NAME))
8749     {
8750         if (currentStyle.HasParagraphStyleName())
8751         {
8752             if (currentStyle.GetParagraphStyleName() != attr.GetParagraphStyleName())
8753             {
8754                 // Clash of attr - mark as such
8755                 clashingAttr.AddFlag(wxTEXT_ATTR_PARAGRAPH_STYLE_NAME);
8756                 currentStyle.RemoveFlag(wxTEXT_ATTR_PARAGRAPH_STYLE_NAME);
8757             }
8758         }
8759         else
8760             currentStyle.SetParagraphStyleName(attr.GetParagraphStyleName());
8761     }
8762
8763     if (attr.HasListStyleName() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_LIST_STYLE_NAME))
8764     {
8765         if (currentStyle.HasListStyleName())
8766         {
8767             if (currentStyle.GetListStyleName() != attr.GetListStyleName())
8768             {
8769                 // Clash of attr - mark as such
8770                 clashingAttr.AddFlag(wxTEXT_ATTR_LIST_STYLE_NAME);
8771                 currentStyle.RemoveFlag(wxTEXT_ATTR_LIST_STYLE_NAME);
8772             }
8773         }
8774         else
8775             currentStyle.SetListStyleName(attr.GetListStyleName());
8776     }
8777
8778     if (attr.HasBulletStyle() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_BULLET_STYLE))
8779     {
8780         if (currentStyle.HasBulletStyle())
8781         {
8782             if (currentStyle.GetBulletStyle() != attr.GetBulletStyle())
8783             {
8784                 // Clash of attr - mark as such
8785                 clashingAttr.AddFlag(wxTEXT_ATTR_BULLET_STYLE);
8786                 currentStyle.RemoveFlag(wxTEXT_ATTR_BULLET_STYLE);
8787             }
8788         }
8789         else
8790             currentStyle.SetBulletStyle(attr.GetBulletStyle());
8791     }
8792
8793     if (attr.HasBulletNumber() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_BULLET_NUMBER))
8794     {
8795         if (currentStyle.HasBulletNumber())
8796         {
8797             if (currentStyle.GetBulletNumber() != attr.GetBulletNumber())
8798             {
8799                 // Clash of attr - mark as such
8800                 clashingAttr.AddFlag(wxTEXT_ATTR_BULLET_NUMBER);
8801                 currentStyle.RemoveFlag(wxTEXT_ATTR_BULLET_NUMBER);
8802             }
8803         }
8804         else
8805             currentStyle.SetBulletNumber(attr.GetBulletNumber());
8806     }
8807
8808     if (attr.HasBulletText() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_BULLET_TEXT))
8809     {
8810         if (currentStyle.HasBulletText())
8811         {
8812             if (currentStyle.GetBulletText() != attr.GetBulletText())
8813             {
8814                 // Clash of attr - mark as such
8815                 clashingAttr.AddFlag(wxTEXT_ATTR_BULLET_TEXT);
8816                 currentStyle.RemoveFlag(wxTEXT_ATTR_BULLET_TEXT);
8817             }
8818         }
8819         else
8820         {
8821             currentStyle.SetBulletText(attr.GetBulletText());
8822             currentStyle.SetBulletFont(attr.GetBulletFont());
8823         }
8824     }
8825
8826     if (attr.HasBulletName() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_BULLET_NAME))
8827     {
8828         if (currentStyle.HasBulletName())
8829         {
8830             if (currentStyle.GetBulletName() != attr.GetBulletName())
8831             {
8832                 // Clash of attr - mark as such
8833                 clashingAttr.AddFlag(wxTEXT_ATTR_BULLET_NAME);
8834                 currentStyle.RemoveFlag(wxTEXT_ATTR_BULLET_NAME);
8835             }
8836         }
8837         else
8838         {
8839             currentStyle.SetBulletName(attr.GetBulletName());
8840         }
8841     }
8842
8843     if (attr.HasURL() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_URL))
8844     {
8845         if (currentStyle.HasURL())
8846         {
8847             if (currentStyle.GetURL() != attr.GetURL())
8848             {
8849                 // Clash of attr - mark as such
8850                 clashingAttr.AddFlag(wxTEXT_ATTR_URL);
8851                 currentStyle.RemoveFlag(wxTEXT_ATTR_URL);
8852             }
8853         }
8854         else
8855         {
8856             currentStyle.SetURL(attr.GetURL());
8857         }
8858     }
8859
8860     if (attr.HasTextEffects() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_EFFECTS))
8861     {
8862         if (currentStyle.HasTextEffects())
8863         {
8864             // We need to find the bits in the new attr that are different:
8865             // just look at those bits that are specified by the new attr.
8866
8867             // We need to remove the bits and flags that are not common between current attr
8868             // and new attr. In so doing we need to take account of the styles absent from one or more of the
8869             // previous styles.
8870
8871             int currentRelevantTextEffects = currentStyle.GetTextEffects() & attr.GetTextEffectFlags();
8872             int newRelevantTextEffects = attr.GetTextEffects() & attr.GetTextEffectFlags();
8873
8874             if (currentRelevantTextEffects != newRelevantTextEffects)
8875             {
8876                 // Find the text effects that were different, using XOR
8877                 int differentEffects = currentRelevantTextEffects ^ newRelevantTextEffects;
8878
8879                 // Clash of attr - mark as such
8880                 clashingAttr.SetTextEffectFlags(clashingAttr.GetTextEffectFlags() | differentEffects);
8881                 currentStyle.SetTextEffectFlags(currentStyle.GetTextEffectFlags() & ~differentEffects);
8882             }
8883         }
8884         else
8885         {
8886             currentStyle.SetTextEffects(attr.GetTextEffects());
8887             currentStyle.SetTextEffectFlags(attr.GetTextEffectFlags());
8888         }
8889
8890         // Mask out the flags and values that cannot be common because they were absent in one or more objecrs
8891         // that we've looked at so far
8892         currentStyle.SetTextEffects(currentStyle.GetTextEffects() & ~absentAttr.GetTextEffectFlags());
8893         currentStyle.SetTextEffectFlags(currentStyle.GetTextEffectFlags() & ~absentAttr.GetTextEffectFlags());
8894
8895         if (currentStyle.GetTextEffectFlags() == 0)
8896             currentStyle.RemoveFlag(wxTEXT_ATTR_EFFECTS);
8897     }
8898
8899     if (attr.HasOutlineLevel() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_OUTLINE_LEVEL))
8900     {
8901         if (currentStyle.HasOutlineLevel())
8902         {
8903             if (currentStyle.GetOutlineLevel() != attr.GetOutlineLevel())
8904             {
8905                 // Clash of attr - mark as such
8906                 clashingAttr.AddFlag(wxTEXT_ATTR_OUTLINE_LEVEL);
8907                 currentStyle.RemoveFlag(wxTEXT_ATTR_OUTLINE_LEVEL);
8908             }
8909         }
8910         else
8911             currentStyle.SetOutlineLevel(attr.GetOutlineLevel());
8912     }
8913 }
8914
8915
8916 #endif
8917     // wxUSE_RICHTEXT