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