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 #include "wx/richtext/richtextsizepage.h"
  45 #include "wx/richtext/richtextxml.h"
  46
  47 #include "wx/listimpl.cpp"
  48 #include "wx/arrimpl.cpp"
  49
  50 WX_DEFINE_LIST(wxRichTextObjectList)
  51 WX_DEFINE_LIST(wxRichTextLineList)
  52
  53 // Switch off if the platform doesn't like it for some reason
  54 #define wxRICHTEXT_USE_OPTIMIZED_DRAWING 1
  55
  56 // Use GetPartialTextExtents for platforms that support it natively
  57 #define wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS 1
  58
  59 const wxChar wxRichTextLineBreakChar = (wxChar) 29;
  60
  61 // Helper classes for floating layout
  62 struct wxRichTextFloatRectMap
  63 {
  64     wxRichTextFloatRectMap(int sY, int eY, int w, wxRichTextObject* obj)
  65     {
  66         startY = sY;
  67         endY = eY;
  68         width = w;
  69         anchor = obj;
  70     }
  71
  72     int startY, endY;
  73     int width;
  74     wxRichTextObject* anchor;
  75 };
  76
  77 WX_DEFINE_SORTED_ARRAY(wxRichTextFloatRectMap*, wxRichTextFloatRectMapArray);
  78
  79 int wxRichTextFloatRectMapCmp(wxRichTextFloatRectMap* r1, wxRichTextFloatRectMap* r2)
  80 {
  81     return r1->startY - r2->startY;
  82 }
  83
  84 class wxRichTextFloatCollector
  85 {
  86 public:
  87     wxRichTextFloatCollector(const wxRect& availableRect);
  88     ~wxRichTextFloatCollector();
  89
  90     // Collect the floating objects info in the given paragraph
  91     void CollectFloat(wxRichTextParagraph* para);
  92     void CollectFloat(wxRichTextParagraph* para, wxRichTextObject* floating);
  93
  94     // Return the last paragraph we collected
  95     wxRichTextParagraph* LastParagraph();
  96
  97     // Given the start y position and the height of the line,
  98     // find out how wide the line can be
  99     wxRect GetAvailableRect(int startY, int endY);
 100
 101     // Given a floating box, find its fit position
 102     int GetFitPosition(int direction, int start, int height) const;
 103     int GetFitPosition(const wxRichTextFloatRectMapArray& array, int start, int height) const;
 104
 105     // Find the last y position
 106     int GetLastRectBottom();
 107
 108     // Draw the floats inside a rect
 109     void Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
 110
 111     // HitTest the floats
 112     int HitTest(wxDC& dc, wxRichTextDrawingContext& context, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, int flags);
 113
 114     // Get floating object count
 115     int GetFloatingObjectCount() const { return m_left.GetCount() + m_right.GetCount(); }
 116
 117     // Get floating objects
 118     bool GetFloatingObjects(wxRichTextObjectList& objects) const;
 119
 120     // Delete a float
 121     bool DeleteFloat(wxRichTextObject* obj);
 122
 123     // Do we have this float already?
 124     bool HasFloat(wxRichTextObject* obj);
 125
 126     bool HasFloats() const { return m_left.GetCount() >0 || m_right.GetCount() > 0; }
 127
 128     static int SearchAdjacentRect(const wxRichTextFloatRectMapArray& array, int point);
 129
 130     static int GetWidthFromFloatRect(const wxRichTextFloatRectMapArray& array, int index, int startY, int endY);
 131
 132     static void FreeFloatRectMapArray(wxRichTextFloatRectMapArray& array);
 133
 134     static void DrawFloat(const wxRichTextFloatRectMapArray& array, wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
 135
 136     static int HitTestFloat(const wxRichTextFloatRectMapArray& array, wxDC& dc, wxRichTextDrawingContext& context, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, int flags);
 137
 138 private:
 139     wxRichTextFloatRectMapArray m_left;
 140     wxRichTextFloatRectMapArray m_right;
 141     //int m_width;
 142     wxRect               m_availableRect;
 143     wxRichTextParagraph* m_para;
 144 };
 145
 146 // Delete a float
 147 bool wxRichTextFloatCollector::DeleteFloat(wxRichTextObject* obj)
 148 {
 149     size_t i;
 150     for (i = 0; i < m_left.GetCount(); i++)
 151     {
 152         if (m_left[i]->anchor == obj)
 153         {
 154             m_left.RemoveAt(i);
 155             return true;
 156         }
 157     }
 158     for (i = 0; i < m_right.GetCount(); i++)
 159     {
 160         if (m_right[i]->anchor == obj)
 161         {
 162             m_right.RemoveAt(i);
 163             return true;
 164         }
 165     }
 166     return false;
 167 }
 168
 169 // Do we have this float already?
 170 bool wxRichTextFloatCollector::HasFloat(wxRichTextObject* obj)
 171 {
 172     size_t i;
 173     for (i = 0; i < m_left.GetCount(); i++)
 174     {
 175         if (m_left[i]->anchor == obj)
 176         {
 177             return true;
 178         }
 179     }
 180     for (i = 0; i < m_right.GetCount(); i++)
 181     {
 182         if (m_right[i]->anchor == obj)
 183         {
 184             return true;
 185         }
 186     }
 187     return false;
 188 }
 189
 190 // Get floating objects
 191 bool wxRichTextFloatCollector::GetFloatingObjects(wxRichTextObjectList& objects) const
 192 {
 193     size_t i;
 194     for (i = 0; i < m_left.GetCount(); i++)
 195         objects.Append(m_left[i]->anchor);
 196     for (i = 0; i < m_right.GetCount(); i++)
 197         objects.Append(m_right[i]->anchor);
 198     return true;
 199 }
 200
 201
 202 /*
 203  * Binary search helper function
 204  * The argument point is the Y coordinate, and this fuction
 205  * always return the floating rect that contain this coordinate
 206  * or under this coordinate.
 207  */
 208 int wxRichTextFloatCollector::SearchAdjacentRect(const wxRichTextFloatRectMapArray& array, int point)
 209 {
 210     int end = array.GetCount() - 1;
 211     int start = 0;
 212     int ret = 0;
 213
 214     wxASSERT(end >= 0);
 215
 216     while (true)
 217     {
 218         if (start > end)
 219         {
 220             break;
 221         }
 222
 223         int mid = (start + end) / 2;
 224         if (array[mid]->startY <= point && array[mid]->endY >= point)
 225             return mid;
 226         else if (array[mid]->startY > point)
 227         {
 228             end = mid - 1;
 229             ret = mid;
 230         }
 231         else if (array[mid]->endY < point)
 232         {
 233             start = mid + 1;
 234             ret = start;
 235         }
 236     }
 237
 238     return ret;
 239 }
 240
 241 int wxRichTextFloatCollector::GetWidthFromFloatRect(const wxRichTextFloatRectMapArray& array, int index, int startY, int endY)
 242 {
 243     int ret = 0;
 244     int len = array.GetCount();
 245
 246     wxASSERT(index >= 0 && index < len);
 247
 248     if (array[index]->startY < startY && array[index]->endY > startY)
 249         ret = ret < array[index]->width ? array[index]->width : ret;
 250     while (index < len && array[index]->startY <= endY)
 251     {
 252         ret = ret < array[index]->width ? array[index]->width : ret;
 253         index++;
 254     }
 255
 256     return ret;
 257 }
 258
 259 wxRichTextFloatCollector::wxRichTextFloatCollector(const wxRect& rect) : m_left(wxRichTextFloatRectMapCmp), m_right(wxRichTextFloatRectMapCmp)
 260 {
 261     m_availableRect = rect;
 262     m_para = NULL;
 263 }
 264
 265 void wxRichTextFloatCollector::FreeFloatRectMapArray(wxRichTextFloatRectMapArray& array)
 266 {
 267     int len = array.GetCount();
 268     for (int i = 0; i < len; i++)
 269         delete array[i];
 270 }
 271
 272 wxRichTextFloatCollector::~wxRichTextFloatCollector()
 273 {
 274     FreeFloatRectMapArray(m_left);
 275     FreeFloatRectMapArray(m_right);
 276 }
 277
 278 int wxRichTextFloatCollector::GetFitPosition(const wxRichTextFloatRectMapArray& array, int start, int height) const
 279 {
 280     if (array.GetCount() == 0)
 281         return start;
 282
 283     int i = SearchAdjacentRect(array, start);
 284     int last = start;
 285     while (i < (int) array.GetCount())
 286     {
 287         if (array[i]->startY - last >= height)
 288             return last + 1;
 289         last = array[i]->endY;
 290         i++;
 291     }
 292
 293     return last + 1;
 294 }
 295
 296 int wxRichTextFloatCollector::GetFitPosition(int direction, int start, int height) const
 297 {
 298     if (direction == wxTEXT_BOX_ATTR_FLOAT_LEFT)
 299         return GetFitPosition(m_left, start, height);
 300     else if (direction == wxTEXT_BOX_ATTR_FLOAT_RIGHT)
 301         return GetFitPosition(m_right, start, height);
 302     else
 303     {
 304         wxASSERT("Never should be here");
 305         return start;
 306     }
 307 }
 308
 309 // Adds a floating image to the float collector.
 310 // The actual positioning is done by wxRichTextParagraph::LayoutFloat.
 311 void wxRichTextFloatCollector::CollectFloat(wxRichTextParagraph* para, wxRichTextObject* floating)
 312 {
 313     int direction = floating->GetFloatDirection();
 314
 315     wxPoint pos = floating->GetPosition();
 316     wxSize size = floating->GetCachedSize();
 317     wxRichTextFloatRectMap *map = new wxRichTextFloatRectMap(pos.y, pos.y + size.y, size.x, floating);
 318     switch (direction)
 319     {
 320         case wxTEXT_BOX_ATTR_FLOAT_NONE:
 321             delete map;
 322             break;
 323         case wxTEXT_BOX_ATTR_FLOAT_LEFT:
 324             // Just a not-enough simple assertion
 325             wxASSERT (m_left.Index(map) == wxNOT_FOUND);
 326             m_left.Add(map);
 327             break;
 328         case wxTEXT_BOX_ATTR_FLOAT_RIGHT:
 329             wxASSERT (m_right.Index(map) == wxNOT_FOUND);
 330             m_right.Add(map);
 331             break;
 332         default:
 333             delete map;
 334             wxASSERT("Unrecognised float attribute.");
 335     }
 336
 337     m_para = para;
 338 }
 339
 340 void wxRichTextFloatCollector::CollectFloat(wxRichTextParagraph* para)
 341 {
 342     wxRichTextObjectList::compatibility_iterator node = para->GetChildren().GetFirst();
 343     while (node)
 344     {
 345         wxRichTextObject* floating = node->GetData();
 346
 347         if (floating->IsFloating())
 348         {
 349             CollectFloat(para, floating);
 350         }
 351
 352         node = node->GetNext();
 353     }
 354
 355     m_para = para;
 356 }
 357
 358 wxRichTextParagraph* wxRichTextFloatCollector::LastParagraph()
 359 {
 360     return m_para;
 361 }
 362
 363 wxRect wxRichTextFloatCollector::GetAvailableRect(int startY, int endY)
 364 {
 365     int widthLeft = 0, widthRight = 0;
 366     if (m_left.GetCount() != 0)
 367     {
 368         int i = SearchAdjacentRect(m_left, startY);
 369         if (i < (int) m_left.GetCount())
 370             widthLeft = GetWidthFromFloatRect(m_left, i, startY, endY);
 371     }
 372     if (m_right.GetCount() != 0)
 373     {
 374         int j = SearchAdjacentRect(m_right, startY);
 375         if (j < (int) m_right.GetCount())
 376             widthRight = GetWidthFromFloatRect(m_right, j, startY, endY);
 377     }
 378
 379     // TODO: actually we want to use the actual image positions to find the
 380     // available remaining space, since the image might not be right up against
 381     // the left or right edge of the container.
 382     return wxRect(widthLeft + m_availableRect.x, 0, m_availableRect.width - widthLeft - widthRight, 0);
 383 }
 384
 385 int wxRichTextFloatCollector::GetLastRectBottom()
 386 {
 387     int ret = 0;
 388     int len = m_left.GetCount();
 389     if (len) {
 390         ret = ret > m_left[len-1]->endY ? ret : m_left[len-1]->endY;
 391     }
 392     len = m_right.GetCount();
 393     if (len) {
 394         ret = ret > m_right[len-1]->endY ? ret : m_right[len-1]->endY;
 395     }
 396
 397     return ret;
 398 }
 399
 400 void wxRichTextFloatCollector::DrawFloat(const wxRichTextFloatRectMapArray& array, wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& WXUNUSED(range), const wxRichTextSelection& selection, const wxRect& rect, int descent, int style)
 401 {
 402     int start = rect.y;
 403     int end = rect.y + rect.height;
 404     int i, j;
 405     i = SearchAdjacentRect(array, start);
 406     if (i < 0 || i >= (int) array.GetCount())
 407         return;
 408     j = SearchAdjacentRect(array, end);
 409     if (j < 0 || j >= (int) array.GetCount())
 410         j = array.GetCount() - 1;
 411     while (i <= j)
 412     {
 413         wxRichTextObject* obj = array[i]->anchor;
 414         wxRichTextRange r = obj->GetRange();
 415         obj->Draw(dc, context, r, selection, wxRect(obj->GetPosition(), obj->GetCachedSize()), descent, style);
 416         i++;
 417     }
 418 }
 419
 420 void wxRichTextFloatCollector::Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style)
 421 {
 422     if (m_left.GetCount() > 0)
 423         DrawFloat(m_left, dc, context, range, selection, rect, descent, style);
 424     if (m_right.GetCount() > 0)
 425         DrawFloat(m_right, dc, context, range, selection, rect, descent, style);
 426 }
 427
 428 int wxRichTextFloatCollector::HitTestFloat(const wxRichTextFloatRectMapArray& array, wxDC& WXUNUSED(dc), wxRichTextDrawingContext& WXUNUSED(context), const wxPoint& pt, long& textPosition, wxRichTextObject** obj, int WXUNUSED(flags))
 429 {
 430     int i;
 431     if (array.GetCount() == 0)
 432         return wxRICHTEXT_HITTEST_NONE;
 433     i = SearchAdjacentRect(array, pt.y);
 434     if (i < 0 || i >= (int) array.GetCount())
 435         return wxRICHTEXT_HITTEST_NONE;
 436     if (!array[i]->anchor->IsShown())
 437         return wxRICHTEXT_HITTEST_NONE;
 438
 439     wxPoint point = array[i]->anchor->GetPosition();
 440     wxSize size = array[i]->anchor->GetCachedSize();
 441     if (point.x <= pt.x && point.x + size.x >= pt.x
 442         && point.y <= pt.y && point.y + size.y >= pt.y)
 443     {
 444         textPosition = array[i]->anchor->GetRange().GetStart();
 445         * obj = array[i]->anchor;
 446         if (pt.x > (pt.x + pt.x + size.x) / 2)
 447             return wxRICHTEXT_HITTEST_BEFORE;
 448         else
 449             return wxRICHTEXT_HITTEST_AFTER;
 450     }
 451
 452     return wxRICHTEXT_HITTEST_NONE;
 453 }
 454
 455 int wxRichTextFloatCollector::HitTest(wxDC& dc, wxRichTextDrawingContext& context, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, int flags)
 456 {
 457     int ret = HitTestFloat(m_left, dc, context, pt, textPosition, obj, flags);
 458     if (ret == wxRICHTEXT_HITTEST_NONE)
 459     {
 460         ret = HitTestFloat(m_right, dc, context, pt, textPosition, obj, flags);
 461     }
 462     return ret;
 463 }
 464
 465 // Helpers for efficiency
 466 inline void wxCheckSetFont(wxDC& dc, const wxFont& font)
 467 {
 468     dc.SetFont(font);
 469 }
 470
 471 inline void wxCheckSetPen(wxDC& dc, const wxPen& pen)
 472 {
 473     const wxPen& pen1 = dc.GetPen();
 474     if (pen1.IsOk() && pen.IsOk())
 475     {
 476         if (pen1.GetWidth() == pen.GetWidth() &&
 477             pen1.GetStyle() == pen.GetStyle() &&
 478             pen1.GetColour() == pen.GetColour())
 479             return;
 480     }
 481     dc.SetPen(pen);
 482 }
 483
 484 inline void wxCheckSetBrush(wxDC& dc, const wxBrush& brush)
 485 {
 486     const wxBrush& brush1 = dc.GetBrush();
 487     if (brush1.IsOk() && brush.IsOk())
 488     {
 489         if (brush1.GetStyle() == brush.GetStyle() &&
 490             brush1.GetColour() == brush.GetColour())
 491             return;
 492     }
 493     dc.SetBrush(brush);
 494 }
 495
 496 /*!
 497  * wxRichTextObject
 498  * This is the base for drawable objects.
 499  */
 500
 501 IMPLEMENT_CLASS(wxRichTextObject, wxObject)
 502
 503 wxRichTextObject::wxRichTextObject(wxRichTextObject* parent)
 504 {
 505     m_refCount = 1;
 506     m_parent = parent;
 507     m_descent = 0;
 508     m_show = true;
 509 }
 510
 511 wxRichTextObject::~wxRichTextObject()
 512 {
 513 }
 514
 515 void wxRichTextObject::Dereference()
 516 {
 517     m_refCount --;
 518     if (m_refCount <= 0)
 519         delete this;
 520 }
 521
 522 /// Copy
 523 void wxRichTextObject::Copy(const wxRichTextObject& obj)
 524 {
 525     m_size = obj.m_size;
 526     m_maxSize = obj.m_maxSize;
 527     m_minSize = obj.m_minSize;
 528     m_pos = obj.m_pos;
 529     m_range = obj.m_range;
 530     m_ownRange = obj.m_ownRange;
 531     m_attributes = obj.m_attributes;
 532     m_properties = obj.m_properties;
 533     m_descent = obj.m_descent;
 534     m_show = obj.m_show;
 535 }
 536
 537 // Get/set the top-level container of this object.
 538 wxRichTextParagraphLayoutBox* wxRichTextObject::GetContainer() const
 539 {
 540     const wxRichTextObject* p = this;
 541     while (p)
 542     {
 543         if (p->IsTopLevel())
 544         {
 545             return wxDynamicCast(p, wxRichTextParagraphLayoutBox);
 546         }
 547         p = p->GetParent();
 548     }
 549     return NULL;
 550 }
 551
 552 void wxRichTextObject::SetMargins(int margin)
 553 {
 554     SetMargins(margin, margin, margin, margin);
 555 }
 556
 557 void wxRichTextObject::SetMargins(int leftMargin, int rightMargin, int topMargin, int bottomMargin)
 558 {
 559     GetAttributes().GetTextBoxAttr().GetMargins().GetLeft().SetValue(leftMargin, wxTEXT_ATTR_UNITS_PIXELS);
 560     GetAttributes().GetTextBoxAttr().GetMargins().GetRight().SetValue(rightMargin, wxTEXT_ATTR_UNITS_PIXELS);
 561     GetAttributes().GetTextBoxAttr().GetMargins().GetTop().SetValue(topMargin, wxTEXT_ATTR_UNITS_PIXELS);
 562     GetAttributes().GetTextBoxAttr().GetMargins().GetBottom().SetValue(bottomMargin, wxTEXT_ATTR_UNITS_PIXELS);
 563 }
 564
 565 int wxRichTextObject::GetLeftMargin() const
 566 {
 567     return GetAttributes().GetTextBoxAttr().GetMargins().GetLeft().GetValue();
 568 }
 569
 570 int wxRichTextObject::GetRightMargin() const
 571 {
 572     return GetAttributes().GetTextBoxAttr().GetMargins().GetRight().GetValue();
 573 }
 574
 575 int wxRichTextObject::GetTopMargin() const
 576 {
 577     return GetAttributes().GetTextBoxAttr().GetMargins().GetTop().GetValue();
 578 }
 579
 580 int wxRichTextObject::GetBottomMargin() const
 581 {
 582     return GetAttributes().GetTextBoxAttr().GetMargins().GetBottom().GetValue();
 583 }
 584
 585 // Calculate the available content space in the given rectangle, given the
 586 // margins, border and padding specified in the object's attributes.
 587 wxRect wxRichTextObject::GetAvailableContentArea(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& outerRect) const
 588 {
 589     wxRect marginRect, borderRect, contentRect, paddingRect, outlineRect;
 590     marginRect = outerRect;
 591     wxRichTextAttr attr(GetAttributes());
 592     context.ApplyVirtualAttributes(attr, (wxRichTextObject*) this);
 593     GetBoxRects(dc, GetBuffer(), attr, marginRect, borderRect, contentRect, paddingRect, outlineRect);
 594     return contentRect;
 595 }
 596
 597 // Invalidate the buffer. With no argument, invalidates whole buffer.
 598 void wxRichTextObject::Invalidate(const wxRichTextRange& invalidRange)
 599 {
 600     if (invalidRange != wxRICHTEXT_NONE)
 601     {
 602         // If this is a floating object, size may not be recalculated
 603         // after floats have been collected in an early stage of Layout.
 604         // So avoid resetting the cache for floating objects during layout.
 605         if (!IsFloating())
 606             SetCachedSize(wxDefaultSize);
 607         SetMaxSize(wxDefaultSize);
 608         SetMinSize(wxDefaultSize);
 609     }
 610 }
 611
 612 // Convert units in tenths of a millimetre to device units
 613 int wxRichTextObject::ConvertTenthsMMToPixels(wxDC& dc, int units) const
 614 {
 615     // Unscale
 616     double scale = 1.0;
 617     if (GetBuffer())
 618         scale = GetBuffer()->GetScale() / GetBuffer()->GetDimensionScale();
 619     int p = ConvertTenthsMMToPixels(dc.GetPPI().x, units, scale);
 620
 621     return p;
 622 }
 623
 624 // Convert units in tenths of a millimetre to device units
 625 int wxRichTextObject::ConvertTenthsMMToPixels(int ppi, int units, double scale)
 626 {
 627     // There are ppi pixels in 254.1 "1/10 mm"
 628
 629     double pixels = ((double) units * (double)ppi) / 254.1;
 630     if (scale != 1.0)
 631         pixels /= scale;
 632
 633     // If the result is very small, make it at least one pixel in size.
 634     if (pixels == 0 && units > 0)
 635         pixels = 1;
 636
 637     return (int) pixels;
 638 }
 639
 640 // Convert units in pixels to tenths of a millimetre
 641 int wxRichTextObject::ConvertPixelsToTenthsMM(wxDC& dc, int pixels) const
 642 {
 643     int p = pixels;
 644     double scale = 1.0;
 645     if (GetBuffer())
 646         scale = GetBuffer()->GetScale();
 647
 648     return ConvertPixelsToTenthsMM(dc.GetPPI().x, p, scale);
 649 }
 650
 651 int wxRichTextObject::ConvertPixelsToTenthsMM(int ppi, int pixels, double scale)
 652 {
 653     // There are ppi pixels in 254.1 "1/10 mm"
 654
 655     double p = double(pixels);
 656
 657     if (scale != 1.0)
 658         p *= scale;
 659
 660     int units = int( p * 254.1 / (double) ppi );
 661     return units;
 662 }
 663
 664 // Draw the borders and background for the given rectangle and attributes.
 665 // Width and height are taken to be the outer margin size, not the content.
 666 bool wxRichTextObject::DrawBoxAttributes(wxDC& dc, wxRichTextBuffer* buffer, const wxRichTextAttr& attr, const wxRect& boxRect, int flags)
 667 {
 668     // Assume boxRect is the area around the content
 669     wxRect marginRect = boxRect;
 670     wxRect contentRect, borderRect, paddingRect, outlineRect;
 671
 672     GetBoxRects(dc, buffer, attr, marginRect, borderRect, contentRect, paddingRect, outlineRect);
 673
 674     // Margin is transparent. Draw background from margin.
 675     if (attr.HasBackgroundColour() || (flags & wxRICHTEXT_DRAW_SELECTED))
 676     {
 677         wxColour colour;
 678         if (flags & wxRICHTEXT_DRAW_SELECTED)
 679         {
 680             // TODO: get selection colour from control?
 681             colour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
 682         }
 683         else
 684             colour = attr.GetBackgroundColour();
 685
 686         wxPen pen(colour);
 687         wxBrush brush(colour);
 688
 689         dc.SetPen(pen);
 690         dc.SetBrush(brush);
 691         dc.DrawRectangle(borderRect);
 692     }
 693
 694     if (flags & wxRICHTEXT_DRAW_GUIDELINES)
 695     {
 696         wxRichTextAttr editBorderAttr = attr;
 697         // TODO: make guideline colour configurable
 698         editBorderAttr.GetTextBoxAttr().GetBorder().SetColour(*wxLIGHT_GREY);
 699         editBorderAttr.GetTextBoxAttr().GetBorder().SetWidth(1, wxTEXT_ATTR_UNITS_PIXELS);
 700         editBorderAttr.GetTextBoxAttr().GetBorder().SetStyle(wxTEXT_BOX_ATTR_BORDER_SOLID);
 701
 702         DrawBorder(dc, buffer, editBorderAttr.GetTextBoxAttr().GetBorder(), borderRect, flags);
 703     }
 704
 705     if (attr.GetTextBoxAttr().GetBorder().IsValid())
 706         DrawBorder(dc, buffer, attr.GetTextBoxAttr().GetBorder(), borderRect);
 707
 708     if (attr.GetTextBoxAttr().GetOutline().IsValid())
 709         DrawBorder(dc, buffer, attr.GetTextBoxAttr().GetOutline(), outlineRect);
 710
 711     return true;
 712 }
 713
 714 // Draw a border
 715 bool wxRichTextObject::DrawBorder(wxDC& dc, wxRichTextBuffer* buffer, const wxTextAttrBorders& attr, const wxRect& rect, int WXUNUSED(flags))
 716 {
 717     int borderLeft = 0, borderRight = 0, borderTop = 0, borderBottom = 0;
 718     wxTextAttrDimensionConverter converter(dc, buffer ? buffer->GetScale() : 1.0);
 719
 720     if (attr.GetLeft().IsValid() && attr.GetLeft().GetStyle() != wxTEXT_BOX_ATTR_BORDER_NONE)
 721     {
 722         borderLeft = converter.GetPixels(attr.GetLeft().GetWidth());
 723         wxColour col(attr.GetLeft().GetColour());
 724
 725         // If pen width is > 1, resorts to a solid rectangle.
 726         if (borderLeft == 1)
 727         {
 728             int penStyle = wxSOLID;
 729             if (attr.GetLeft().GetStyle() == wxTEXT_BOX_ATTR_BORDER_DOTTED)
 730                 penStyle = wxDOT;
 731             else if (attr.GetLeft().GetStyle() == wxTEXT_BOX_ATTR_BORDER_DASHED)
 732                 penStyle = wxLONG_DASH;
 733             wxPen pen(col, 1, penStyle);
 734             dc.SetPen(pen);
 735             dc.DrawLine(rect.x, rect.y, rect.x, rect.y + rect.height);
 736
 737         }
 738         else if (borderLeft > 1)
 739         {
 740             wxPen pen(col);
 741             wxBrush brush(col);
 742             dc.SetPen(pen);
 743             dc.SetBrush(brush);
 744             dc.DrawRectangle(rect.x, rect.y, borderLeft, rect.height);
 745         }
 746     }
 747
 748     if (attr.GetRight().IsValid() && attr.GetRight().GetStyle() != wxTEXT_BOX_ATTR_BORDER_NONE)
 749     {
 750         borderRight = converter.GetPixels(attr.GetRight().GetWidth());
 751
 752         wxColour col(attr.GetRight().GetColour());
 753
 754         // If pen width is > 1, resorts to a solid rectangle.
 755         if (borderRight == 1)
 756         {
 757             int penStyle = wxSOLID;
 758             if (attr.GetRight().GetStyle() == wxTEXT_BOX_ATTR_BORDER_DOTTED)
 759                 penStyle = wxDOT;
 760             else if (attr.GetRight().GetStyle() == wxTEXT_BOX_ATTR_BORDER_DASHED)
 761                 penStyle = wxLONG_DASH;
 762             wxPen pen(col, 1, penStyle);
 763             dc.SetPen(pen);
 764             dc.DrawLine(rect.x + rect.width, rect.y, rect.x + rect.width, rect.y + rect.height + 1);
 765
 766         }
 767         else if (borderRight > 1)
 768         {
 769             wxPen pen(col);
 770             wxBrush brush(col);
 771             dc.SetPen(pen);
 772             dc.SetBrush(brush);
 773             dc.DrawRectangle(rect.x + rect.width - borderRight, rect.y, borderRight, rect.height);
 774         }
 775     }
 776
 777     if (attr.GetTop().IsValid() && attr.GetTop().GetStyle() != wxTEXT_BOX_ATTR_BORDER_NONE)
 778     {
 779         borderTop = converter.GetPixels(attr.GetTop().GetWidth());
 780
 781         wxColour col(attr.GetTop().GetColour());
 782
 783         // If pen width is > 1, resorts to a solid rectangle.
 784         if (borderTop == 1)
 785         {
 786             int penStyle = wxSOLID;
 787             if (attr.GetTop().GetStyle() == wxTEXT_BOX_ATTR_BORDER_DOTTED)
 788                 penStyle = wxDOT;
 789             else if (attr.GetTop().GetStyle() == wxTEXT_BOX_ATTR_BORDER_DASHED)
 790                 penStyle = wxLONG_DASH;
 791             wxPen pen(col, 1, penStyle);
 792             dc.SetPen(pen);
 793             dc.DrawLine(rect.x, rect.y, rect.x + rect.width, rect.y);
 794
 795         }
 796         else if (borderTop > 1)
 797         {
 798             wxPen pen(col);
 799             wxBrush brush(col);
 800             dc.SetPen(pen);
 801             dc.SetBrush(brush);
 802             dc.DrawRectangle(rect.x, rect.y, rect.width, borderTop);
 803         }
 804     }
 805
 806     if (attr.GetBottom().IsValid() && attr.GetBottom().GetStyle() != wxTEXT_BOX_ATTR_BORDER_NONE)
 807     {
 808         borderBottom = converter.GetPixels(attr.GetBottom().GetWidth());
 809         wxColour col(attr.GetTop().GetColour());
 810
 811         // If pen width is > 1, resorts to a solid rectangle.
 812         if (borderBottom == 1)
 813         {
 814             int penStyle = wxSOLID;
 815             if (attr.GetBottom().GetStyle() == wxTEXT_BOX_ATTR_BORDER_DOTTED)
 816                 penStyle = wxDOT;
 817             else if (attr.GetBottom().GetStyle() == wxTEXT_BOX_ATTR_BORDER_DASHED)
 818                 penStyle = wxLONG_DASH;
 819             wxPen pen(col, 1, penStyle);
 820             dc.SetPen(pen);
 821             dc.DrawLine(rect.x, rect.y + rect.height, rect.x + rect.width, rect.y + rect.height);
 822
 823         }
 824         else if (borderBottom > 1)
 825         {
 826             wxPen pen(col);
 827             wxBrush brush(col);
 828             dc.SetPen(pen);
 829             dc.SetBrush(brush);
 830             dc.DrawRectangle(rect.x, rect.y + rect.height - borderBottom, rect.width, borderBottom);
 831         }
 832     }
 833
 834     return true;
 835 }
 836
 837 // Get the various rectangles of the box model in pixels. You can either specify contentRect (inner)
 838 // or marginRect (outer), and the other must be the default rectangle (no width or height).
 839 // Note that the outline doesn't affect the position of the rectangle, it's drawn in whatever space
 840 // is available.
 841 //
 842 // | Margin | Border | Padding | CONTENT | Padding | Border | Margin |
 843
 844 bool wxRichTextObject::GetBoxRects(wxDC& dc, wxRichTextBuffer* buffer, const wxRichTextAttr& attr, wxRect& marginRect, wxRect& borderRect, wxRect& contentRect, wxRect& paddingRect, wxRect& outlineRect)
 845 {
 846     int borderLeft = 0, borderRight = 0, borderTop = 0, borderBottom = 0;
 847     int outlineLeft = 0, outlineRight = 0, outlineTop = 0, outlineBottom = 0;
 848     int paddingLeft = 0, paddingRight = 0, paddingTop = 0, paddingBottom = 0;
 849     int marginLeft = 0, marginRight = 0, marginTop = 0, marginBottom = 0;
 850
 851     wxTextAttrDimensionConverter converter(dc, buffer ? buffer->GetScale() : 1.0);
 852
 853     if (attr.GetTextBoxAttr().GetMargins().GetLeft().IsValid())
 854         marginLeft = converter.GetPixels(attr.GetTextBoxAttr().GetMargins().GetLeft());
 855     if (attr.GetTextBoxAttr().GetMargins().GetRight().IsValid())
 856         marginRight = converter.GetPixels(attr.GetTextBoxAttr().GetMargins().GetRight());
 857     if (attr.GetTextBoxAttr().GetMargins().GetTop().IsValid())
 858         marginTop = converter.GetPixels(attr.GetTextBoxAttr().GetMargins().GetTop());
 859     if (attr.GetTextBoxAttr().GetMargins().GetBottom().IsValid())
 860         marginBottom = converter.GetPixels(attr.GetTextBoxAttr().GetMargins().GetBottom());
 861
 862     if (attr.GetTextBoxAttr().GetBorder().GetLeft().GetWidth().IsValid())
 863         borderLeft = converter.GetPixels(attr.GetTextBoxAttr().GetBorder().GetLeft().GetWidth());
 864     if (attr.GetTextBoxAttr().GetBorder().GetRight().GetWidth().IsValid())
 865         borderRight = converter.GetPixels(attr.GetTextBoxAttr().GetBorder().GetRight().GetWidth());
 866     if (attr.GetTextBoxAttr().GetBorder().GetTop().GetWidth().IsValid())
 867         borderTop = converter.GetPixels(attr.GetTextBoxAttr().GetBorder().GetTop().GetWidth());
 868     if (attr.GetTextBoxAttr().GetBorder().GetBottom().GetWidth().IsValid())
 869         borderBottom = converter.GetPixels(attr.GetTextBoxAttr().GetBorder().GetBottom().GetWidth());
 870
 871     if (attr.GetTextBoxAttr().GetPadding().GetLeft().IsValid())
 872         paddingLeft = converter.GetPixels(attr.GetTextBoxAttr().GetPadding().GetLeft());
 873     if (attr.GetTextBoxAttr().GetPadding().GetRight().IsValid())
 874         paddingRight = converter.GetPixels(attr.GetTextBoxAttr().GetPadding().GetRight());
 875     if (attr.GetTextBoxAttr().GetPadding().GetTop().IsValid())
 876         paddingTop = converter.GetPixels(attr.GetTextBoxAttr().GetPadding().GetTop());
 877     if (attr.GetTextBoxAttr().GetPadding().GetBottom().IsValid())
 878         paddingBottom = converter.GetPixels(attr.GetTextBoxAttr().GetPadding().GetBottom());
 879
 880     if (attr.GetTextBoxAttr().GetOutline().GetLeft().GetWidth().IsValid())
 881         outlineLeft = converter.GetPixels(attr.GetTextBoxAttr().GetOutline().GetLeft().GetWidth());
 882     if (attr.GetTextBoxAttr().GetOutline().GetRight().GetWidth().IsValid())
 883         outlineRight = converter.GetPixels(attr.GetTextBoxAttr().GetOutline().GetRight().GetWidth());
 884     if (attr.GetTextBoxAttr().GetOutline().GetTop().GetWidth().IsValid())
 885         outlineTop = converter.GetPixels(attr.GetTextBoxAttr().GetOutline().GetTop().GetWidth());
 886     if (attr.GetTextBoxAttr().GetOutline().GetBottom().GetWidth().IsValid())
 887         outlineBottom = converter.GetPixels(attr.GetTextBoxAttr().GetOutline().GetBottom().GetWidth());
 888
 889     int leftTotal = marginLeft + borderLeft + paddingLeft;
 890     int rightTotal = marginRight + borderRight + paddingRight;
 891     int topTotal = marginTop + borderTop + paddingTop;
 892     int bottomTotal = marginBottom + borderBottom + paddingBottom;
 893
 894     if (marginRect != wxRect())
 895     {
 896         contentRect.x = marginRect.x + leftTotal;
 897         contentRect.y = marginRect.y + topTotal;
 898         contentRect.width = marginRect.width - (leftTotal + rightTotal);
 899         contentRect.height = marginRect.height - (topTotal + bottomTotal);
 900     }
 901     else
 902     {
 903         marginRect.x = contentRect.x - leftTotal;
 904         marginRect.y = contentRect.y - topTotal;
 905         marginRect.width = contentRect.width + (leftTotal + rightTotal);
 906         marginRect.height = contentRect.height + (topTotal + bottomTotal);
 907     }
 908
 909     borderRect.x = marginRect.x + marginLeft;
 910     borderRect.y = marginRect.y + marginTop;
 911     borderRect.width = marginRect.width - (marginLeft + marginRight);
 912     borderRect.height = marginRect.height - (marginTop + marginBottom);
 913
 914     paddingRect.x = marginRect.x + marginLeft + borderLeft;
 915     paddingRect.y = marginRect.y + marginTop + borderTop;
 916     paddingRect.width = marginRect.width - (marginLeft + marginRight + borderLeft + borderRight);
 917     paddingRect.height = marginRect.height - (marginTop + marginBottom + borderTop + borderBottom);
 918
 919     // The outline is outside the margin and doesn't influence the overall box position or content size.
 920     outlineRect.x = marginRect.x - outlineLeft;
 921     outlineRect.y = marginRect.y - outlineTop;
 922     outlineRect.width = marginRect.width + (outlineLeft + outlineRight);
 923     outlineRect.height = marginRect.height + (outlineTop + outlineBottom);
 924
 925     return true;
 926 }
 927
 928 // Get the total margin for the object in pixels, taking into account margin, padding and border size
 929 bool wxRichTextObject::GetTotalMargin(wxDC& dc, wxRichTextBuffer* buffer, const wxRichTextAttr& attr, int& leftMargin, int& rightMargin,
 930         int& topMargin, int& bottomMargin)
 931 {
 932     // Assume boxRect is the area around the content
 933     wxRect contentRect, marginRect, borderRect, paddingRect, outlineRect;
 934     marginRect = wxRect(0, 0, 1000, 1000);
 935
 936     GetBoxRects(dc, buffer, attr, marginRect, borderRect, contentRect, paddingRect, outlineRect);
 937
 938     leftMargin = contentRect.GetLeft() - marginRect.GetLeft();
 939     rightMargin = marginRect.GetRight() - contentRect.GetRight();
 940     topMargin = contentRect.GetTop() - marginRect.GetTop();
 941     bottomMargin = marginRect.GetBottom() - contentRect.GetBottom();
 942
 943     return true;
 944 }
 945
 946 // Returns the rectangle which the child has available to it given restrictions specified in the
 947 // child attribute, e.g. 50% width of the parent, 400 pixels, x position 20% of the parent, etc.
 948 // availableContainerSpace might be a parent that the cell has to compute its width relative to.
 949 // E.g. a cell that's 50% of its parent.
 950 wxRect wxRichTextObject::AdjustAvailableSpace(wxDC& dc, wxRichTextBuffer* buffer, const wxRichTextAttr& WXUNUSED(parentAttr), const wxRichTextAttr& childAttr, const wxRect& availableParentSpace, const wxRect& availableContainerSpace)
 951 {
 952     wxRect rect = availableParentSpace;
 953     double scale = 1.0;
 954     if (buffer)
 955         scale = buffer->GetScale();
 956
 957     wxTextAttrDimensionConverter converter(dc, scale, availableContainerSpace.GetSize());
 958
 959     if (childAttr.GetTextBoxAttr().GetWidth().IsValid())
 960         rect.width = converter.GetPixels(childAttr.GetTextBoxAttr().GetWidth());
 961
 962     if (childAttr.GetTextBoxAttr().GetHeight().IsValid())
 963         rect.height = converter.GetPixels(childAttr.GetTextBoxAttr().GetHeight());
 964
 965     // Can specify either left or right for the position (we're assuming we can't
 966     // set the left and right edges to effectively set the size. Would we want to do that?)
 967     if (childAttr.GetTextBoxAttr().GetPosition().GetLeft().IsValid())
 968     {
 969         rect.x = rect.x + converter.GetPixels(childAttr.GetTextBoxAttr().GetPosition().GetLeft());
 970     }
 971     else if (childAttr.GetTextBoxAttr().GetPosition().GetRight().IsValid())
 972     {
 973         int x = converter.GetPixels(childAttr.GetTextBoxAttr().GetPosition().GetRight());
 974         if (childAttr.GetTextBoxAttr().GetPosition().GetRight().GetPosition() == wxTEXT_BOX_ATTR_POSITION_RELATIVE)
 975             rect.x = availableContainerSpace.x + availableContainerSpace.width - rect.width;
 976         else
 977             rect.x += x;
 978     }
 979
 980     if (childAttr.GetTextBoxAttr().GetPosition().GetTop().IsValid())
 981     {
 982         rect.y = rect.y + converter.GetPixels(childAttr.GetTextBoxAttr().GetPosition().GetTop());
 983     }
 984     else if (childAttr.GetTextBoxAttr().GetPosition().GetBottom().IsValid())
 985     {
 986         int y = converter.GetPixels(childAttr.GetTextBoxAttr().GetPosition().GetBottom());
 987         if (childAttr.GetTextBoxAttr().GetPosition().GetBottom().GetPosition() == wxTEXT_BOX_ATTR_POSITION_RELATIVE)
 988             rect.y = availableContainerSpace.y + availableContainerSpace.height - rect.height;
 989         else
 990             rect.y += y;
 991     }
 992
 993     if (rect.GetWidth() > availableParentSpace.GetWidth())
 994         rect.SetWidth(availableParentSpace.GetWidth());
 995
 996     return rect;
 997 }
 998
 999 // Dump to output stream for debugging
1000 void wxRichTextObject::Dump(wxTextOutputStream& stream)
1001 {
1002     stream << GetClassInfo()->GetClassName() << wxT("\n");
1003     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");
1004     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");
1005 }
1006
1007 // Gets the containing buffer
1008 wxRichTextBuffer* wxRichTextObject::GetBuffer() const
1009 {
1010     const wxRichTextObject* obj = this;
1011     while (obj && !wxDynamicCast(obj, wxRichTextBuffer))
1012         obj = obj->GetParent();
1013     return wxDynamicCast(obj, wxRichTextBuffer);
1014 }
1015
1016 // Get the absolute object position, by traversing up the child/parent hierarchy
1017 wxPoint wxRichTextObject::GetAbsolutePosition() const
1018 {
1019     wxPoint pt = GetPosition();
1020
1021     wxRichTextObject* p = GetParent();
1022     while (p)
1023     {
1024         pt = pt + p->GetPosition();
1025         p = p->GetParent();
1026     }
1027
1028     return pt;
1029 }
1030
1031 // Hit-testing: returns a flag indicating hit test details, plus
1032 // information about position
1033 int wxRichTextObject::HitTest(wxDC& WXUNUSED(dc), wxRichTextDrawingContext& WXUNUSED(context), const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int WXUNUSED(flags))
1034 {
1035     if (!IsShown())
1036         return wxRICHTEXT_HITTEST_NONE;
1037
1038     wxRect rect = GetRect();
1039     if (pt.x >= rect.x && pt.x < rect.x + rect.width &&
1040         pt.y >= rect.y && pt.y < rect.y + rect.height)
1041     {
1042         *obj = this;
1043         *contextObj = GetParentContainer();
1044         textPosition = GetRange().GetStart();
1045         return wxRICHTEXT_HITTEST_ON;
1046     }
1047     else
1048         return wxRICHTEXT_HITTEST_NONE;
1049 }
1050
1051 // Lays out the object first with a given amount of space, and then if no width was specified in attr,
1052 // lays out the object again using the maximum ('best') size
1053 bool wxRichTextObject::LayoutToBestSize(wxDC& dc, wxRichTextDrawingContext& context, wxRichTextBuffer* buffer,
1054     const wxRichTextAttr& parentAttr, const wxRichTextAttr& attr,
1055     const wxRect& availableParentSpace, const wxRect& availableContainerSpace,
1056     int style)
1057 {
1058     wxRect availableChildRect = AdjustAvailableSpace(dc, buffer, parentAttr, attr, availableParentSpace, availableContainerSpace);
1059     wxRect originalAvailableRect = availableChildRect;
1060     Layout(dc, context, availableChildRect, availableContainerSpace, style);
1061
1062     wxSize maxSize = GetMaxSize();
1063
1064     // Don't ignore if maxSize.x is zero, since we need to redo the paragraph's lines
1065     // on this basis
1066     if (!attr.GetTextBoxAttr().GetWidth().IsValid() && maxSize.x < availableChildRect.width)
1067     {
1068         // Redo the layout with a fixed, minimum size this time.
1069         Invalidate(wxRICHTEXT_ALL);
1070         wxRichTextAttr newAttr(attr);
1071         newAttr.GetTextBoxAttr().GetWidth().SetValue(maxSize.x, wxTEXT_ATTR_UNITS_PIXELS);
1072         newAttr.GetTextBoxAttr().GetWidth().SetPosition(wxTEXT_BOX_ATTR_POSITION_ABSOLUTE);
1073
1074         availableChildRect = AdjustAvailableSpace(dc, buffer, parentAttr, newAttr, availableParentSpace, availableContainerSpace);
1075
1076         // If a paragraph, align the whole paragraph.
1077         // Problem with this: if we're limited by a floating object, a line may be centered
1078         // w.r.t. the smaller resulting box rather than the actual available width.
1079         if (attr.HasAlignment() && !GetContainer()->GetFloatCollector()->HasFloats()) // FIXME: aligning whole paragraph not compatible with floating objects
1080         {
1081             // centering, right-justification
1082             if (attr.GetAlignment() == wxTEXT_ALIGNMENT_CENTRE)
1083             {
1084                 availableChildRect.x = (originalAvailableRect.GetWidth() - availableChildRect.GetWidth())/2 + availableChildRect.x;
1085             }
1086             else if (attr.GetAlignment() == wxTEXT_ALIGNMENT_RIGHT)
1087             {
1088                 availableChildRect.x = availableChildRect.x + originalAvailableRect.GetWidth() - availableChildRect.GetWidth();
1089             }
1090         }
1091
1092         Layout(dc, context, availableChildRect, availableContainerSpace, style);
1093     }
1094
1095     /*
1096      __________________
1097     |   ____________   |
1098     |  |            |  |
1099
1100
1101     */
1102
1103     return true;
1104 }
1105
1106 // Move the object recursively, by adding the offset from old to new
1107 void wxRichTextObject::Move(const wxPoint& pt)
1108 {
1109     SetPosition(pt);
1110 }
1111
1112
1113 /*!
1114  * wxRichTextCompositeObject
1115  * This is the base for drawable objects.
1116  */
1117
1118 IMPLEMENT_CLASS(wxRichTextCompositeObject, wxRichTextObject)
1119
1120 wxRichTextCompositeObject::wxRichTextCompositeObject(wxRichTextObject* parent):
1121     wxRichTextObject(parent)
1122 {
1123 }
1124
1125 wxRichTextCompositeObject::~wxRichTextCompositeObject()
1126 {
1127     DeleteChildren();
1128 }
1129
1130 /// Get the nth child
1131 wxRichTextObject* wxRichTextCompositeObject::GetChild(size_t n) const
1132 {
1133     wxASSERT ( n < m_children.GetCount() );
1134
1135     return m_children.Item(n)->GetData();
1136 }
1137
1138 /// Append a child, returning the position
1139 size_t wxRichTextCompositeObject::AppendChild(wxRichTextObject* child)
1140 {
1141     m_children.Append(child);
1142     child->SetParent(this);
1143     return m_children.GetCount() - 1;
1144 }
1145
1146 /// Insert the child in front of the given object, or at the beginning
1147 bool wxRichTextCompositeObject::InsertChild(wxRichTextObject* child, wxRichTextObject* inFrontOf)
1148 {
1149     if (inFrontOf)
1150     {
1151         wxRichTextObjectList::compatibility_iterator node = m_children.Find(inFrontOf);
1152         m_children.Insert(node, child);
1153     }
1154     else
1155         m_children.Insert(child);
1156     child->SetParent(this);
1157
1158     return true;
1159 }
1160
1161 /// Delete the child
1162 bool wxRichTextCompositeObject::RemoveChild(wxRichTextObject* child, bool deleteChild)
1163 {
1164     wxRichTextObjectList::compatibility_iterator node = m_children.Find(child);
1165     if (node)
1166     {
1167         wxRichTextObject* obj = node->GetData();
1168         m_children.Erase(node);
1169         if (deleteChild)
1170             delete obj;
1171
1172         return true;
1173     }
1174     return false;
1175 }
1176
1177 /// Delete all children
1178 bool wxRichTextCompositeObject::DeleteChildren()
1179 {
1180     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1181     while (node)
1182     {
1183         wxRichTextObjectList::compatibility_iterator oldNode = node;
1184
1185         wxRichTextObject* child = node->GetData();
1186         child->Dereference(); // Only delete if reference count is zero
1187
1188         node = node->GetNext();
1189         m_children.Erase(oldNode);
1190     }
1191
1192     return true;
1193 }
1194
1195 /// Get the child count
1196 size_t wxRichTextCompositeObject::GetChildCount() const
1197 {
1198     return m_children.GetCount();
1199 }
1200
1201 /// Copy
1202 void wxRichTextCompositeObject::Copy(const wxRichTextCompositeObject& obj)
1203 {
1204     wxRichTextObject::Copy(obj);
1205
1206     DeleteChildren();
1207
1208     wxRichTextObjectList::compatibility_iterator node = obj.m_children.GetFirst();
1209     while (node)
1210     {
1211         wxRichTextObject* child = node->GetData();
1212         wxRichTextObject* newChild = child->Clone();
1213         newChild->SetParent(this);
1214         m_children.Append(newChild);
1215
1216         node = node->GetNext();
1217     }
1218 }
1219
1220 /// Hit-testing: returns a flag indicating hit test details, plus
1221 /// information about position
1222 int wxRichTextCompositeObject::HitTest(wxDC& dc, wxRichTextDrawingContext& context, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags)
1223 {
1224     if (!IsShown())
1225         return wxRICHTEXT_HITTEST_NONE;
1226
1227     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1228     while (node)
1229     {
1230         wxRichTextObject* child = node->GetData();
1231
1232         if (child->IsShown() && child->IsTopLevel() && (flags & wxRICHTEXT_HITTEST_NO_NESTED_OBJECTS))
1233         {
1234             // Just check if we hit the overall object
1235             int ret = child->wxRichTextObject::HitTest(dc, context, pt, textPosition, obj, contextObj, flags);
1236             if (ret != wxRICHTEXT_HITTEST_NONE)
1237                 return ret;
1238         }
1239         else if (child->IsShown())
1240         {
1241             int ret = child->HitTest(dc, context, pt, textPosition, obj, contextObj, flags);
1242             if (ret != wxRICHTEXT_HITTEST_NONE)
1243                 return ret;
1244         }
1245
1246         node = node->GetNext();
1247     }
1248
1249     return wxRICHTEXT_HITTEST_NONE;
1250 }
1251
1252 /// Finds the absolute position and row height for the given character position
1253 bool wxRichTextCompositeObject::FindPosition(wxDC& dc, wxRichTextDrawingContext& context, long index, wxPoint& pt, int* height, bool forceLineStart)
1254 {
1255     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1256     while (node)
1257     {
1258         wxRichTextObject* child = node->GetData();
1259
1260         // Don't recurse if the child is a top-level object,
1261         // such as a text box, because the character position will no longer
1262         // apply. By definition, a top-level object has its own range of
1263         // character positions.
1264         if (!child->IsTopLevel() && child->FindPosition(dc, context, index, pt, height, forceLineStart))
1265             return true;
1266
1267         node = node->GetNext();
1268     }
1269
1270     return false;
1271 }
1272
1273 /// Calculate range
1274 void wxRichTextCompositeObject::CalculateRange(long start, long& end)
1275 {
1276     long current = start;
1277     long lastEnd = current;
1278
1279     if (IsTopLevel())
1280     {
1281         current = 0;
1282         lastEnd = 0;
1283     }
1284
1285     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1286     while (node)
1287     {
1288         wxRichTextObject* child = node->GetData();
1289         long childEnd = 0;
1290
1291         child->CalculateRange(current, childEnd);
1292         lastEnd = childEnd;
1293
1294         current = childEnd + 1;
1295
1296         node = node->GetNext();
1297     }
1298
1299     if (IsTopLevel())
1300     {
1301         // A top-level object always has a range of size 1,
1302         // because its children don't count at this level.
1303         end = start;
1304         m_range.SetRange(start, start);
1305
1306         // An object with no children has zero length
1307         if (m_children.GetCount() == 0)
1308             lastEnd --;
1309         m_ownRange.SetRange(0, lastEnd);
1310     }
1311     else
1312     {
1313         end = lastEnd;
1314
1315         // An object with no children has zero length
1316         if (m_children.GetCount() == 0)
1317             end --;
1318
1319         m_range.SetRange(start, end);
1320     }
1321 }
1322
1323 /// Delete range from layout.
1324 bool wxRichTextCompositeObject::DeleteRange(const wxRichTextRange& range)
1325 {
1326     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1327
1328     while (node)
1329     {
1330         wxRichTextObject* obj = (wxRichTextObject*) node->GetData();
1331         wxRichTextObjectList::compatibility_iterator next = node->GetNext();
1332
1333         // Delete the range in each paragraph
1334
1335         // When a chunk has been deleted, internally the content does not
1336         // now match the ranges.
1337         // However, so long as deletion is not done on the same object twice this is OK.
1338         // If you may delete content from the same object twice, recalculate
1339         // the ranges inbetween DeleteRange calls by calling CalculateRanges, and
1340         // adjust the range you're deleting accordingly.
1341
1342         if (!obj->GetRange().IsOutside(range))
1343         {
1344             // No need to delete within a top-level object; just removing this object will do fine
1345             if (!obj->IsTopLevel())
1346                 obj->DeleteRange(range);
1347
1348             // Delete an empty object, or paragraph within this range.
1349             if (obj->IsEmpty() ||
1350                 (range.GetStart() <= obj->GetRange().GetStart() && range.GetEnd() >= obj->GetRange().GetEnd()))
1351             {
1352                 // An empty paragraph has length 1, so won't be deleted unless the
1353                 // whole range is deleted.
1354                 RemoveChild(obj, true);
1355             }
1356         }
1357
1358         node = next;
1359     }
1360
1361     return true;
1362 }
1363
1364 /// Get any text in this object for the given range
1365 wxString wxRichTextCompositeObject::GetTextForRange(const wxRichTextRange& range) const
1366 {
1367     wxString text;
1368     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1369     while (node)
1370     {
1371         wxRichTextObject* child = node->GetData();
1372         wxRichTextRange childRange = range;
1373         if (!child->GetRange().IsOutside(range))
1374         {
1375             childRange.LimitTo(child->GetRange());
1376
1377             wxString childText = child->GetTextForRange(childRange);
1378
1379             text += childText;
1380         }
1381         node = node->GetNext();
1382     }
1383
1384     return text;
1385 }
1386
1387 /// Get the child object at the given character position
1388 wxRichTextObject* wxRichTextCompositeObject::GetChildAtPosition(long pos) const
1389 {
1390     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1391     while (node)
1392     {
1393         wxRichTextObject* child = node->GetData();
1394         if (child->GetRange().GetStart() == pos)
1395             return child;
1396         node = node->GetNext();
1397     }
1398     return NULL;
1399 }
1400
1401 /// Recursively merge all pieces that can be merged.
1402 bool wxRichTextCompositeObject::Defragment(const wxRichTextRange& range)
1403 {
1404     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1405     while (node)
1406     {
1407         wxRichTextObject* child = node->GetData();
1408         if (range == wxRICHTEXT_ALL || !child->GetRange().IsOutside(range))
1409         {
1410             wxRichTextCompositeObject* composite = wxDynamicCast(child, wxRichTextCompositeObject);
1411             if (composite)
1412                 composite->Defragment();
1413
1414             if (node->GetNext())
1415             {
1416                 wxRichTextObject* nextChild = node->GetNext()->GetData();
1417                 if (child->CanMerge(nextChild) && child->Merge(nextChild))
1418                 {
1419                     nextChild->Dereference();
1420                     m_children.Erase(node->GetNext());
1421
1422                     // Don't set node -- we'll see if we can merge again with the next
1423                     // child.
1424                 }
1425                 else
1426                     node = node->GetNext();
1427             }
1428             else
1429                 node = node->GetNext();
1430         }
1431         else
1432             node = node->GetNext();
1433     }
1434
1435     // Delete any remaining empty objects, but leave at least one empty object per composite object.
1436     if (GetChildCount() > 1)
1437     {
1438         node = m_children.GetFirst();
1439         while (node)
1440         {
1441             wxRichTextObjectList::compatibility_iterator next = node->GetNext();
1442             wxRichTextObject* child = node->GetData();
1443             if (range == wxRICHTEXT_ALL || !child->GetRange().IsOutside(range))
1444             {
1445                 if (child->IsEmpty())
1446                 {
1447                     child->Dereference();
1448                     m_children.Erase(node);
1449                 }
1450                 node = next;
1451             }
1452             else
1453                 node = node->GetNext();
1454         }
1455     }
1456
1457     return true;
1458 }
1459
1460 /// Dump to output stream for debugging
1461 void wxRichTextCompositeObject::Dump(wxTextOutputStream& stream)
1462 {
1463     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1464     while (node)
1465     {
1466         wxRichTextObject* child = node->GetData();
1467         child->Dump(stream);
1468         node = node->GetNext();
1469     }
1470 }
1471
1472 /// Get/set the object size for the given range. Returns false if the range
1473 /// is invalid for this object.
1474 bool wxRichTextCompositeObject::GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int flags, wxPoint position, wxArrayInt* partialExtents) const
1475 {
1476     if (!range.IsWithin(GetRange()))
1477         return false;
1478
1479     wxSize sz;
1480
1481     wxArrayInt childExtents;
1482     wxArrayInt* p;
1483     if (partialExtents)
1484         p = & childExtents;
1485     else
1486         p = NULL;
1487
1488     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1489     while (node)
1490     {
1491         wxRichTextObject* child = node->GetData();
1492         if (!child->GetRange().IsOutside(range))
1493         {
1494             // Floating objects have a zero size within the paragraph.
1495             if (child->IsFloating())
1496             {
1497                 if (partialExtents)
1498                 {
1499                     int lastSize;
1500                     if (partialExtents->GetCount() > 0)
1501                         lastSize = (*partialExtents)[partialExtents->GetCount()-1];
1502                     else
1503                         lastSize = 0;
1504
1505                     partialExtents->Add(0 /* zero size */ + lastSize);
1506                 }
1507             }
1508             else
1509             {
1510                 wxSize childSize;
1511
1512                 wxRichTextRange rangeToUse = range;
1513                 rangeToUse.LimitTo(child->GetRange());
1514                 if (child->IsTopLevel())
1515                     rangeToUse = child->GetOwnRange();
1516
1517                 int childDescent = 0;
1518
1519                 // At present wxRICHTEXT_HEIGHT_ONLY is only fast if we're already cached the size,
1520                 // but it's only going to be used after caching has taken place.
1521                 if ((flags & wxRICHTEXT_HEIGHT_ONLY) && child->GetCachedSize().y != 0)
1522                 {
1523                     childDescent = child->GetDescent();
1524                     childSize = child->GetCachedSize();
1525
1526                     sz.y = wxMax(sz.y, childSize.y);
1527                     sz.x += childSize.x;
1528                     descent = wxMax(descent, childDescent);
1529                 }
1530                 else if (child->GetRangeSize(rangeToUse, childSize, childDescent, dc, context, flags, wxPoint(position.x + sz.x, position.y), p))
1531                 {
1532                     sz.y = wxMax(sz.y, childSize.y);
1533                     sz.x += childSize.x;
1534                     descent = wxMax(descent, childDescent);
1535
1536                     if ((flags & wxRICHTEXT_CACHE_SIZE) && (rangeToUse == child->GetRange() || child->IsTopLevel()))
1537                     {
1538                         child->SetCachedSize(childSize);
1539                         child->SetDescent(childDescent);
1540                     }
1541
1542                     if (partialExtents)
1543                     {
1544                         int lastSize;
1545                         if (partialExtents->GetCount() > 0)
1546                             lastSize = (*partialExtents)[partialExtents->GetCount()-1];
1547                         else
1548                             lastSize = 0;
1549
1550                         size_t i;
1551                         for (i = 0; i < childExtents.GetCount(); i++)
1552                         {
1553                             partialExtents->Add(childExtents[i] + lastSize);
1554                         }
1555                     }
1556                 }
1557             }
1558
1559             if (p)
1560                 p->Clear();
1561         }
1562
1563         node = node->GetNext();
1564     }
1565     size = sz;
1566     return true;
1567 }
1568
1569 // Invalidate the buffer. With no argument, invalidates whole buffer.
1570 void wxRichTextCompositeObject::Invalidate(const wxRichTextRange& invalidRange)
1571 {
1572     wxRichTextObject::Invalidate(invalidRange);
1573
1574     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1575     while (node)
1576     {
1577         wxRichTextObject* child = node->GetData();
1578         if (invalidRange != wxRICHTEXT_ALL && invalidRange != wxRICHTEXT_NONE && child->GetRange().IsOutside(invalidRange))
1579         {
1580             // Skip
1581         }
1582         else if (child->IsTopLevel())
1583         {
1584             if (invalidRange == wxRICHTEXT_NONE)
1585                 child->Invalidate(wxRICHTEXT_NONE);
1586             else
1587                 child->Invalidate(wxRICHTEXT_ALL); // All children must be invalidated if within parent range
1588         }
1589         else
1590             child->Invalidate(invalidRange);
1591         node = node->GetNext();
1592     }
1593 }
1594
1595 // Move the object recursively, by adding the offset from old to new
1596 void wxRichTextCompositeObject::Move(const wxPoint& pt)
1597 {
1598     wxPoint oldPos = GetPosition();
1599     SetPosition(pt);
1600     wxPoint offset = pt - oldPos;
1601
1602     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1603     while (node)
1604     {
1605         wxRichTextObject* child = node->GetData();
1606         wxPoint childPos = child->GetPosition() + offset;
1607         child->Move(childPos);
1608         node = node->GetNext();
1609     }
1610 }
1611
1612
1613 /*!
1614  * wxRichTextParagraphLayoutBox
1615  * This box knows how to lay out paragraphs.
1616  */
1617
1618 IMPLEMENT_DYNAMIC_CLASS(wxRichTextParagraphLayoutBox, wxRichTextCompositeObject)
1619
1620 wxRichTextParagraphLayoutBox::wxRichTextParagraphLayoutBox(wxRichTextObject* parent):
1621     wxRichTextCompositeObject(parent)
1622 {
1623     Init();
1624 }
1625
1626 wxRichTextParagraphLayoutBox::~wxRichTextParagraphLayoutBox()
1627 {
1628     if (m_floatCollector)
1629     {
1630         delete m_floatCollector;
1631         m_floatCollector = NULL;
1632     }
1633 }
1634
1635 /// Initialize the object.
1636 void wxRichTextParagraphLayoutBox::Init()
1637 {
1638     m_ctrl = NULL;
1639
1640     // For now, assume is the only box and has no initial size.
1641     m_range = wxRichTextRange(0, -1);
1642     m_ownRange = wxRichTextRange(0, -1);
1643
1644     m_invalidRange = wxRICHTEXT_ALL;
1645
1646     m_partialParagraph = false;
1647     m_floatCollector = NULL;
1648 }
1649
1650 void wxRichTextParagraphLayoutBox::Clear()
1651 {
1652     DeleteChildren();
1653
1654     if (m_floatCollector)
1655         delete m_floatCollector;
1656     m_floatCollector = NULL;
1657     m_partialParagraph = false;
1658 }
1659
1660 /// Copy
1661 void wxRichTextParagraphLayoutBox::Copy(const wxRichTextParagraphLayoutBox& obj)
1662 {
1663     Clear();
1664
1665     wxRichTextCompositeObject::Copy(obj);
1666
1667     m_partialParagraph = obj.m_partialParagraph;
1668     m_defaultAttributes = obj.m_defaultAttributes;
1669 }
1670
1671 // Gather information about floating objects; only gather floats for those paragraphs that
1672 // will not be formatted again due to optimization, after which floats will be gathered per-paragraph
1673 // during layout.
1674 bool wxRichTextParagraphLayoutBox::UpdateFloatingObjects(const wxRect& availableRect, wxRichTextObject* untilObj)
1675 {
1676     if (m_floatCollector != NULL)
1677         delete m_floatCollector;
1678     m_floatCollector = new wxRichTextFloatCollector(availableRect);
1679     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1680     // Only gather floats up to the point we'll start formatting paragraphs.
1681     while (untilObj && node && node->GetData() != untilObj)
1682     {
1683         wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
1684         wxASSERT (child != NULL);
1685         if (child)
1686             m_floatCollector->CollectFloat(child);
1687         node = node->GetNext();
1688     }
1689
1690     return true;
1691 }
1692
1693 // Returns the style sheet associated with the overall buffer.
1694 wxRichTextStyleSheet* wxRichTextParagraphLayoutBox::GetStyleSheet() const
1695 {
1696     return GetBuffer() ? GetBuffer()->GetStyleSheet() : (wxRichTextStyleSheet*) NULL;
1697 }
1698
1699 // Get the number of floating objects at this level
1700 int wxRichTextParagraphLayoutBox::GetFloatingObjectCount() const
1701 {
1702     if (m_floatCollector)
1703         return m_floatCollector->GetFloatingObjectCount();
1704     else
1705         return 0;
1706 }
1707
1708 // Get a list of floating objects
1709 bool wxRichTextParagraphLayoutBox::GetFloatingObjects(wxRichTextObjectList& objects) const
1710 {
1711     if (m_floatCollector)
1712     {
1713         return m_floatCollector->GetFloatingObjects(objects);
1714     }
1715     else
1716         return false;
1717 }
1718
1719 // Calculate ranges
1720 void wxRichTextParagraphLayoutBox::UpdateRanges()
1721 {
1722     long start = 0;
1723     if (GetParent())
1724         start = GetRange().GetStart();
1725     long end;
1726     CalculateRange(start, end);
1727 }
1728
1729 // HitTest
1730 int wxRichTextParagraphLayoutBox::HitTest(wxDC& dc, wxRichTextDrawingContext& context, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags)
1731 {
1732     if (!IsShown())
1733         return wxRICHTEXT_HITTEST_NONE;
1734
1735     int ret = wxRICHTEXT_HITTEST_NONE;
1736     if (m_floatCollector && (flags & wxRICHTEXT_HITTEST_NO_FLOATING_OBJECTS) == 0)
1737         ret = m_floatCollector->HitTest(dc, context, pt, textPosition, obj, flags);
1738
1739     if (ret == wxRICHTEXT_HITTEST_NONE)
1740         return wxRichTextCompositeObject::HitTest(dc, context, pt, textPosition, obj, contextObj, flags);
1741     else
1742     {
1743         *contextObj = this;
1744         return ret;
1745     }
1746 }
1747
1748 /// Draw the floating objects
1749 void wxRichTextParagraphLayoutBox::DrawFloats(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style)
1750 {
1751     if (m_floatCollector)
1752         m_floatCollector->Draw(dc, context, range, selection, rect, descent, style);
1753 }
1754
1755 void wxRichTextParagraphLayoutBox::MoveAnchoredObjectToParagraph(wxRichTextParagraph* from, wxRichTextParagraph* to, wxRichTextObject* obj)
1756 {
1757     if (from == to)
1758         return;
1759
1760     from->RemoveChild(obj);
1761     to->AppendChild(obj);
1762 }
1763
1764 /// Draw the item
1765 bool wxRichTextParagraphLayoutBox::Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style)
1766 {
1767     if (!IsShown())
1768         return true;
1769
1770     wxRect thisRect(GetPosition(), GetCachedSize());
1771
1772     wxRichTextAttr attr(GetAttributes());
1773     context.ApplyVirtualAttributes(attr, this);
1774
1775     int flags = style;
1776     if (selection.IsValid() && GetParentContainer() != this && selection.WithinSelection(GetRange().GetStart(), GetParentContainer()))
1777         flags |= wxRICHTEXT_DRAW_SELECTED;
1778
1779     // Don't draw guidelines if at top level
1780     int theseFlags = flags;
1781     if (!GetParent())
1782         theseFlags &= ~wxRICHTEXT_DRAW_GUIDELINES;
1783     DrawBoxAttributes(dc, GetBuffer(), attr, thisRect, theseFlags);
1784
1785     DrawFloats(dc, context, range, selection, rect, descent, style);
1786     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1787     while (node)
1788     {
1789         wxRichTextObject* child = node->GetData();
1790
1791         if (child && !child->GetRange().IsOutside(range))
1792         {
1793             wxRect childRect(child->GetPosition(), child->GetCachedSize());
1794             wxRichTextRange childRange = range;
1795             if (child->IsTopLevel())
1796             {
1797                 childRange = child->GetOwnRange();
1798             }
1799
1800             if (((style & wxRICHTEXT_DRAW_IGNORE_CACHE) == 0) && childRect.GetTop() > rect.GetBottom())
1801             {
1802                 // Stop drawing
1803                 break;
1804             }
1805             else if (((style & wxRICHTEXT_DRAW_IGNORE_CACHE) == 0) && childRect.GetBottom() < rect.GetTop())
1806             {
1807                 // Skip
1808             }
1809             else
1810                 child->Draw(dc, context, childRange, selection, rect, descent, style);
1811         }
1812
1813         node = node->GetNext();
1814     }
1815     return true;
1816 }
1817
1818 /// Lay the item out
1819 bool wxRichTextParagraphLayoutBox::Layout(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, const wxRect& parentRect, int style)
1820 {
1821     SetPosition(rect.GetPosition());
1822
1823     if (!IsShown())
1824         return true;
1825
1826     wxRect availableSpace;
1827     bool formatRect = (style & wxRICHTEXT_LAYOUT_SPECIFIED_RECT) == wxRICHTEXT_LAYOUT_SPECIFIED_RECT;
1828
1829     wxRichTextAttr attr(GetAttributes());
1830     context.ApplyVirtualAttributes(attr, this);
1831
1832     // If only laying out a specific area, the passed rect has a different meaning:
1833     // the visible part of the buffer. This is used in wxRichTextCtrl::OnSize,
1834     // so that during a size, only the visible part will be relaid out, or
1835     // it would take too long causing flicker. As an approximation, we assume that
1836     // everything up to the start of the visible area is laid out correctly.
1837     if (formatRect)
1838     {
1839         wxRect rect2(0, 0, rect.width, rect.height);
1840         availableSpace = GetAvailableContentArea(dc, context, rect2);
1841
1842         // Invalidate the part of the buffer from the first visible line
1843         // to the end. If other parts of the buffer are currently invalid,
1844         // then they too will be taken into account if they are above
1845         // the visible point.
1846         long startPos = 0;
1847         wxRichTextLine* line = GetLineAtYPosition(rect.y);
1848         if (line)
1849             startPos = line->GetAbsoluteRange().GetStart();
1850
1851         Invalidate(wxRichTextRange(startPos, GetOwnRange().GetEnd()));
1852     }
1853     else
1854     {
1855         availableSpace = GetAvailableContentArea(dc, context, rect);
1856     }
1857
1858     // Fix the width if we're at the top level
1859     if (!GetParent())
1860         attr.GetTextBoxAttr().GetWidth().SetValue(rect.GetWidth(), wxTEXT_ATTR_UNITS_PIXELS);
1861
1862     int leftMargin, rightMargin, topMargin, bottomMargin;
1863     wxRichTextObject::GetTotalMargin(dc, GetBuffer(), attr, leftMargin, rightMargin,
1864             topMargin, bottomMargin);
1865
1866     int maxWidth = 0;
1867     int maxHeight = 0;
1868
1869     // The maximum paragraph maximum width, so we can set the overall maximum width for this object
1870     int maxMaxWidth = 0;
1871
1872     // The maximum paragraph minimum width, so we can set the overall minimum width for this object
1873     int maxMinWidth = 0;
1874
1875     // If we have vertical alignment, we must recalculate everything.
1876     bool hasVerticalAlignment = (attr.GetTextBoxAttr().HasVerticalAlignment() &&
1877         (attr.GetTextBoxAttr().GetVerticalAlignment() > wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_TOP));
1878
1879     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
1880
1881     bool layoutAll = true;
1882
1883     // Get invalid range, rounding to paragraph start/end.
1884     wxRichTextRange invalidRange = GetInvalidRange(true);
1885
1886     if (invalidRange == wxRICHTEXT_NONE && !formatRect)
1887         return true;
1888
1889     if (invalidRange == wxRICHTEXT_ALL || hasVerticalAlignment)
1890         layoutAll = true;
1891     else    // If we know what range is affected, start laying out from that point on.
1892         if (invalidRange.GetStart() >= GetOwnRange().GetStart())
1893     {
1894         wxRichTextParagraph* firstParagraph = GetParagraphAtPosition(invalidRange.GetStart());
1895         if (firstParagraph)
1896         {
1897             wxRichTextObjectList::compatibility_iterator firstNode = m_children.Find(firstParagraph);
1898             wxRichTextObjectList::compatibility_iterator previousNode;
1899             if ( firstNode )
1900                 previousNode = firstNode->GetPrevious();
1901             if (firstNode)
1902             {
1903                 if (previousNode)
1904                 {
1905                     wxRichTextParagraph* previousParagraph = wxDynamicCast(previousNode->GetData(), wxRichTextParagraph);
1906                     availableSpace.y = previousParagraph->GetPosition().y + previousParagraph->GetCachedSize().y;
1907                 }
1908
1909                 // Now we're going to start iterating from the first affected paragraph.
1910                 node = firstNode;
1911
1912                 layoutAll = false;
1913             }
1914         }
1915     }
1916
1917     // Gather information about only those floating objects that will not be formatted,
1918     // after which floats will be gathered per-paragraph during layout.
1919     UpdateFloatingObjects(availableSpace, node ? node->GetData() : (wxRichTextObject*) NULL);
1920
1921     // A way to force speedy rest-of-buffer layout (the 'else' below)
1922     bool forceQuickLayout = false;
1923
1924     // First get the size of the paragraphs we won't be laying out
1925     wxRichTextObjectList::compatibility_iterator n = m_children.GetFirst();
1926     while (n && n != node)
1927     {
1928         wxRichTextParagraph* child = wxDynamicCast(n->GetData(), wxRichTextParagraph);
1929         if (child)
1930         {
1931             maxWidth = wxMax(maxWidth, child->GetCachedSize().x);
1932             maxMinWidth = wxMax(maxMinWidth, child->GetMinSize().x);
1933             maxMaxWidth = wxMax(maxMaxWidth, child->GetMaxSize().x);
1934         }
1935         n = n->GetNext();
1936     }
1937
1938     while (node)
1939     {
1940         // Assume this box only contains paragraphs
1941
1942         wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
1943         // Unsure if this is needed
1944         // wxCHECK_MSG( child, false, wxT("Unknown object in layout") );
1945
1946         if (child && child->IsShown())
1947         {
1948             // TODO: what if the child hasn't been laid out (e.g. involved in Undo) but still has 'old' lines
1949             if ( !forceQuickLayout &&
1950                     (layoutAll ||
1951                         child->GetLines().IsEmpty() ||
1952                             !child->GetRange().IsOutside(invalidRange)) )
1953             {
1954                 // Lays out the object first with a given amount of space, and then if no width was specified in attr,
1955                 // lays out the object again using the minimum size
1956                 child->LayoutToBestSize(dc, context, GetBuffer(),
1957                         attr, child->GetAttributes(), availableSpace, rect, style&~wxRICHTEXT_LAYOUT_SPECIFIED_RECT);
1958
1959                 // Layout must set the cached size
1960                 availableSpace.y += child->GetCachedSize().y;
1961                 maxWidth = wxMax(maxWidth, child->GetCachedSize().x);
1962                 maxMinWidth = wxMax(maxMinWidth, child->GetMinSize().x);
1963                 maxMaxWidth = wxMax(maxMaxWidth, child->GetMaxSize().x);
1964
1965                 // If we're just formatting the visible part of the buffer,
1966                 // and we're now past the bottom of the window, and we don't have any
1967                 // floating objects (since they may cause wrapping to change for the rest of the
1968                 // the buffer), start quick layout.
1969                 if (!hasVerticalAlignment && formatRect && child->GetPosition().y > rect.GetBottom() && GetFloatingObjectCount() == 0)
1970                     forceQuickLayout = true;
1971             }
1972             else
1973             {
1974                 // We're outside the immediately affected range, so now let's just
1975                 // move everything up or down. This assumes that all the children have previously
1976                 // been laid out and have wrapped line lists associated with them.
1977                 // TODO: check all paragraphs before the affected range.
1978
1979                 int inc = availableSpace.y - child->GetPosition().y;
1980
1981                 while (node)
1982                 {
1983                     wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
1984                     if (child)
1985                     {
1986                         if (child->GetLines().GetCount() == 0)
1987                         {
1988                             // Lays out the object first with a given amount of space, and then if no width was specified in attr,
1989                             // lays out the object again using the minimum size
1990                             child->LayoutToBestSize(dc, context, GetBuffer(),
1991                                         attr, child->GetAttributes(), availableSpace, rect, style&~wxRICHTEXT_LAYOUT_SPECIFIED_RECT);
1992
1993                             //child->Layout(dc, availableChildRect, style);
1994                         }
1995                         else
1996                             child->Move(wxPoint(child->GetPosition().x, child->GetPosition().y + inc));
1997
1998                         availableSpace.y += child->GetCachedSize().y;
1999                         maxWidth = wxMax(maxWidth, child->GetCachedSize().x);
2000                         maxMinWidth = wxMax(maxMinWidth, child->GetMinSize().x);
2001                         maxMaxWidth = wxMax(maxMaxWidth, child->GetMaxSize().x);
2002                     }
2003
2004                     node = node->GetNext();
2005                 }
2006                 break;
2007             }
2008         }
2009
2010         node = node->GetNext();
2011     }
2012
2013     node = m_children.GetLast();
2014     if (node && node->GetData()->IsShown())
2015     {
2016         wxRichTextObject* child = node->GetData();
2017         maxHeight = child->GetPosition().y - (GetPosition().y + topMargin) + child->GetCachedSize().y;
2018     }
2019     else
2020         maxHeight = 0; // topMargin + bottomMargin;
2021
2022     // Check the bottom edge of any floating object
2023     if (GetFloatCollector() && GetFloatCollector()->HasFloats())
2024     {
2025         int bottom = GetFloatCollector()->GetLastRectBottom();
2026         if (bottom > maxHeight)
2027             maxHeight = bottom;
2028     }
2029
2030     if (attr.GetTextBoxAttr().GetSize().GetWidth().IsValid())
2031     {
2032         wxRect r = AdjustAvailableSpace(dc, GetBuffer(), wxRichTextAttr() /* not used */, attr, parentRect, parentRect);
2033         int w = r.GetWidth();
2034
2035         // Convert external to content rect
2036         w = w - leftMargin - rightMargin;
2037         maxWidth = wxMax(maxWidth, w);
2038         maxMaxWidth = wxMax(maxMaxWidth, w);
2039     }
2040     else
2041     {
2042         // TODO: Make sure the layout box's position reflects
2043         // the position of the children, but without
2044         // breaking layout of a box within a paragraph.
2045     }
2046
2047     // TODO: (also in para layout) should set the
2048     // object's size to an absolute one if specified,
2049     // but if not specified, calculate it from content.
2050
2051     // We need to add back the margins etc.
2052     {
2053         wxRect marginRect, borderRect, contentRect, paddingRect, outlineRect;
2054         contentRect = wxRect(wxPoint(0, 0), wxSize(maxWidth, maxHeight));
2055         GetBoxRects(dc, GetBuffer(), attr, marginRect, borderRect, contentRect, paddingRect, outlineRect);
2056         SetCachedSize(marginRect.GetSize());
2057     }
2058
2059     // The maximum size is the greatest of all maximum widths for all paragraphs.
2060     {
2061         wxRect marginRect, borderRect, contentRect, paddingRect, outlineRect;
2062         contentRect = wxRect(wxPoint(0, 0), wxSize(maxMaxWidth, maxHeight)); // Actually max height is a lie, we can't know it
2063         GetBoxRects(dc, GetBuffer(), attr, marginRect, borderRect, contentRect, paddingRect, outlineRect);
2064         SetMaxSize(marginRect.GetSize());
2065     }
2066
2067     // The minimum size is the greatest of all minimum widths for all paragraphs.
2068     {
2069         wxRect marginRect, borderRect, contentRect, paddingRect, outlineRect;
2070         contentRect = wxRect(wxPoint(0, 0), wxSize(maxMinWidth, maxHeight)); // Actually max height is a lie, we can't know it
2071         GetBoxRects(dc, GetBuffer(), attr, marginRect, borderRect, contentRect, paddingRect, outlineRect);
2072         SetMinSize(marginRect.GetSize());
2073     }
2074
2075     if (attr.GetTextBoxAttr().HasVerticalAlignment() &&
2076         (attr.GetTextBoxAttr().GetVerticalAlignment() > wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_TOP))
2077     {
2078         int yOffset = 0;
2079         int leftOverSpace = availableSpace.height - topMargin - bottomMargin - maxHeight;
2080         if (leftOverSpace > 0)
2081         {
2082             if (attr.GetTextBoxAttr().GetVerticalAlignment() == wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_CENTRE)
2083             {
2084                 yOffset = (leftOverSpace/2);
2085             }
2086             else if (attr.GetTextBoxAttr().GetVerticalAlignment() == wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_BOTTOM)
2087             {
2088                 yOffset = leftOverSpace;
2089             }
2090         }
2091
2092         // Move all the children to vertically align the content
2093         // This doesn't take into account floating objects, unfortunately.
2094         if (yOffset != 0)
2095         {
2096             wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
2097             while (node)
2098             {
2099                 wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
2100                 if (child)
2101                     child->Move(wxPoint(child->GetPosition().x, child->GetPosition().y + yOffset));
2102
2103                 node = node->GetNext();
2104             }
2105         }
2106     }
2107
2108     m_invalidRange = wxRICHTEXT_NONE;
2109
2110     return true;
2111 }
2112
2113 /// Get/set the size for the given range.
2114 bool wxRichTextParagraphLayoutBox::GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int flags, wxPoint position, wxArrayInt* WXUNUSED(partialExtents)) const
2115 {
2116     wxSize sz;
2117
2118     wxRichTextObjectList::compatibility_iterator startPara = wxRichTextObjectList::compatibility_iterator();
2119     wxRichTextObjectList::compatibility_iterator endPara = wxRichTextObjectList::compatibility_iterator();
2120
2121     // First find the first paragraph whose starting position is within the range.
2122     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
2123     while (node)
2124     {
2125         // child is a paragraph
2126         wxRichTextObject* child = node->GetData();
2127         const wxRichTextRange& r = child->GetRange();
2128
2129         if (r.GetStart() <= range.GetStart() && r.GetEnd() >= range.GetStart())
2130         {
2131             startPara = node;
2132             break;
2133         }
2134
2135         node = node->GetNext();
2136     }
2137
2138     // Next find the last paragraph containing part of the range
2139     node = m_children.GetFirst();
2140     while (node)
2141     {
2142         // child is a paragraph
2143         wxRichTextObject* child = node->GetData();
2144         const wxRichTextRange& r = child->GetRange();
2145
2146         if (r.GetStart() <= range.GetEnd() && r.GetEnd() >= range.GetEnd())
2147         {
2148             endPara = node;
2149             break;
2150         }
2151
2152         node = node->GetNext();
2153     }
2154
2155     if (!startPara || !endPara)
2156         return false;
2157
2158     // Now we can add up the sizes
2159     for (node = startPara; node ; node = node->GetNext())
2160     {
2161         // child is a paragraph
2162         wxRichTextObject* child = node->GetData();
2163         const wxRichTextRange& childRange = child->GetRange();
2164         wxRichTextRange rangeToFind = range;
2165         rangeToFind.LimitTo(childRange);
2166
2167         if (child->IsTopLevel())
2168             rangeToFind = child->GetOwnRange();
2169
2170         wxSize childSize;
2171
2172         int childDescent = 0;
2173         child->GetRangeSize(rangeToFind, childSize, childDescent, dc, context, flags, position);
2174
2175         descent = wxMax(childDescent, descent);
2176
2177         sz.x = wxMax(sz.x, childSize.x);
2178         sz.y += childSize.y;
2179
2180         if (node == endPara)
2181             break;
2182     }
2183
2184     size = sz;
2185
2186     return true;
2187 }
2188
2189 /// Get the paragraph at the given position
2190 wxRichTextParagraph* wxRichTextParagraphLayoutBox::GetParagraphAtPosition(long pos, bool caretPosition) const
2191 {
2192     if (caretPosition)
2193         pos ++;
2194
2195     // First find the first paragraph whose starting position is within the range.
2196     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
2197     while (node)
2198     {
2199         // child is a paragraph
2200         wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
2201         // wxASSERT (child != NULL);
2202
2203         if (child)
2204         {
2205             // Return first child in buffer if position is -1
2206             // if (pos == -1)
2207             //    return child;
2208
2209             if (child->GetRange().Contains(pos))
2210                 return child;
2211         }
2212
2213         node = node->GetNext();
2214     }
2215     return NULL;
2216 }
2217
2218 /// Get the line at the given position
2219 wxRichTextLine* wxRichTextParagraphLayoutBox::GetLineAtPosition(long pos, bool caretPosition) const
2220 {
2221     if (caretPosition)
2222         pos ++;
2223
2224     // First find the first paragraph whose starting position is within the range.
2225     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
2226     while (node)
2227     {
2228         wxRichTextObject* obj = (wxRichTextObject*) node->GetData();
2229         if (obj->GetRange().Contains(pos))
2230         {
2231             // child is a paragraph
2232             wxRichTextParagraph* child = wxDynamicCast(obj, wxRichTextParagraph);
2233             // wxASSERT (child != NULL);
2234
2235             if (child)
2236             {
2237                 wxRichTextLineList::compatibility_iterator node2 = child->GetLines().GetFirst();
2238                 while (node2)
2239                 {
2240                     wxRichTextLine* line = node2->GetData();
2241
2242                     wxRichTextRange range = line->GetAbsoluteRange();
2243
2244                     if (range.Contains(pos) ||
2245
2246                         // If the position is end-of-paragraph, then return the last line of
2247                         // of the paragraph.
2248                         ((range.GetEnd() == child->GetRange().GetEnd()-1) && (pos == child->GetRange().GetEnd())))
2249                         return line;
2250
2251                     node2 = node2->GetNext();
2252                 }
2253             }
2254         }
2255
2256         node = node->GetNext();
2257     }
2258
2259     int lineCount = GetLineCount();
2260     if (lineCount > 0)
2261         return GetLineForVisibleLineNumber(lineCount-1);
2262     else
2263         return NULL;
2264 }
2265
2266 /// Get the line at the given y pixel position, or the last line.
2267 wxRichTextLine* wxRichTextParagraphLayoutBox::GetLineAtYPosition(int y) const
2268 {
2269     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
2270     while (node)
2271     {
2272         wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
2273         // wxASSERT (child != NULL);
2274
2275         if (child)
2276         {
2277             wxRichTextLineList::compatibility_iterator node2 = child->GetLines().GetFirst();
2278             while (node2)
2279             {
2280                 wxRichTextLine* line = node2->GetData();
2281
2282                 wxRect rect(line->GetRect());
2283
2284                 if (y <= rect.GetBottom())
2285                     return line;
2286
2287                 node2 = node2->GetNext();
2288             }
2289         }
2290
2291         node = node->GetNext();
2292     }
2293
2294     // Return last line
2295     int lineCount = GetLineCount();
2296     if (lineCount > 0)
2297         return GetLineForVisibleLineNumber(lineCount-1);
2298     else
2299         return NULL;
2300 }
2301
2302 /// Get the number of visible lines
2303 int wxRichTextParagraphLayoutBox::GetLineCount() const
2304 {
2305     int count = 0;
2306
2307     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
2308     while (node)
2309     {
2310         wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
2311         // wxASSERT (child != NULL);
2312
2313         if (child)
2314             count += child->GetLines().GetCount();
2315
2316         node = node->GetNext();
2317     }
2318     return count;
2319 }
2320
2321
2322 /// Get the paragraph for a given line
2323 wxRichTextParagraph* wxRichTextParagraphLayoutBox::GetParagraphForLine(wxRichTextLine* line) const
2324 {
2325     return GetParagraphAtPosition(line->GetAbsoluteRange().GetStart());
2326 }
2327
2328 /// Get the line size at the given position
2329 wxSize wxRichTextParagraphLayoutBox::GetLineSizeAtPosition(long pos, bool caretPosition) const
2330 {
2331     wxRichTextLine* line = GetLineAtPosition(pos, caretPosition);
2332     if (line)
2333     {
2334         return line->GetSize();
2335     }
2336     else
2337         return wxSize(0, 0);
2338 }
2339
2340
2341 /// Convenience function to add a paragraph of text
2342 wxRichTextRange wxRichTextParagraphLayoutBox::AddParagraph(const wxString& text, wxRichTextAttr* paraStyle)
2343 {
2344     // Don't use the base style, just the default style, and the base style will
2345     // be combined at display time.
2346     // Divide into paragraph and character styles.
2347
2348     wxRichTextAttr defaultCharStyle;
2349     wxRichTextAttr defaultParaStyle;
2350
2351     // If the default style is a named paragraph style, don't apply any character formatting
2352     // to the initial text string.
2353     if (GetDefaultStyle().HasParagraphStyleName() && GetStyleSheet())
2354     {
2355         wxRichTextParagraphStyleDefinition* def = GetStyleSheet()->FindParagraphStyle(GetDefaultStyle().GetParagraphStyleName());
2356         if (def)
2357             defaultParaStyle = def->GetStyleMergedWithBase(GetStyleSheet());
2358     }
2359     else
2360         wxRichTextSplitParaCharStyles(GetDefaultStyle(), defaultParaStyle, defaultCharStyle);
2361
2362     wxRichTextAttr* pStyle = paraStyle ? paraStyle : (wxRichTextAttr*) & defaultParaStyle;
2363     wxRichTextAttr* cStyle = & defaultCharStyle;
2364
2365     wxRichTextParagraph* para = new wxRichTextParagraph(text, this, pStyle, cStyle);
2366     para->GetAttributes().GetTextBoxAttr().Reset();
2367
2368     AppendChild(para);
2369
2370     UpdateRanges();
2371
2372     return para->GetRange();
2373 }
2374
2375 /// Adds multiple paragraphs, based on newlines.
2376 wxRichTextRange wxRichTextParagraphLayoutBox::AddParagraphs(const wxString& text, wxRichTextAttr* paraStyle)
2377 {
2378     // Don't use the base style, just the default style, and the base style will
2379     // be combined at display time.
2380     // Divide into paragraph and character styles.
2381
2382     wxRichTextAttr defaultCharStyle;
2383     wxRichTextAttr defaultParaStyle;
2384
2385     // If the default style is a named paragraph style, don't apply any character formatting
2386     // to the initial text string.
2387     if (GetDefaultStyle().HasParagraphStyleName() && GetStyleSheet())
2388     {
2389         wxRichTextParagraphStyleDefinition* def = GetStyleSheet()->FindParagraphStyle(GetDefaultStyle().GetParagraphStyleName());
2390         if (def)
2391             defaultParaStyle = def->GetStyleMergedWithBase(GetStyleSheet());
2392     }
2393     else
2394         wxRichTextSplitParaCharStyles(GetDefaultStyle(), defaultParaStyle, defaultCharStyle);
2395
2396     wxRichTextAttr* pStyle = paraStyle ? paraStyle : (wxRichTextAttr*) & defaultParaStyle;
2397     wxRichTextAttr* cStyle = & defaultCharStyle;
2398
2399     wxRichTextParagraph* firstPara = NULL;
2400     wxRichTextParagraph* lastPara = NULL;
2401
2402     wxRichTextRange range(-1, -1);
2403
2404     size_t i = 0;
2405     size_t len = text.length();
2406     wxString line;
2407     wxRichTextParagraph* para = new wxRichTextParagraph(wxEmptyString, this, pStyle, cStyle);
2408     para->GetAttributes().GetTextBoxAttr().Reset();
2409
2410     AppendChild(para);
2411
2412     firstPara = para;
2413     lastPara = para;
2414
2415     while (i < len)
2416     {
2417         wxChar ch = text[i];
2418         if (ch == wxT('\n') || ch == wxT('\r'))
2419         {
2420             if (i != (len-1))
2421             {
2422                 wxRichTextPlainText* plainText = (wxRichTextPlainText*) para->GetChildren().GetFirst()->GetData();
2423                 plainText->SetText(line);
2424
2425                 para = new wxRichTextParagraph(wxEmptyString, this, pStyle, cStyle);
2426                 para->GetAttributes().GetTextBoxAttr().Reset();
2427
2428                 AppendChild(para);
2429
2430                 lastPara = para;
2431                 line = wxEmptyString;
2432             }
2433         }
2434         else
2435             line += ch;
2436
2437         i ++;
2438     }
2439
2440     if (!line.empty())
2441     {
2442         wxRichTextPlainText* plainText = (wxRichTextPlainText*) para->GetChildren().GetFirst()->GetData();
2443         plainText->SetText(line);
2444     }
2445
2446     UpdateRanges();
2447
2448     return wxRichTextRange(firstPara->GetRange().GetStart(), lastPara->GetRange().GetEnd());
2449 }
2450
2451 /// Convenience function to add an image
2452 wxRichTextRange wxRichTextParagraphLayoutBox::AddImage(const wxImage& image, wxRichTextAttr* paraStyle)
2453 {
2454     // Don't use the base style, just the default style, and the base style will
2455     // be combined at display time.
2456     // Divide into paragraph and character styles.
2457
2458     wxRichTextAttr defaultCharStyle;
2459     wxRichTextAttr defaultParaStyle;
2460
2461     // If the default style is a named paragraph style, don't apply any character formatting
2462     // to the initial text string.
2463     if (GetDefaultStyle().HasParagraphStyleName() && GetStyleSheet())
2464     {
2465         wxRichTextParagraphStyleDefinition* def = GetStyleSheet()->FindParagraphStyle(GetDefaultStyle().GetParagraphStyleName());
2466         if (def)
2467             defaultParaStyle = def->GetStyleMergedWithBase(GetStyleSheet());
2468     }
2469     else
2470         wxRichTextSplitParaCharStyles(GetDefaultStyle(), defaultParaStyle, defaultCharStyle);
2471
2472     wxRichTextAttr* pStyle = paraStyle ? paraStyle : (wxRichTextAttr*) & defaultParaStyle;
2473     wxRichTextAttr* cStyle = & defaultCharStyle;
2474
2475     wxRichTextParagraph* para = new wxRichTextParagraph(this, pStyle);
2476     para->GetAttributes().GetTextBoxAttr().Reset();
2477     AppendChild(para);
2478     para->AppendChild(new wxRichTextImage(image, this, cStyle));
2479
2480     UpdateRanges();
2481
2482     return para->GetRange();
2483 }
2484
2485
2486 /// Insert fragment into this box at the given position. If partialParagraph is true,
2487 /// it is assumed that the last (or only) paragraph is just a piece of data with no paragraph
2488 /// marker.
2489
2490 bool wxRichTextParagraphLayoutBox::InsertFragment(long position, wxRichTextParagraphLayoutBox& fragment)
2491 {
2492     // First, find the first paragraph whose starting position is within the range.
2493     wxRichTextParagraph* para = GetParagraphAtPosition(position);
2494     if (para)
2495     {
2496         wxRichTextAttr originalAttr = para->GetAttributes();
2497
2498         wxRichTextObjectList::compatibility_iterator node = m_children.Find(para);
2499
2500         // Now split at this position, returning the object to insert the new
2501         // ones in front of.
2502         wxRichTextObject* nextObject = para->SplitAt(position);
2503
2504         // Special case: partial paragraph, just one paragraph. Might be a small amount of
2505         // text, for example, so let's optimize.
2506
2507         if (fragment.GetPartialParagraph() && fragment.GetChildren().GetCount() == 1)
2508         {
2509             // Add the first para to this para...
2510             wxRichTextObjectList::compatibility_iterator firstParaNode = fragment.GetChildren().GetFirst();
2511             if (!firstParaNode)
2512                 return false;
2513
2514             // Iterate through the fragment paragraph inserting the content into this paragraph.
2515             wxRichTextParagraph* firstPara = wxDynamicCast(firstParaNode->GetData(), wxRichTextParagraph);
2516             wxASSERT (firstPara != NULL);
2517
2518             wxRichTextObjectList::compatibility_iterator objectNode = firstPara->GetChildren().GetFirst();
2519             while (objectNode)
2520             {
2521                 wxRichTextObject* newObj = objectNode->GetData()->Clone();
2522
2523                 if (!nextObject)
2524                 {
2525                     // Append
2526                     para->AppendChild(newObj);
2527                 }
2528                 else
2529                 {
2530                     // Insert before nextObject
2531                     para->InsertChild(newObj, nextObject);
2532                 }
2533
2534                 objectNode = objectNode->GetNext();
2535             }
2536
2537             return true;
2538         }
2539         else
2540         {
2541             // Procedure for inserting a fragment consisting of a number of
2542             // paragraphs:
2543             //
2544             // 1. Remove and save the content that's after the insertion point, for adding
2545             //    back once we've added the fragment.
2546             // 2. Add the content from the first fragment paragraph to the current
2547             //    paragraph.
2548             // 3. Add remaining fragment paragraphs after the current paragraph.
2549             // 4. Add back the saved content from the first paragraph. If partialParagraph
2550             //    is true, add it to the last paragraph added and not a new one.
2551
2552             // 1. Remove and save objects after split point.
2553             wxList savedObjects;
2554             if (nextObject)
2555                 para->MoveToList(nextObject, savedObjects);
2556
2557             // 2. Add the content from the 1st fragment paragraph.
2558             wxRichTextObjectList::compatibility_iterator firstParaNode = fragment.GetChildren().GetFirst();
2559             if (!firstParaNode)
2560                 return false;
2561
2562             wxRichTextParagraph* firstPara = wxDynamicCast(firstParaNode->GetData(), wxRichTextParagraph);
2563             wxASSERT(firstPara != NULL);
2564
2565             if (!(fragment.GetAttributes().GetFlags() & wxTEXT_ATTR_KEEP_FIRST_PARA_STYLE))
2566                 para->SetAttributes(firstPara->GetAttributes());
2567
2568             // Save empty paragraph attributes for appending later
2569             // These are character attributes deliberately set for a new paragraph. Without this,
2570             // we couldn't pass default attributes when appending a new paragraph.
2571             wxRichTextAttr emptyParagraphAttributes;
2572
2573             wxRichTextObjectList::compatibility_iterator objectNode = firstPara->GetChildren().GetFirst();
2574
2575             if (objectNode && firstPara->GetChildren().GetCount() == 1 && objectNode->GetData()->IsEmpty())
2576                 emptyParagraphAttributes = objectNode->GetData()->GetAttributes();
2577
2578             while (objectNode)
2579             {
2580                 wxRichTextObject* newObj = objectNode->GetData()->Clone();
2581
2582                 // Append
2583                 para->AppendChild(newObj);
2584
2585                 objectNode = objectNode->GetNext();
2586             }
2587
2588             // 3. Add remaining fragment paragraphs after the current paragraph.
2589             wxRichTextObjectList::compatibility_iterator nextParagraphNode = node->GetNext();
2590             wxRichTextObject* nextParagraph = NULL;
2591             if (nextParagraphNode)
2592                 nextParagraph = nextParagraphNode->GetData();
2593
2594             wxRichTextObjectList::compatibility_iterator i = fragment.GetChildren().GetFirst()->GetNext();
2595             wxRichTextParagraph* finalPara = para;
2596
2597             bool needExtraPara = (!i || !fragment.GetPartialParagraph());
2598
2599             // If there was only one paragraph, we need to insert a new one.
2600             while (i)
2601             {
2602                 wxRichTextParagraph* para = wxDynamicCast(i->GetData(), wxRichTextParagraph);
2603                 wxASSERT( para != NULL );
2604
2605                 finalPara = (wxRichTextParagraph*) para->Clone();
2606
2607                 if (nextParagraph)
2608                     InsertChild(finalPara, nextParagraph);
2609                 else
2610                     AppendChild(finalPara);
2611
2612                 i = i->GetNext();
2613             }
2614
2615             // If there was only one paragraph, or we have full paragraphs in our fragment,
2616             // we need to insert a new one.
2617             if (needExtraPara)
2618             {
2619                 finalPara = new wxRichTextParagraph;
2620
2621                 if (nextParagraph)
2622                     InsertChild(finalPara, nextParagraph);
2623                 else
2624                     AppendChild(finalPara);
2625             }
2626
2627             // 4. Add back the remaining content.
2628             if (finalPara)
2629             {
2630                 if (nextObject)
2631                     finalPara->MoveFromList(savedObjects);
2632
2633                 // Ensure there's at least one object
2634                 if (finalPara->GetChildCount() == 0)
2635                 {
2636                     wxRichTextPlainText* text = new wxRichTextPlainText(wxEmptyString);
2637                     text->SetAttributes(emptyParagraphAttributes);
2638
2639                     finalPara->AppendChild(text);
2640                 }
2641             }
2642
2643             if ((fragment.GetAttributes().GetFlags() & wxTEXT_ATTR_KEEP_FIRST_PARA_STYLE) && firstPara)
2644                 finalPara->SetAttributes(firstPara->GetAttributes());
2645             else if (finalPara && finalPara != para)
2646                 finalPara->SetAttributes(originalAttr);
2647
2648             return true;
2649         }
2650     }
2651     else
2652     {
2653         // Append
2654         wxRichTextObjectList::compatibility_iterator i = fragment.GetChildren().GetFirst();
2655         while (i)
2656         {
2657             wxRichTextParagraph* para = wxDynamicCast(i->GetData(), wxRichTextParagraph);
2658             wxASSERT( para != NULL );
2659
2660             AppendChild(para->Clone());
2661
2662             i = i->GetNext();
2663         }
2664
2665         return true;
2666     }
2667 }
2668
2669 /// Make a copy of the fragment corresponding to the given range, putting it in 'fragment'.
2670 /// If there was an incomplete paragraph at the end, partialParagraph is set to true.
2671 bool wxRichTextParagraphLayoutBox::CopyFragment(const wxRichTextRange& range, wxRichTextParagraphLayoutBox& fragment)
2672 {
2673     wxRichTextObjectList::compatibility_iterator i = GetChildren().GetFirst();
2674     while (i)
2675     {
2676         wxRichTextParagraph* para = wxDynamicCast(i->GetData(), wxRichTextParagraph);
2677         wxASSERT( para != NULL );
2678
2679         if (!para->GetRange().IsOutside(range))
2680         {
2681             fragment.AppendChild(para->Clone());
2682         }
2683         i = i->GetNext();
2684     }
2685
2686     // Now top and tail the first and last paragraphs in our new fragment (which might be the same).
2687     if (!fragment.IsEmpty())
2688     {
2689         wxRichTextParagraph* firstPara = wxDynamicCast(fragment.GetChildren().GetFirst()->GetData(), wxRichTextParagraph);
2690         wxASSERT( firstPara != NULL );
2691
2692         wxRichTextParagraph* lastPara = wxDynamicCast(fragment.GetChildren().GetLast()->GetData(), wxRichTextParagraph);
2693         wxASSERT( lastPara != NULL );
2694
2695         if (!firstPara || !lastPara)
2696             return false;
2697
2698         bool isFragment = (range.GetEnd() < lastPara->GetRange().GetEnd());
2699
2700         long firstPos = firstPara->GetRange().GetStart();
2701
2702         // Adjust for renumbering from zero
2703         wxRichTextRange topTailRange(range.GetStart() - firstPos, range.GetEnd() - firstPos);
2704
2705         long end;
2706         fragment.CalculateRange(0, end);
2707
2708         // Chop off the start of the paragraph
2709         if (topTailRange.GetStart() > 0)
2710         {
2711             wxRichTextRange r(0, topTailRange.GetStart()-1);
2712             firstPara->DeleteRange(r);
2713
2714             // Make sure the numbering is correct
2715             fragment.CalculateRange(0, end);
2716
2717             // Now, we've deleted some positions, so adjust the range
2718             // accordingly.
2719             topTailRange.SetStart(range.GetLength());
2720             topTailRange.SetEnd(fragment.GetOwnRange().GetEnd());
2721         }
2722         else
2723         {
2724             topTailRange.SetStart(range.GetLength());
2725             topTailRange.SetEnd(fragment.GetOwnRange().GetEnd());
2726         }
2727
2728         if (topTailRange.GetStart() < lastPara->GetRange().GetEnd())
2729         {
2730             lastPara->DeleteRange(topTailRange);
2731
2732             // Make sure the numbering is correct
2733             long end;
2734             fragment.CalculateRange(0, end);
2735
2736             // We only have part of a paragraph at the end
2737             fragment.SetPartialParagraph(true);
2738         }
2739         else
2740         {
2741             // We have a partial paragraph (don't save last new paragraph marker)
2742             // or complete paragraph
2743             fragment.SetPartialParagraph(isFragment);
2744         }
2745     }
2746
2747     return true;
2748 }
2749
2750 /// Given a position, get the number of the visible line (potentially many to a paragraph),
2751 /// starting from zero at the start of the buffer.
2752 long wxRichTextParagraphLayoutBox::GetVisibleLineNumber(long pos, bool caretPosition, bool startOfLine) const
2753 {
2754     if (caretPosition)
2755         pos ++;
2756
2757     int lineCount = 0;
2758
2759     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
2760     while (node)
2761     {
2762         wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
2763         // wxASSERT( child != NULL );
2764
2765         if (child)
2766         {
2767             if (child->GetRange().Contains(pos))
2768             {
2769                 wxRichTextLineList::compatibility_iterator node2 = child->GetLines().GetFirst();
2770                 while (node2)
2771                 {
2772                     wxRichTextLine* line = node2->GetData();
2773                     wxRichTextRange lineRange = line->GetAbsoluteRange();
2774
2775                     if (lineRange.Contains(pos) || pos == lineRange.GetStart())
2776                     {
2777                         // If the caret is displayed at the end of the previous wrapped line,
2778                         // we want to return the line it's _displayed_ at (not the actual line
2779                         // containing the position).
2780                         if (lineRange.GetStart() == pos && !startOfLine && child->GetRange().GetStart() != pos)
2781                             return lineCount - 1;
2782                         else
2783                             return lineCount;
2784                     }
2785
2786                     lineCount ++;
2787
2788                     node2 = node2->GetNext();
2789                 }
2790                 // If we didn't find it in the lines, it must be
2791                 // the last position of the paragraph. So return the last line.
2792                 return lineCount-1;
2793             }
2794             else
2795                 lineCount += child->GetLines().GetCount();
2796         }
2797
2798         node = node->GetNext();
2799     }
2800
2801     // Not found
2802     return -1;
2803 }
2804
2805 /// Given a line number, get the corresponding wxRichTextLine object.
2806 wxRichTextLine* wxRichTextParagraphLayoutBox::GetLineForVisibleLineNumber(long lineNumber) const
2807 {
2808     int lineCount = 0;
2809
2810     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
2811     while (node)
2812     {
2813         wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
2814         // wxASSERT(child != NULL);
2815
2816         if (child)
2817         {
2818             if (lineNumber < (int) (child->GetLines().GetCount() + lineCount))
2819             {
2820                 wxRichTextLineList::compatibility_iterator node2 = child->GetLines().GetFirst();
2821                 while (node2)
2822                 {
2823                     wxRichTextLine* line = node2->GetData();
2824
2825                     if (lineCount == lineNumber)
2826                         return line;
2827
2828                     lineCount ++;
2829
2830                     node2 = node2->GetNext();
2831                 }
2832             }
2833             else
2834                 lineCount += child->GetLines().GetCount();
2835         }
2836
2837         node = node->GetNext();
2838     }
2839
2840     // Didn't find it
2841     return NULL;
2842 }
2843
2844 /// Delete range from layout.
2845 bool wxRichTextParagraphLayoutBox::DeleteRange(const wxRichTextRange& range)
2846 {
2847     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
2848
2849     wxRichTextParagraph* firstPara = NULL;
2850     while (node)
2851     {
2852         wxRichTextParagraph* obj = wxDynamicCast(node->GetData(), wxRichTextParagraph);
2853         // wxASSERT (obj != NULL);
2854
2855         wxRichTextObjectList::compatibility_iterator next = node->GetNext();
2856
2857         if (obj)
2858         {
2859             // Delete the range in each paragraph
2860
2861             if (!obj->GetRange().IsOutside(range))
2862             {
2863                 // Deletes the content of this object within the given range
2864                 obj->DeleteRange(range);
2865
2866                 wxRichTextRange thisRange = obj->GetRange();
2867                 wxRichTextAttr thisAttr = obj->GetAttributes();
2868
2869                 // If the whole paragraph is within the range to delete,
2870                 // delete the whole thing.
2871                 if (range.GetStart() <= thisRange.GetStart() && range.GetEnd() >= thisRange.GetEnd())
2872                 {
2873                     // Delete the whole object
2874                     RemoveChild(obj, true);
2875                     obj = NULL;
2876                 }
2877                 else if (!firstPara)
2878                     firstPara = obj;
2879
2880                 // If the range includes the paragraph end, we need to join this
2881                 // and the next paragraph.
2882                 if (range.GetEnd() <= thisRange.GetEnd())
2883                 {
2884                     // We need to move the objects from the next paragraph
2885                     // to this paragraph
2886
2887                     wxRichTextParagraph* nextParagraph = NULL;
2888                     if ((range.GetEnd() < thisRange.GetEnd()) && obj)
2889                         nextParagraph = obj;
2890                     else
2891                     {
2892                         // We're ending at the end of the paragraph, so merge the _next_ paragraph.
2893                         if (next)
2894                             nextParagraph = wxDynamicCast(next->GetData(), wxRichTextParagraph);
2895                     }
2896
2897                     bool applyFinalParagraphStyle = firstPara && nextParagraph && nextParagraph != firstPara;
2898
2899                     wxRichTextAttr nextParaAttr;
2900                     if (applyFinalParagraphStyle)
2901                     {
2902                         // Special case when deleting the end of a paragraph - use _this_ paragraph's style,
2903                         // not the next one.
2904                         if (range.GetStart() == range.GetEnd() && range.GetStart() == thisRange.GetEnd())
2905                             nextParaAttr = thisAttr;
2906                         else
2907                             nextParaAttr = nextParagraph->GetAttributes();
2908                     }
2909
2910                     if (firstPara && nextParagraph && firstPara != nextParagraph)
2911                     {
2912                         // Move the objects to the previous para
2913                         wxRichTextObjectList::compatibility_iterator node1 = nextParagraph->GetChildren().GetFirst();
2914
2915                         while (node1)
2916                         {
2917                             wxRichTextObject* obj1 = node1->GetData();
2918
2919                             firstPara->AppendChild(obj1);
2920
2921                             wxRichTextObjectList::compatibility_iterator next1 = node1->GetNext();
2922                             nextParagraph->GetChildren().Erase(node1);
2923
2924                             node1 = next1;
2925                         }
2926
2927                         // Delete the paragraph
2928                         RemoveChild(nextParagraph, true);
2929                     }
2930
2931                     // Avoid empty paragraphs
2932                     if (firstPara && firstPara->GetChildren().GetCount() == 0)
2933                     {
2934                         wxRichTextPlainText* text = new wxRichTextPlainText(wxEmptyString);
2935                         firstPara->AppendChild(text);
2936                     }
2937
2938                     if (applyFinalParagraphStyle)
2939                         firstPara->SetAttributes(nextParaAttr);
2940
2941                     return true;
2942                 }
2943             }
2944         }
2945
2946         node = next;
2947     }
2948
2949     return true;
2950 }
2951
2952 /// Get any text in this object for the given range
2953 wxString wxRichTextParagraphLayoutBox::GetTextForRange(const wxRichTextRange& range) const
2954 {
2955     int lineCount = 0;
2956     wxString text;
2957     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
2958     while (node)
2959     {
2960         wxRichTextObject* child = node->GetData();
2961         if (!child->GetRange().IsOutside(range))
2962         {
2963             wxRichTextRange childRange = range;
2964             childRange.LimitTo(child->GetRange());
2965
2966             wxString childText = child->GetTextForRange(childRange);
2967
2968             text += childText;
2969
2970             if ((childRange.GetEnd() == child->GetRange().GetEnd()) && node->GetNext())
2971                 text += wxT("\n");
2972
2973             lineCount ++;
2974         }
2975         node = node->GetNext();
2976     }
2977
2978     return text;
2979 }
2980
2981 /// Get all the text
2982 wxString wxRichTextParagraphLayoutBox::GetText() const
2983 {
2984     return GetTextForRange(GetOwnRange());
2985 }
2986
2987 /// Get the paragraph by number
2988 wxRichTextParagraph* wxRichTextParagraphLayoutBox::GetParagraphAtLine(long paragraphNumber) const
2989 {
2990     if ((size_t) paragraphNumber >= GetChildCount())
2991         return NULL;
2992
2993     return (wxRichTextParagraph*) GetChild((size_t) paragraphNumber);
2994 }
2995
2996 /// Get the length of the paragraph
2997 int wxRichTextParagraphLayoutBox::GetParagraphLength(long paragraphNumber) const
2998 {
2999     wxRichTextParagraph* para = GetParagraphAtLine(paragraphNumber);
3000     if (para)
3001         return para->GetRange().GetLength() - 1; // don't include newline
3002     else
3003         return 0;
3004 }
3005
3006 /// Get the text of the paragraph
3007 wxString wxRichTextParagraphLayoutBox::GetParagraphText(long paragraphNumber) const
3008 {
3009     wxRichTextParagraph* para = GetParagraphAtLine(paragraphNumber);
3010     if (para)
3011         return para->GetTextForRange(para->GetRange());
3012     else
3013         return wxEmptyString;
3014 }
3015
3016 /// Convert zero-based line column and paragraph number to a position.
3017 long wxRichTextParagraphLayoutBox::XYToPosition(long x, long y) const
3018 {
3019     wxRichTextParagraph* para = GetParagraphAtLine(y);
3020     if (para)
3021     {
3022         return para->GetRange().GetStart() + x;
3023     }
3024     else
3025         return -1;
3026 }
3027
3028 /// Convert zero-based position to line column and paragraph number
3029 bool wxRichTextParagraphLayoutBox::PositionToXY(long pos, long* x, long* y) const
3030 {
3031     wxRichTextParagraph* para = GetParagraphAtPosition(pos);
3032     if (para)
3033     {
3034         int count = 0;
3035         wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
3036         while (node)
3037         {
3038             wxRichTextObject* child = node->GetData();
3039             if (child == para)
3040                 break;
3041             count ++;
3042             node = node->GetNext();
3043         }
3044
3045         *y = count;
3046         *x = pos - para->GetRange().GetStart();
3047
3048         return true;
3049     }
3050     else
3051         return false;
3052 }
3053
3054 /// Get the leaf object in a paragraph at this position.
3055 /// Given a line number, get the corresponding wxRichTextLine object.
3056 wxRichTextObject* wxRichTextParagraphLayoutBox::GetLeafObjectAtPosition(long position) const
3057 {
3058     wxRichTextParagraph* para = GetParagraphAtPosition(position);
3059     if (para)
3060     {
3061         wxRichTextObjectList::compatibility_iterator node = para->GetChildren().GetFirst();
3062
3063         while (node)
3064         {
3065             wxRichTextObject* child = node->GetData();
3066             if (child->GetRange().Contains(position))
3067                 return child;
3068
3069             node = node->GetNext();
3070         }
3071         if (position == para->GetRange().GetEnd() && para->GetChildCount() > 0)
3072             return para->GetChildren().GetLast()->GetData();
3073     }
3074     return NULL;
3075 }
3076
3077 /// Set character or paragraph text attributes: apply character styles only to immediate text nodes
3078 bool wxRichTextParagraphLayoutBox::SetStyle(const wxRichTextRange& range, const wxRichTextAttr& style, int flags)
3079 {
3080     bool characterStyle = false;
3081     bool paragraphStyle = false;
3082
3083     if (style.IsCharacterStyle())
3084         characterStyle = true;
3085     if (style.IsParagraphStyle())
3086         paragraphStyle = true;
3087
3088     wxRichTextBuffer* buffer = GetBuffer();
3089
3090     bool withUndo = ((flags & wxRICHTEXT_SETSTYLE_WITH_UNDO) != 0);
3091     bool applyMinimal = ((flags & wxRICHTEXT_SETSTYLE_OPTIMIZE) != 0);
3092     bool parasOnly = ((flags & wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY) != 0);
3093     bool charactersOnly = ((flags & wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY) != 0);
3094     bool resetExistingStyle = ((flags & wxRICHTEXT_SETSTYLE_RESET) != 0);
3095     bool removeStyle = ((flags & wxRICHTEXT_SETSTYLE_REMOVE) != 0);
3096
3097     // Apply paragraph style first, if any
3098     wxRichTextAttr wholeStyle(style);
3099
3100     if (!removeStyle && wholeStyle.HasParagraphStyleName() && buffer->GetStyleSheet())
3101     {
3102         wxRichTextParagraphStyleDefinition* def = buffer->GetStyleSheet()->FindParagraphStyle(wholeStyle.GetParagraphStyleName());
3103         if (def)
3104             wxRichTextApplyStyle(wholeStyle, def->GetStyleMergedWithBase(buffer->GetStyleSheet()));
3105     }
3106
3107     // Limit the attributes to be set to the content to only character attributes.
3108     wxRichTextAttr characterAttributes(wholeStyle);
3109     characterAttributes.SetFlags(characterAttributes.GetFlags() & (wxTEXT_ATTR_CHARACTER));
3110
3111     if (!removeStyle && characterAttributes.HasCharacterStyleName() && buffer->GetStyleSheet())
3112     {
3113         wxRichTextCharacterStyleDefinition* def = buffer->GetStyleSheet()->FindCharacterStyle(characterAttributes.GetCharacterStyleName());
3114         if (def)
3115             wxRichTextApplyStyle(characterAttributes, def->GetStyleMergedWithBase(buffer->GetStyleSheet()));
3116     }
3117
3118     // If we are associated with a control, make undoable; otherwise, apply immediately
3119     // to the data.
3120
3121     bool haveControl = (buffer->GetRichTextCtrl() != NULL);
3122
3123     wxRichTextAction* action = NULL;
3124
3125     if (haveControl && withUndo)
3126     {
3127         action = new wxRichTextAction(NULL, _("Change Style"), wxRICHTEXT_CHANGE_STYLE, buffer, this, buffer->GetRichTextCtrl());
3128         action->SetRange(range);
3129         action->SetPosition(buffer->GetRichTextCtrl()->GetCaretPosition());
3130     }
3131
3132     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
3133     while (node)
3134     {
3135         wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
3136         // wxASSERT (para != NULL);
3137
3138         if (para && para->GetChildCount() > 0)
3139         {
3140             // Stop searching if we're beyond the range of interest
3141             if (para->GetRange().GetStart() > range.GetEnd())
3142                 break;
3143
3144             if (!para->GetRange().IsOutside(range))
3145             {
3146                 // We'll be using a copy of the paragraph to make style changes,
3147                 // not updating the buffer directly.
3148                 wxRichTextParagraph* newPara wxDUMMY_INITIALIZE(NULL);
3149
3150                 if (haveControl && withUndo)
3151                 {
3152                     newPara = new wxRichTextParagraph(*para);
3153                     action->GetNewParagraphs().AppendChild(newPara);
3154
3155                     // Also store the old ones for Undo
3156                     action->GetOldParagraphs().AppendChild(new wxRichTextParagraph(*para));
3157                 }
3158                 else
3159                     newPara = para;
3160
3161                 // If we're specifying paragraphs only, then we really mean character formatting
3162                 // to be included in the paragraph style
3163                 if ((paragraphStyle || parasOnly) && !charactersOnly)
3164                 {
3165                     if (removeStyle)
3166                     {
3167                         // Removes the given style from the paragraph
3168                         wxRichTextRemoveStyle(newPara->GetAttributes(), style);
3169                     }
3170                     else if (resetExistingStyle)
3171                         newPara->GetAttributes() = wholeStyle;
3172                     else
3173                     {
3174                         if (applyMinimal)
3175                         {
3176                             // Only apply attributes that will make a difference to the combined
3177                             // style as seen on the display
3178                             wxRichTextAttr combinedAttr(para->GetCombinedAttributes(true));
3179                             wxRichTextApplyStyle(newPara->GetAttributes(), wholeStyle, & combinedAttr);
3180                         }
3181                         else
3182                             wxRichTextApplyStyle(newPara->GetAttributes(), wholeStyle);
3183                     }
3184                 }
3185
3186                 // When applying paragraph styles dynamically, don't change the text objects' attributes
3187                 // since they will computed as needed. Only apply the character styling if it's _only_
3188                 // character styling. This policy is subject to change and might be put under user control.
3189
3190                 // Hm. we might well be applying a mix of paragraph and character styles, in which
3191                 // case we _do_ want to apply character styles regardless of what para styles are set.
3192                 // But if we're applying a paragraph style, which has some character attributes, but
3193                 // we only want the paragraphs to hold this character style, then we _don't_ want to
3194                 // apply the character style. So we need to be able to choose.
3195
3196                 if (!parasOnly && (characterStyle|charactersOnly) && range.GetStart() != newPara->GetRange().GetEnd())
3197                 {
3198                     wxRichTextRange childRange(range);
3199                     childRange.LimitTo(newPara->GetRange());
3200
3201                     // Find the starting position and if necessary split it so
3202                     // we can start applying a different style.
3203                     // TODO: check that the style actually changes or is different
3204                     // from style outside of range
3205                     wxRichTextObject* firstObject wxDUMMY_INITIALIZE(NULL);
3206                     wxRichTextObject* lastObject wxDUMMY_INITIALIZE(NULL);
3207
3208                     if (childRange.GetStart() == newPara->GetRange().GetStart())
3209                         firstObject = newPara->GetChildren().GetFirst()->GetData();
3210                     else
3211                         firstObject = newPara->SplitAt(range.GetStart());
3212
3213                     // Increment by 1 because we're apply the style one _after_ the split point
3214                     long splitPoint = childRange.GetEnd();
3215                     if (splitPoint != newPara->GetRange().GetEnd())
3216                         splitPoint ++;
3217
3218                     // Find last object
3219                     if (splitPoint == newPara->GetRange().GetEnd())
3220                         lastObject = newPara->GetChildren().GetLast()->GetData();
3221                     else
3222                         // lastObject is set as a side-effect of splitting. It's
3223                         // returned as the object before the new object.
3224                         (void) newPara->SplitAt(splitPoint, & lastObject);
3225
3226                     wxASSERT(firstObject != NULL);
3227                     wxASSERT(lastObject != NULL);
3228
3229                     if (!firstObject || !lastObject)
3230                         continue;
3231
3232                     wxRichTextObjectList::compatibility_iterator firstNode = newPara->GetChildren().Find(firstObject);
3233                     wxRichTextObjectList::compatibility_iterator lastNode = newPara->GetChildren().Find(lastObject);
3234
3235                     wxASSERT(firstNode);
3236                     wxASSERT(lastNode);
3237
3238                     wxRichTextObjectList::compatibility_iterator node2 = firstNode;
3239
3240                     while (node2)
3241                     {
3242                         wxRichTextObject* child = node2->GetData();
3243
3244                         if (removeStyle)
3245                         {
3246                             // Removes the given style from the paragraph
3247                             wxRichTextRemoveStyle(child->GetAttributes(), style);
3248                         }
3249                         else if (resetExistingStyle)
3250                             child->GetAttributes() = characterAttributes;
3251                         else
3252                         {
3253                             if (applyMinimal)
3254                             {
3255                                 // Only apply attributes that will make a difference to the combined
3256                                 // style as seen on the display
3257                                 wxRichTextAttr combinedAttr(newPara->GetCombinedAttributes(child->GetAttributes(), true));
3258                                 wxRichTextApplyStyle(child->GetAttributes(), characterAttributes, & combinedAttr);
3259                             }
3260                             else
3261                                 wxRichTextApplyStyle(child->GetAttributes(), characterAttributes);
3262                         }
3263
3264                         if (node2 == lastNode)
3265                             break;
3266
3267                         node2 = node2->GetNext();
3268                     }
3269                 }
3270             }
3271         }
3272
3273         node = node->GetNext();
3274     }
3275
3276     // Do action, or delay it until end of batch.
3277     if (haveControl && withUndo)
3278         buffer->SubmitAction(action);
3279
3280     return true;
3281 }
3282
3283 // Just change the attributes for this single object.
3284 void wxRichTextParagraphLayoutBox::SetStyle(wxRichTextObject* obj, const wxRichTextAttr& textAttr, int flags)
3285 {
3286     wxRichTextBuffer* buffer = GetBuffer();
3287     bool withUndo = flags & wxRICHTEXT_SETSTYLE_WITH_UNDO;
3288     bool resetExistingStyle = ((flags & wxRICHTEXT_SETSTYLE_RESET) != 0);
3289     bool haveControl = (buffer->GetRichTextCtrl() != NULL);
3290
3291     wxRichTextAction *action = NULL;
3292     wxRichTextAttr newAttr = obj->GetAttributes();
3293     if (resetExistingStyle)
3294         newAttr = textAttr;
3295     else
3296         newAttr.Apply(textAttr);
3297
3298     if (haveControl && withUndo)
3299     {
3300         action = new wxRichTextAction(NULL, _("Change Object Style"), wxRICHTEXT_CHANGE_ATTRIBUTES, buffer, obj->GetContainer(), buffer->GetRichTextCtrl());
3301         action->SetRange(obj->GetRange().FromInternal());
3302         action->SetPosition(buffer->GetRichTextCtrl()->GetCaretPosition());
3303         action->MakeObject(obj);
3304
3305         action->GetAttributes() = newAttr;
3306     }
3307     else
3308         obj->GetAttributes() = newAttr;
3309
3310     if (haveControl && withUndo)
3311         buffer->SubmitAction(action);
3312 }
3313
3314 /// Get the text attributes for this position.
3315 bool wxRichTextParagraphLayoutBox::GetStyle(long position, wxRichTextAttr& style)
3316 {
3317     return DoGetStyle(position, style, true);
3318 }
3319
3320 bool wxRichTextParagraphLayoutBox::GetUncombinedStyle(long position, wxRichTextAttr& style)
3321 {
3322     return DoGetStyle(position, style, false);
3323 }
3324
3325 /// Implementation helper for GetStyle. If combineStyles is true, combine base, paragraph and
3326 /// context attributes.
3327 bool wxRichTextParagraphLayoutBox::DoGetStyle(long position, wxRichTextAttr& style, bool combineStyles)
3328 {
3329     wxRichTextObject* obj wxDUMMY_INITIALIZE(NULL);
3330
3331     if (style.IsParagraphStyle())
3332     {
3333         obj = GetParagraphAtPosition(position);
3334         if (obj)
3335         {
3336             if (combineStyles)
3337             {
3338                 // Start with the base style
3339                 style = GetAttributes();
3340                 style.GetTextBoxAttr().Reset();
3341
3342                 // Apply the paragraph style
3343                 wxRichTextApplyStyle(style, obj->GetAttributes());
3344             }
3345             else
3346                 style = obj->GetAttributes();
3347
3348             return true;
3349         }
3350     }
3351     else
3352     {
3353         obj = GetLeafObjectAtPosition(position);
3354         if (obj)
3355         {
3356             if (combineStyles)
3357             {
3358                 wxRichTextParagraph* para = wxDynamicCast(obj->GetParent(), wxRichTextParagraph);
3359                 style = para ? para->GetCombinedAttributes(obj->GetAttributes()) : obj->GetAttributes();
3360             }
3361             else
3362                 style = obj->GetAttributes();
3363
3364             return true;
3365         }
3366     }
3367     return false;
3368 }
3369
3370 static bool wxHasStyle(long flags, long style)
3371 {
3372     return (flags & style) != 0;
3373 }
3374
3375 /// Combines 'style' with 'currentStyle' for the purpose of summarising the attributes of a range of
3376 /// content.
3377 bool wxRichTextParagraphLayoutBox::CollectStyle(wxRichTextAttr& currentStyle, const wxRichTextAttr& style, wxRichTextAttr& clashingAttr, wxRichTextAttr& absentAttr)
3378 {
3379     currentStyle.CollectCommonAttributes(style, clashingAttr, absentAttr);
3380
3381     return true;
3382 }
3383
3384 /// Get the combined style for a range - if any attribute is different within the range,
3385 /// that attribute is not present within the flags.
3386 /// *** Note that this is not recursive, and so assumes that content inside a paragraph is not itself
3387 /// nested.
3388 bool wxRichTextParagraphLayoutBox::GetStyleForRange(const wxRichTextRange& range, wxRichTextAttr& style)
3389 {
3390     style = wxRichTextAttr();
3391
3392     wxRichTextAttr clashingAttr;
3393     wxRichTextAttr absentAttrPara, absentAttrChar;
3394
3395     wxRichTextObjectList::compatibility_iterator node = GetChildren().GetFirst();
3396     while (node)
3397     {
3398         wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
3399         if (para && !(para->GetRange().GetStart() > range.GetEnd() || para->GetRange().GetEnd() < range.GetStart()))
3400         {
3401             if (para->GetChildren().GetCount() == 0)
3402             {
3403                 wxRichTextAttr paraStyle = para->GetCombinedAttributes(true /* use box attributes */);
3404
3405                 CollectStyle(style, paraStyle, clashingAttr, absentAttrPara);
3406             }
3407             else
3408             {
3409                 wxRichTextRange paraRange(para->GetRange());
3410                 paraRange.LimitTo(range);
3411
3412                 // First collect paragraph attributes only
3413                 wxRichTextAttr paraStyle = para->GetCombinedAttributes();
3414                 paraStyle.SetFlags(paraStyle.GetFlags() & wxTEXT_ATTR_PARAGRAPH);
3415                 CollectStyle(style, paraStyle, clashingAttr, absentAttrPara);
3416
3417                 wxRichTextObjectList::compatibility_iterator childNode = para->GetChildren().GetFirst();
3418
3419                 while (childNode)
3420                 {
3421                     wxRichTextObject* child = childNode->GetData();
3422                     if (!(child->GetRange().GetStart() > range.GetEnd() || child->GetRange().GetEnd() < range.GetStart()))
3423                     {
3424                         wxRichTextAttr childStyle = para->GetCombinedAttributes(child->GetAttributes(), true /* include box attributes */);
3425
3426                         // Now collect character attributes only
3427                         childStyle.SetFlags(childStyle.GetFlags() & wxTEXT_ATTR_CHARACTER);
3428
3429                         CollectStyle(style, childStyle, clashingAttr, absentAttrChar);
3430                     }
3431
3432                     childNode = childNode->GetNext();
3433                 }
3434             }
3435         }
3436         node = node->GetNext();
3437     }
3438     return true;
3439 }
3440
3441 /// Set default style
3442 bool wxRichTextParagraphLayoutBox::SetDefaultStyle(const wxRichTextAttr& style)
3443 {
3444     m_defaultAttributes = style;
3445     return true;
3446 }
3447
3448 /// Test if this whole range has character attributes of the specified kind. If any
3449 /// of the attributes are different within the range, the test fails. You
3450 /// can use this to implement, for example, bold button updating. style must have
3451 /// flags indicating which attributes are of interest.
3452 bool wxRichTextParagraphLayoutBox::HasCharacterAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const
3453 {
3454     int foundCount = 0;
3455     int matchingCount = 0;
3456
3457     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
3458     while (node)
3459     {
3460         wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
3461         // wxASSERT (para != NULL);
3462
3463         if (para)
3464         {
3465             // Stop searching if we're beyond the range of interest
3466             if (para->GetRange().GetStart() > range.GetEnd())
3467                 return foundCount == matchingCount && foundCount != 0;
3468
3469             if (!para->GetRange().IsOutside(range))
3470             {
3471                 wxRichTextObjectList::compatibility_iterator node2 = para->GetChildren().GetFirst();
3472
3473                 while (node2)
3474                 {
3475                     wxRichTextObject* child = node2->GetData();
3476                     // Allow for empty string if no buffer
3477                     wxRichTextRange childRange = child->GetRange();
3478                     if (childRange.GetLength() == 0 && GetRange().GetLength() == 1)
3479                         childRange.SetEnd(childRange.GetEnd()+1);
3480
3481                     if (!childRange.IsOutside(range) && wxDynamicCast(child, wxRichTextPlainText))
3482                     {
3483                         foundCount ++;
3484                         wxRichTextAttr textAttr = para->GetCombinedAttributes(child->GetAttributes());
3485
3486                         if (textAttr.EqPartial(style, false /* strong test - attributes must be valid in both objects */))
3487                             matchingCount ++;
3488                     }
3489
3490                     node2 = node2->GetNext();
3491                 }
3492             }
3493         }
3494
3495         node = node->GetNext();
3496     }
3497
3498     return foundCount == matchingCount && foundCount != 0;
3499 }
3500
3501 /// Test if this whole range has paragraph attributes of the specified kind. If any
3502 /// of the attributes are different within the range, the test fails. You
3503 /// can use this to implement, for example, centering button updating. style must have
3504 /// flags indicating which attributes are of interest.
3505 bool wxRichTextParagraphLayoutBox::HasParagraphAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const
3506 {
3507     int foundCount = 0;
3508     int matchingCount = 0;
3509
3510     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
3511     while (node)
3512     {
3513         wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
3514         // wxASSERT (para != NULL);
3515
3516         if (para)
3517         {
3518             // Stop searching if we're beyond the range of interest
3519             if (para->GetRange().GetStart() > range.GetEnd())
3520                 return foundCount == matchingCount && foundCount != 0;
3521
3522             if (!para->GetRange().IsOutside(range))
3523             {
3524                 wxRichTextAttr textAttr = GetAttributes();
3525                 // Apply the paragraph style
3526                 wxRichTextApplyStyle(textAttr, para->GetAttributes());
3527
3528                 foundCount ++;
3529                 if (textAttr.EqPartial(style, false /* strong test */))
3530                     matchingCount ++;
3531             }
3532         }
3533
3534         node = node->GetNext();
3535     }
3536     return foundCount == matchingCount && foundCount != 0;
3537 }
3538
3539 void wxRichTextParagraphLayoutBox::PrepareContent(wxRichTextParagraphLayoutBox& container)
3540 {
3541     wxRichTextBuffer* buffer = GetBuffer();
3542     if (buffer && buffer->GetRichTextCtrl())
3543         buffer->GetRichTextCtrl()->PrepareContent(container);
3544 }
3545
3546 /// Set character or paragraph properties
3547 bool wxRichTextParagraphLayoutBox::SetProperties(const wxRichTextRange& range, const wxRichTextProperties& properties, int flags)
3548 {
3549     wxRichTextBuffer* buffer = GetBuffer();
3550
3551     bool withUndo = ((flags & wxRICHTEXT_SETPROPERTIES_WITH_UNDO) != 0);
3552     bool parasOnly = ((flags & wxRICHTEXT_SETPROPERTIES_PARAGRAPHS_ONLY) != 0);
3553     bool charactersOnly = ((flags & wxRICHTEXT_SETPROPERTIES_CHARACTERS_ONLY) != 0);
3554     bool resetExistingProperties = ((flags & wxRICHTEXT_SETPROPERTIES_RESET) != 0);
3555     bool removeProperties = ((flags & wxRICHTEXT_SETPROPERTIES_REMOVE) != 0);
3556
3557     // If we are associated with a control, make undoable; otherwise, apply immediately
3558     // to the data.
3559
3560     bool haveControl = (buffer->GetRichTextCtrl() != NULL);
3561
3562     wxRichTextAction* action = NULL;
3563
3564     if (haveControl && withUndo)
3565     {
3566         action = new wxRichTextAction(NULL, _("Change Properties"), wxRICHTEXT_CHANGE_PROPERTIES, buffer, this, buffer->GetRichTextCtrl());
3567         action->SetRange(range);
3568         action->SetPosition(buffer->GetRichTextCtrl()->GetCaretPosition());
3569     }
3570
3571     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
3572     while (node)
3573     {
3574         wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
3575         // wxASSERT (para != NULL);
3576
3577         if (para && para->GetChildCount() > 0)
3578         {
3579             // Stop searching if we're beyond the range of interest
3580             if (para->GetRange().GetStart() > range.GetEnd())
3581                 break;
3582
3583             if (!para->GetRange().IsOutside(range))
3584             {
3585                 // We'll be using a copy of the paragraph to make style changes,
3586                 // not updating the buffer directly.
3587                 wxRichTextParagraph* newPara wxDUMMY_INITIALIZE(NULL);
3588
3589                 if (haveControl && withUndo)
3590                 {
3591                     newPara = new wxRichTextParagraph(*para);
3592                     action->GetNewParagraphs().AppendChild(newPara);
3593
3594                     // Also store the old ones for Undo
3595                     action->GetOldParagraphs().AppendChild(new wxRichTextParagraph(*para));
3596                 }
3597                 else
3598                     newPara = para;
3599
3600                 if (parasOnly)
3601                 {
3602                     if (removeProperties)
3603                     {
3604                         // Removes the given style from the paragraph
3605                         // TODO
3606                         newPara->GetProperties().RemoveProperties(properties);
3607                     }
3608                     else if (resetExistingProperties)
3609                         newPara->GetProperties() = properties;
3610                     else
3611                         newPara->GetProperties().MergeProperties(properties);
3612                 }
3613
3614                 // When applying paragraph styles dynamically, don't change the text objects' attributes
3615                 // since they will computed as needed. Only apply the character styling if it's _only_
3616                 // character styling. This policy is subject to change and might be put under user control.
3617
3618                 // Hm. we might well be applying a mix of paragraph and character styles, in which
3619                 // case we _do_ want to apply character styles regardless of what para styles are set.
3620                 // But if we're applying a paragraph style, which has some character attributes, but
3621                 // we only want the paragraphs to hold this character style, then we _don't_ want to
3622                 // apply the character style. So we need to be able to choose.
3623
3624                 if (!parasOnly && charactersOnly && range.GetStart() != newPara->GetRange().GetEnd())
3625                 {
3626                     wxRichTextRange childRange(range);
3627                     childRange.LimitTo(newPara->GetRange());
3628
3629                     // Find the starting position and if necessary split it so
3630                     // we can start applying different properties.
3631                     // TODO: check that the properties actually change or are different
3632                     // from properties outside of range
3633                     wxRichTextObject* firstObject wxDUMMY_INITIALIZE(NULL);
3634                     wxRichTextObject* lastObject wxDUMMY_INITIALIZE(NULL);
3635
3636                     if (childRange.GetStart() == newPara->GetRange().GetStart())
3637                         firstObject = newPara->GetChildren().GetFirst()->GetData();
3638                     else
3639                         firstObject = newPara->SplitAt(range.GetStart());
3640
3641                     // Increment by 1 because we're apply the style one _after_ the split point
3642                     long splitPoint = childRange.GetEnd();
3643                     if (splitPoint != newPara->GetRange().GetEnd())
3644                         splitPoint ++;
3645
3646                     // Find last object
3647                     if (splitPoint == newPara->GetRange().GetEnd())
3648                         lastObject = newPara->GetChildren().GetLast()->GetData();
3649                     else
3650                         // lastObject is set as a side-effect of splitting. It's
3651                         // returned as the object before the new object.
3652                         (void) newPara->SplitAt(splitPoint, & lastObject);
3653
3654                     wxASSERT(firstObject != NULL);
3655                     wxASSERT(lastObject != NULL);
3656
3657                     if (!firstObject || !lastObject)
3658                         continue;
3659
3660                     wxRichTextObjectList::compatibility_iterator firstNode = newPara->GetChildren().Find(firstObject);
3661                     wxRichTextObjectList::compatibility_iterator lastNode = newPara->GetChildren().Find(lastObject);
3662
3663                     wxASSERT(firstNode);
3664                     wxASSERT(lastNode);
3665
3666                     wxRichTextObjectList::compatibility_iterator node2 = firstNode;
3667
3668                     while (node2)
3669                     {
3670                         wxRichTextObject* child = node2->GetData();
3671
3672                         if (removeProperties)
3673                         {
3674                             // Removes the given properties from the paragraph
3675                             child->GetProperties().RemoveProperties(properties);
3676                         }
3677                         else if (resetExistingProperties)
3678                             child->GetProperties() = properties;
3679                         else
3680                         {
3681                             child->GetProperties().MergeProperties(properties);
3682                         }
3683
3684                         if (node2 == lastNode)
3685                             break;
3686
3687                         node2 = node2->GetNext();
3688                     }
3689                 }
3690             }
3691         }
3692
3693         node = node->GetNext();
3694     }
3695
3696     // Do action, or delay it until end of batch.
3697     if (haveControl && withUndo)
3698         buffer->SubmitAction(action);
3699
3700     return true;
3701 }
3702
3703 void wxRichTextParagraphLayoutBox::Reset()
3704 {
3705     Clear();
3706
3707     wxRichTextBuffer* buffer = GetBuffer();
3708     if (buffer && buffer->GetRichTextCtrl())
3709     {
3710         wxRichTextEvent event(wxEVT_COMMAND_RICHTEXT_BUFFER_RESET, buffer->GetRichTextCtrl()->GetId());
3711         event.SetEventObject(buffer->GetRichTextCtrl());
3712         event.SetContainer(this);
3713
3714         buffer->SendEvent(event, true);
3715     }
3716
3717     AddParagraph(wxEmptyString);
3718
3719     PrepareContent(*this);
3720
3721     InvalidateHierarchy(wxRICHTEXT_ALL);
3722 }
3723
3724 /// Invalidate the buffer. With no argument, invalidates whole buffer.
3725 void wxRichTextParagraphLayoutBox::Invalidate(const wxRichTextRange& invalidRange)
3726 {
3727     wxRichTextCompositeObject::Invalidate(invalidRange);
3728
3729     DoInvalidate(invalidRange);
3730 }
3731
3732 // Do the (in)validation for this object only
3733 void wxRichTextParagraphLayoutBox::DoInvalidate(const wxRichTextRange& invalidRange)
3734 {
3735     if (invalidRange == wxRICHTEXT_ALL)
3736     {
3737         m_invalidRange = wxRICHTEXT_ALL;
3738     }
3739     // Already invalidating everything
3740     else if (m_invalidRange == wxRICHTEXT_ALL)
3741     {
3742     }
3743     else
3744     {
3745         if ((invalidRange.GetStart() < m_invalidRange.GetStart()) || m_invalidRange.GetStart() == -1)
3746             m_invalidRange.SetStart(invalidRange.GetStart());
3747         if (invalidRange.GetEnd() > m_invalidRange.GetEnd())
3748             m_invalidRange.SetEnd(invalidRange.GetEnd());
3749     }
3750 }
3751
3752 // Do the (in)validation both up and down the hierarchy
3753 void wxRichTextParagraphLayoutBox::InvalidateHierarchy(const wxRichTextRange& invalidRange)
3754 {
3755     Invalidate(invalidRange);
3756
3757     if (invalidRange != wxRICHTEXT_NONE)
3758     {
3759         // Now go up the hierarchy
3760         wxRichTextObject* thisObj = this;
3761         wxRichTextObject* p = GetParent();
3762         while (p)
3763         {
3764             wxRichTextParagraphLayoutBox* l = wxDynamicCast(p, wxRichTextParagraphLayoutBox);
3765             if (l)
3766                 l->DoInvalidate(thisObj->GetRange());
3767
3768             thisObj = p;
3769             p = p->GetParent();
3770         }
3771     }
3772 }
3773
3774 /// Get invalid range, rounding to entire paragraphs if argument is true.
3775 wxRichTextRange wxRichTextParagraphLayoutBox::GetInvalidRange(bool wholeParagraphs) const
3776 {
3777     if (m_invalidRange == wxRICHTEXT_ALL || m_invalidRange == wxRICHTEXT_NONE)
3778         return m_invalidRange;
3779
3780     wxRichTextRange range = m_invalidRange;
3781
3782     if (wholeParagraphs)
3783     {
3784         wxRichTextParagraph* para1 = GetParagraphAtPosition(range.GetStart());
3785         if (para1)
3786             range.SetStart(para1->GetRange().GetStart());
3787         // floating layout make all child should be relayout
3788         range.SetEnd(GetOwnRange().GetEnd());
3789     }
3790     return range;
3791 }
3792
3793 /// Apply the style sheet to the buffer, for example if the styles have changed.
3794 bool wxRichTextParagraphLayoutBox::ApplyStyleSheet(wxRichTextStyleSheet* styleSheet)
3795 {
3796     wxASSERT(styleSheet != NULL);
3797     if (!styleSheet)
3798         return false;
3799
3800     int foundCount = 0;
3801
3802     wxRichTextAttr attr(GetBasicStyle());
3803     if (GetBasicStyle().HasParagraphStyleName())
3804     {
3805         wxRichTextParagraphStyleDefinition* paraDef = styleSheet->FindParagraphStyle(GetBasicStyle().GetParagraphStyleName());
3806         if (paraDef)
3807         {
3808             attr.Apply(paraDef->GetStyleMergedWithBase(styleSheet));
3809             SetBasicStyle(attr);
3810             foundCount ++;
3811         }
3812     }
3813
3814     if (GetBasicStyle().HasCharacterStyleName())
3815     {
3816         wxRichTextCharacterStyleDefinition* charDef = styleSheet->FindCharacterStyle(GetBasicStyle().GetCharacterStyleName());
3817         if (charDef)
3818         {
3819             attr.Apply(charDef->GetStyleMergedWithBase(styleSheet));
3820             SetBasicStyle(attr);
3821             foundCount ++;
3822         }
3823     }
3824
3825     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
3826     while (node)
3827     {
3828         wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
3829         // wxASSERT (para != NULL);
3830
3831         if (para)
3832         {
3833             // Combine paragraph and list styles. If there is a list style in the original attributes,
3834             // the current indentation overrides anything else and is used to find the item indentation.
3835             // Also, for applying paragraph styles, consider having 2 modes: (1) we merge with what we have,
3836             // thereby taking into account all user changes, (2) reset the style completely (except for indentation/list
3837             // exception as above).
3838             // Problem: when changing from one list style to another, there's a danger that the level info will get lost.
3839             // So when changing a list style interactively, could retrieve level based on current style, then
3840             // set appropriate indent and apply new style.
3841
3842             int outline = -1;
3843             int num = -1;
3844             if (para->GetAttributes().HasOutlineLevel())
3845                 outline = para->GetAttributes().GetOutlineLevel();
3846             if (para->GetAttributes().HasBulletNumber())
3847                 num = para->GetAttributes().GetBulletNumber();
3848
3849             if (!para->GetAttributes().GetParagraphStyleName().IsEmpty() && !para->GetAttributes().GetListStyleName().IsEmpty())
3850             {
3851                 int currentIndent = para->GetAttributes().GetLeftIndent();
3852
3853                 wxRichTextParagraphStyleDefinition* paraDef = styleSheet->FindParagraphStyle(para->GetAttributes().GetParagraphStyleName());
3854                 wxRichTextListStyleDefinition* listDef = styleSheet->FindListStyle(para->GetAttributes().GetListStyleName());
3855                 if (paraDef && !listDef)
3856                 {
3857                     para->GetAttributes() = paraDef->GetStyleMergedWithBase(styleSheet);
3858                     foundCount ++;
3859                 }
3860                 else if (listDef && !paraDef)
3861                 {
3862                     // Set overall style defined for the list style definition
3863                     para->GetAttributes() = listDef->GetStyleMergedWithBase(styleSheet);
3864
3865                     // Apply the style for this level
3866                     wxRichTextApplyStyle(para->GetAttributes(), * listDef->GetLevelAttributes(listDef->FindLevelForIndent(currentIndent)));
3867                     foundCount ++;
3868                 }
3869                 else if (listDef && paraDef)
3870                 {
3871                     // Combines overall list style, style for level, and paragraph style
3872                     para->GetAttributes() = listDef->CombineWithParagraphStyle(currentIndent, paraDef->GetStyleMergedWithBase(styleSheet));
3873                     foundCount ++;
3874                 }
3875             }
3876             else if (para->GetAttributes().GetParagraphStyleName().IsEmpty() && !para->GetAttributes().GetListStyleName().IsEmpty())
3877             {
3878                 int currentIndent = para->GetAttributes().GetLeftIndent();
3879
3880                 wxRichTextListStyleDefinition* listDef = styleSheet->FindListStyle(para->GetAttributes().GetListStyleName());
3881
3882                 // Overall list definition style
3883                 para->GetAttributes() = listDef->GetStyleMergedWithBase(styleSheet);
3884
3885                 // Style for this level
3886                 wxRichTextApplyStyle(para->GetAttributes(), * listDef->GetLevelAttributes(listDef->FindLevelForIndent(currentIndent)));
3887
3888                 foundCount ++;
3889             }
3890             else if (!para->GetAttributes().GetParagraphStyleName().IsEmpty() && para->GetAttributes().GetListStyleName().IsEmpty())
3891             {
3892                 wxRichTextParagraphStyleDefinition* def = styleSheet->FindParagraphStyle(para->GetAttributes().GetParagraphStyleName());
3893                 if (def)
3894                 {
3895                     para->GetAttributes() = def->GetStyleMergedWithBase(styleSheet);
3896                     foundCount ++;
3897                 }
3898             }
3899
3900             if (outline != -1)
3901                 para->GetAttributes().SetOutlineLevel(outline);
3902             if (num != -1)
3903                 para->GetAttributes().SetBulletNumber(num);
3904         }
3905
3906         node = node->GetNext();
3907     }
3908     return foundCount != 0;
3909 }
3910
3911 /// Set list style
3912 bool wxRichTextParagraphLayoutBox::SetListStyle(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags, int startFrom, int specifiedLevel)
3913 {
3914     wxRichTextBuffer* buffer = GetBuffer();
3915     wxRichTextStyleSheet* styleSheet = buffer->GetStyleSheet();
3916
3917     bool withUndo = ((flags & wxRICHTEXT_SETSTYLE_WITH_UNDO) != 0);
3918     // bool applyMinimal = ((flags & wxRICHTEXT_SETSTYLE_OPTIMIZE) != 0);
3919     bool specifyLevel = ((flags & wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL) != 0);
3920     bool renumber = ((flags & wxRICHTEXT_SETSTYLE_RENUMBER) != 0);
3921
3922     // Current number, if numbering
3923     int n = startFrom;
3924
3925     wxASSERT (!specifyLevel || (specifyLevel && (specifiedLevel >= 0)));
3926
3927     // If we are associated with a control, make undoable; otherwise, apply immediately
3928     // to the data.
3929
3930     bool haveControl = (buffer->GetRichTextCtrl() != NULL);
3931
3932     wxRichTextAction* action = NULL;
3933
3934     if (haveControl && withUndo)
3935     {
3936         action = new wxRichTextAction(NULL, _("Change List Style"), wxRICHTEXT_CHANGE_STYLE, buffer, this, buffer->GetRichTextCtrl());
3937         action->SetRange(range);
3938         action->SetPosition(buffer->GetRichTextCtrl()->GetCaretPosition());
3939     }
3940
3941     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
3942     while (node)
3943     {
3944         wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
3945         // wxASSERT (para != NULL);
3946
3947         if (para && para->GetChildCount() > 0)
3948         {
3949             // Stop searching if we're beyond the range of interest
3950             if (para->GetRange().GetStart() > range.GetEnd())
3951                 break;
3952
3953             if (!para->GetRange().IsOutside(range))
3954             {
3955                 // We'll be using a copy of the paragraph to make style changes,
3956                 // not updating the buffer directly.
3957                 wxRichTextParagraph* newPara wxDUMMY_INITIALIZE(NULL);
3958
3959                 if (haveControl && withUndo)
3960                 {
3961                     newPara = new wxRichTextParagraph(*para);
3962                     action->GetNewParagraphs().AppendChild(newPara);
3963
3964                     // Also store the old ones for Undo
3965                     action->GetOldParagraphs().AppendChild(new wxRichTextParagraph(*para));
3966                 }
3967                 else
3968                     newPara = para;
3969
3970                 if (def)
3971                 {
3972                     int thisIndent = newPara->GetAttributes().GetLeftIndent();
3973                     int thisLevel = specifyLevel ? specifiedLevel : def->FindLevelForIndent(thisIndent);
3974
3975                     // How is numbering going to work?
3976                     // If we are renumbering, or numbering for the first time, we need to keep
3977                     // track of the number for each level. But we might be simply applying a different
3978                     // list style.
3979                     // In Word, applying a style to several paragraphs, even if at different levels,
3980                     // reverts the level back to the same one. So we could do the same here.
3981                     // Renumbering will need to be done when we promote/demote a paragraph.
3982
3983                     // Apply the overall list style, and item style for this level
3984                     wxRichTextAttr listStyle(def->GetCombinedStyleForLevel(thisLevel, styleSheet));
3985                     wxRichTextApplyStyle(newPara->GetAttributes(), listStyle);
3986
3987                     // Now we need to do numbering
3988                     // Preserve the existing list item continuation bullet style, if any
3989                     if (para->GetAttributes().HasBulletStyle() && (para->GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_CONTINUATION))
3990                         newPara->GetAttributes().SetBulletStyle(newPara->GetAttributes().GetBulletStyle()|wxTEXT_ATTR_BULLET_STYLE_CONTINUATION);
3991                     else
3992                     {
3993                         // Now we need to do numbering
3994                         if (renumber)
3995                         {
3996                             newPara->GetAttributes().SetBulletNumber(n);
3997                         }
3998
3999                         n ++;
4000                     }
4001                 }
4002                 else if (!newPara->GetAttributes().GetListStyleName().IsEmpty())
4003                 {
4004                     // if def is NULL, remove list style, applying any associated paragraph style
4005                     // to restore the attributes
4006
4007                     newPara->GetAttributes().SetListStyleName(wxEmptyString);
4008                     newPara->GetAttributes().SetLeftIndent(0, 0);
4009                     newPara->GetAttributes().SetBulletText(wxEmptyString);
4010
4011                     // Eliminate the main list-related attributes
4012                     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);
4013
4014                     if (styleSheet && !newPara->GetAttributes().GetParagraphStyleName().IsEmpty())
4015                     {
4016                         wxRichTextParagraphStyleDefinition* def = styleSheet->FindParagraphStyle(newPara->GetAttributes().GetParagraphStyleName());
4017                         if (def)
4018                         {
4019                             newPara->GetAttributes() = def->GetStyleMergedWithBase(styleSheet);
4020                         }
4021                     }
4022                 }
4023             }
4024         }
4025
4026         node = node->GetNext();
4027     }
4028
4029     // Do action, or delay it until end of batch.
4030     if (haveControl && withUndo)
4031         buffer->SubmitAction(action);
4032
4033     return true;
4034 }
4035
4036 bool wxRichTextParagraphLayoutBox::SetListStyle(const wxRichTextRange& range, const wxString& defName, int flags, int startFrom, int specifiedLevel)
4037 {
4038     wxRichTextBuffer* buffer = GetBuffer();
4039     if (buffer && buffer->GetStyleSheet())
4040     {
4041         wxRichTextListStyleDefinition* def = buffer->GetStyleSheet()->FindListStyle(defName);
4042         if (def)
4043             return SetListStyle(range, def, flags, startFrom, specifiedLevel);
4044     }
4045     return false;
4046 }
4047
4048 /// Clear list for given range
4049 bool wxRichTextParagraphLayoutBox::ClearListStyle(const wxRichTextRange& range, int flags)
4050 {
4051     return SetListStyle(range, NULL, flags);
4052 }
4053
4054 /// Number/renumber any list elements in the given range
4055 bool wxRichTextParagraphLayoutBox::NumberList(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags, int startFrom, int specifiedLevel)
4056 {
4057     return DoNumberList(range, range, 0, def, flags, startFrom, specifiedLevel);
4058 }
4059
4060 /// Number/renumber any list elements in the given range. Also do promotion or demotion of items, if specified
4061 bool wxRichTextParagraphLayoutBox::DoNumberList(const wxRichTextRange& range, const wxRichTextRange& promotionRange, int promoteBy,
4062                                                 wxRichTextListStyleDefinition* def, int flags, int startFrom, int specifiedLevel)
4063 {
4064     wxRichTextBuffer* buffer = GetBuffer();
4065     wxRichTextStyleSheet* styleSheet = buffer->GetStyleSheet();
4066
4067     bool withUndo = ((flags & wxRICHTEXT_SETSTYLE_WITH_UNDO) != 0);
4068     // bool applyMinimal = ((flags & wxRICHTEXT_SETSTYLE_OPTIMIZE) != 0);
4069 #if wxDEBUG_LEVEL
4070     bool specifyLevel = ((flags & wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL) != 0);
4071 #endif
4072
4073     bool renumber = ((flags & wxRICHTEXT_SETSTYLE_RENUMBER) != 0);
4074
4075     // Max number of levels
4076     const int maxLevels = 10;
4077
4078     // The level we're looking at now
4079     int currentLevel = -1;
4080
4081     // The item number for each level
4082     int levels[maxLevels];
4083     int i;
4084
4085     // Reset all numbering
4086     for (i = 0; i < maxLevels; i++)
4087     {
4088         if (startFrom != -1)
4089             levels[i] = startFrom-1;
4090         else if (renumber) // start again
4091             levels[i] = 0;
4092         else
4093             levels[i] = -1; // start from the number we found, if any
4094     }
4095
4096 #if wxDEBUG_LEVEL
4097     wxASSERT(!specifyLevel || (specifyLevel && (specifiedLevel >= 0)));
4098 #endif
4099
4100     // If we are associated with a control, make undoable; otherwise, apply immediately
4101     // to the data.
4102
4103     bool haveControl = (buffer->GetRichTextCtrl() != NULL);
4104
4105     wxRichTextAction* action = NULL;
4106
4107     if (haveControl && withUndo)
4108     {
4109         action = new wxRichTextAction(NULL, _("Renumber List"), wxRICHTEXT_CHANGE_STYLE, buffer, this, buffer->GetRichTextCtrl());
4110         action->SetRange(range);
4111         action->SetPosition(buffer->GetRichTextCtrl()->GetCaretPosition());
4112     }
4113
4114     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
4115     while (node)
4116     {
4117         wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
4118         // wxASSERT (para != NULL);
4119
4120         if (para && para->GetChildCount() > 0)
4121         {
4122             // Stop searching if we're beyond the range of interest
4123             if (para->GetRange().GetStart() > range.GetEnd())
4124                 break;
4125
4126             if (!para->GetRange().IsOutside(range))
4127             {
4128                 // We'll be using a copy of the paragraph to make style changes,
4129                 // not updating the buffer directly.
4130                 wxRichTextParagraph* newPara wxDUMMY_INITIALIZE(NULL);
4131
4132                 if (haveControl && withUndo)
4133                 {
4134                     newPara = new wxRichTextParagraph(*para);
4135                     action->GetNewParagraphs().AppendChild(newPara);
4136
4137                     // Also store the old ones for Undo
4138                     action->GetOldParagraphs().AppendChild(new wxRichTextParagraph(*para));
4139                 }
4140                 else
4141                     newPara = para;
4142
4143                 wxRichTextListStyleDefinition* defToUse = def;
4144                 if (!defToUse)
4145                 {
4146                     if (styleSheet && !newPara->GetAttributes().GetListStyleName().IsEmpty())
4147                         defToUse = styleSheet->FindListStyle(newPara->GetAttributes().GetListStyleName());
4148                 }
4149
4150                 if (defToUse)
4151                 {
4152                     int thisIndent = newPara->GetAttributes().GetLeftIndent();
4153                     int thisLevel = defToUse->FindLevelForIndent(thisIndent);
4154
4155                     // If we've specified a level to apply to all, change the level.
4156                     if (specifiedLevel != -1)
4157                         thisLevel = specifiedLevel;
4158
4159                     // Do promotion if specified
4160                     if ((promoteBy != 0) && !para->GetRange().IsOutside(promotionRange))
4161                     {
4162                         thisLevel = thisLevel - promoteBy;
4163                         if (thisLevel < 0)
4164                             thisLevel = 0;
4165                         if (thisLevel > 9)
4166                             thisLevel = 9;
4167                     }
4168
4169                     // Apply the overall list style, and item style for this level
4170                     wxRichTextAttr listStyle(defToUse->GetCombinedStyleForLevel(thisLevel, styleSheet));
4171                     wxRichTextApplyStyle(newPara->GetAttributes(), listStyle);
4172
4173                     // Preserve the existing list item continuation bullet style, if any
4174                     if (para->GetAttributes().HasBulletStyle() && (para->GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_CONTINUATION))
4175                         newPara->GetAttributes().SetBulletStyle(newPara->GetAttributes().GetBulletStyle()|wxTEXT_ATTR_BULLET_STYLE_CONTINUATION);
4176
4177                     // OK, we've (re)applied the style, now let's get the numbering right.
4178
4179                     if (currentLevel == -1)
4180                         currentLevel = thisLevel;
4181
4182                     // Same level as before, do nothing except increment level's number afterwards
4183                     if (currentLevel == thisLevel)
4184                     {
4185                     }
4186                     // A deeper level: start renumbering all levels after current level
4187                     else if (thisLevel > currentLevel)
4188                     {
4189                         for (i = currentLevel+1; i <= thisLevel; i++)
4190                         {
4191                             levels[i] = 0;
4192                         }
4193                         currentLevel = thisLevel;
4194                     }
4195                     else if (thisLevel < currentLevel)
4196                     {
4197                         currentLevel = thisLevel;
4198                     }
4199
4200                     // Use the current numbering if -1 and we have a bullet number already
4201                     if (levels[currentLevel] == -1)
4202                     {
4203                         if (newPara->GetAttributes().HasBulletNumber())
4204                             levels[currentLevel] = newPara->GetAttributes().GetBulletNumber();
4205                         else
4206                             levels[currentLevel] = 1;
4207                     }
4208                     else
4209                     {
4210                         if (!(para->GetAttributes().HasBulletStyle() && (para->GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_CONTINUATION)))
4211                             levels[currentLevel] ++;
4212                     }
4213
4214                     newPara->GetAttributes().SetBulletNumber(levels[currentLevel]);
4215
4216                     // Create the bullet text if an outline list
4217                     if (listStyle.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_OUTLINE)
4218                     {
4219                         wxString text;
4220                         for (i = 0; i <= currentLevel; i++)
4221                         {
4222                             if (!text.IsEmpty())
4223                                 text += wxT(".");
4224                             text += wxString::Format(wxT("%d"), levels[i]);
4225                         }
4226                         newPara->GetAttributes().SetBulletText(text);
4227                     }
4228                 }
4229             }
4230         }
4231
4232         node = node->GetNext();
4233     }
4234
4235     // Do action, or delay it until end of batch.
4236     if (haveControl && withUndo)
4237         buffer->SubmitAction(action);
4238
4239     return true;
4240 }
4241
4242 bool wxRichTextParagraphLayoutBox::NumberList(const wxRichTextRange& range, const wxString& defName, int flags, int startFrom, int specifiedLevel)
4243 {
4244     wxRichTextBuffer* buffer = GetBuffer();
4245     if (buffer->GetStyleSheet())
4246     {
4247         wxRichTextListStyleDefinition* def = NULL;
4248         if (!defName.IsEmpty())
4249             def = buffer->GetStyleSheet()->FindListStyle(defName);
4250         return NumberList(range, def, flags, startFrom, specifiedLevel);
4251     }
4252     return false;
4253 }
4254
4255 /// Promote the list items within the given range. promoteBy can be a positive or negative number, e.g. 1 or -1
4256 bool wxRichTextParagraphLayoutBox::PromoteList(int promoteBy, const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags, int specifiedLevel)
4257 {
4258     // TODO
4259     // One strategy is to first work out the range within which renumbering must occur. Then could pass these two ranges
4260     // to NumberList with a flag indicating promotion is required within one of the ranges.
4261     // Find first and last paragraphs in range. Then for first, calculate new indentation and look back until we find
4262     // a paragraph that either has no list style, or has one that is different or whose indentation is less.
4263     // We start renumbering from the para after that different para we found. We specify that the numbering of that
4264     // list position will start from 1.
4265     // Similarly, we look after the last para in the promote range for an indentation that is less (or no list style).
4266     // We can end the renumbering at this point.
4267
4268     // For now, only renumber within the promotion range.
4269
4270     return DoNumberList(range, range, promoteBy, def, flags, 1, specifiedLevel);
4271 }
4272
4273 bool wxRichTextParagraphLayoutBox::PromoteList(int promoteBy, const wxRichTextRange& range, const wxString& defName, int flags, int specifiedLevel)
4274 {
4275     wxRichTextBuffer* buffer = GetBuffer();
4276     if (buffer->GetStyleSheet())
4277     {
4278         wxRichTextListStyleDefinition* def = NULL;
4279         if (!defName.IsEmpty())
4280             def = buffer->GetStyleSheet()->FindListStyle(defName);
4281         return PromoteList(promoteBy, range, def, flags, specifiedLevel);
4282     }
4283     return false;
4284 }
4285
4286 /// Fills in the attributes for numbering a paragraph after previousParagraph. It also finds the
4287 /// position of the paragraph that it had to start looking from.
4288 bool wxRichTextParagraphLayoutBox::FindNextParagraphNumber(wxRichTextParagraph* previousParagraph, wxRichTextAttr& attr) const
4289 {
4290     // Search for a paragraph that isn't a continuation paragraph (no bullet)
4291     while (previousParagraph && previousParagraph->GetAttributes().HasBulletStyle() && previousParagraph->GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_CONTINUATION)
4292     {
4293         wxRichTextObjectList::compatibility_iterator node = ((wxRichTextCompositeObject*) previousParagraph->GetParent())->GetChildren().Find(previousParagraph);
4294         if (node)
4295         {
4296             node = node->GetPrevious();
4297             if (node)
4298                 previousParagraph = wxDynamicCast(node->GetData(), wxRichTextParagraph);
4299             else
4300                 previousParagraph = NULL;
4301         }
4302         else
4303             previousParagraph = NULL;
4304     }
4305
4306     if (!previousParagraph->GetAttributes().HasFlag(wxTEXT_ATTR_BULLET_STYLE) || previousParagraph->GetAttributes().GetBulletStyle() == wxTEXT_ATTR_BULLET_STYLE_NONE)
4307         return false;
4308
4309     wxRichTextBuffer* buffer = GetBuffer();
4310     wxRichTextStyleSheet* styleSheet = buffer->GetStyleSheet();
4311     if (styleSheet && !previousParagraph->GetAttributes().GetListStyleName().IsEmpty())
4312     {
4313         wxRichTextListStyleDefinition* def = styleSheet->FindListStyle(previousParagraph->GetAttributes().GetListStyleName());
4314         if (def)
4315         {
4316             // int thisIndent = previousParagraph->GetAttributes().GetLeftIndent();
4317             // int thisLevel = def->FindLevelForIndent(thisIndent);
4318
4319             bool isOutline = (previousParagraph->GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_OUTLINE) != 0;
4320
4321             attr.SetFlags(previousParagraph->GetAttributes().GetFlags() & (wxTEXT_ATTR_BULLET_STYLE|wxTEXT_ATTR_BULLET_NUMBER|wxTEXT_ATTR_BULLET_TEXT|wxTEXT_ATTR_BULLET_NAME));
4322             if (previousParagraph->GetAttributes().HasBulletName())
4323                 attr.SetBulletName(previousParagraph->GetAttributes().GetBulletName());
4324             attr.SetBulletStyle(previousParagraph->GetAttributes().GetBulletStyle());
4325             attr.SetListStyleName(previousParagraph->GetAttributes().GetListStyleName());
4326
4327             int nextNumber = previousParagraph->GetAttributes().GetBulletNumber() + 1;
4328             attr.SetBulletNumber(nextNumber);
4329
4330             if (isOutline)
4331             {
4332                 wxString text = previousParagraph->GetAttributes().GetBulletText();
4333                 if (!text.IsEmpty())
4334                 {
4335                     int pos = text.Find(wxT('.'), true);
4336                     if (pos != wxNOT_FOUND)
4337                     {
4338                         text = text.Mid(0, text.Length() - pos - 1);
4339                     }
4340                     else
4341                         text = wxEmptyString;
4342                     if (!text.IsEmpty())
4343                         text += wxT(".");
4344                     text += wxString::Format(wxT("%d"), nextNumber);
4345                     attr.SetBulletText(text);
4346                 }
4347             }
4348
4349             return true;
4350         }
4351         else
4352             return false;
4353     }
4354     else
4355         return false;
4356 }
4357
4358 /*!
4359  * wxRichTextParagraph
4360  * This object represents a single paragraph (or in a straight text editor, a line).
4361  */
4362
4363 IMPLEMENT_DYNAMIC_CLASS(wxRichTextParagraph, wxRichTextCompositeObject)
4364
4365 wxArrayInt wxRichTextParagraph::sm_defaultTabs;
4366
4367 wxRichTextParagraph::wxRichTextParagraph(wxRichTextObject* parent, wxRichTextAttr* style):
4368     wxRichTextCompositeObject(parent)
4369 {
4370     if (style)
4371         SetAttributes(*style);
4372 }
4373
4374 wxRichTextParagraph::wxRichTextParagraph(const wxString& text, wxRichTextObject* parent, wxRichTextAttr* paraStyle, wxRichTextAttr* charStyle):
4375     wxRichTextCompositeObject(parent)
4376 {
4377     if (paraStyle)
4378         SetAttributes(*paraStyle);
4379
4380     AppendChild(new wxRichTextPlainText(text, this, charStyle));
4381 }
4382
4383 wxRichTextParagraph::~wxRichTextParagraph()
4384 {
4385     ClearLines();
4386 }
4387
4388 /// Draw the item
4389 bool wxRichTextParagraph::Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int WXUNUSED(descent), int style)
4390 {
4391     if (!IsShown())
4392         return true;
4393
4394     // Currently we don't merge these attributes with the parent, but we
4395     // should consider whether we should (e.g. if we set a border colour
4396     // for all paragraphs). But generally box attributes are likely to be
4397     // different for different objects.
4398     wxRect paraRect = GetRect();
4399     wxRichTextAttr attr = GetCombinedAttributes();
4400     context.ApplyVirtualAttributes(attr, this);
4401
4402     DrawBoxAttributes(dc, GetBuffer(), attr, paraRect);
4403
4404     // Draw the bullet, if any
4405     if ((attr.GetBulletStyle() == wxTEXT_ATTR_BULLET_STYLE_NONE) == 0 && (attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_CONTINUATION) == 0)
4406     {
4407         if (attr.GetLeftSubIndent() != 0)
4408         {
4409             int spaceBeforePara = ConvertTenthsMMToPixels(dc, attr.GetParagraphSpacingBefore());
4410             int leftIndent = ConvertTenthsMMToPixels(dc, attr.GetLeftIndent());
4411
4412             wxRichTextAttr bulletAttr(attr);
4413
4414             // Combine with the font of the first piece of content, if one is specified
4415             if (GetChildren().GetCount() > 0)
4416             {
4417                 wxRichTextObject* firstObj = (wxRichTextObject*) GetChildren().GetFirst()->GetData();
4418                 if (!firstObj->IsFloatable() && firstObj->GetAttributes().HasFont())
4419                 {
4420                     wxRichTextApplyStyle(bulletAttr, firstObj->GetAttributes());
4421                 }
4422             }
4423
4424             // Get line height from first line, if any
4425             wxRichTextLine* line = m_cachedLines.GetFirst() ? (wxRichTextLine* ) m_cachedLines.GetFirst()->GetData() : NULL;
4426
4427             wxPoint linePos;
4428             int lineHeight wxDUMMY_INITIALIZE(0);
4429             if (line)
4430             {
4431                 lineHeight = line->GetSize().y;
4432                 linePos = line->GetPosition() + GetPosition();
4433             }
4434             else
4435             {
4436                 wxFont font;
4437                 if (bulletAttr.HasFont() && GetBuffer())
4438                     font = GetBuffer()->GetFontTable().FindFont(bulletAttr);
4439                 else
4440                     font = (*wxNORMAL_FONT);
4441
4442                 wxCheckSetFont(dc, font);
4443
4444                 lineHeight = dc.GetCharHeight();
4445                 linePos = GetPosition();
4446                 linePos.y += spaceBeforePara;
4447             }
4448
4449             wxRect bulletRect(GetPosition().x + leftIndent, linePos.y, linePos.x - (GetPosition().x + leftIndent), lineHeight);
4450
4451             if (attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_BITMAP)
4452             {
4453                 if (wxRichTextBuffer::GetRenderer())
4454                     wxRichTextBuffer::GetRenderer()->DrawBitmapBullet(this, dc, bulletAttr, bulletRect);
4455             }
4456             else if (attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_STANDARD)
4457             {
4458                 if (wxRichTextBuffer::GetRenderer())
4459                     wxRichTextBuffer::GetRenderer()->DrawStandardBullet(this, dc, bulletAttr, bulletRect);
4460             }
4461             else
4462             {
4463                 wxString bulletText = GetBulletText();
4464
4465                 if (!bulletText.empty() && wxRichTextBuffer::GetRenderer())
4466                     wxRichTextBuffer::GetRenderer()->DrawTextBullet(this, dc, bulletAttr, bulletRect, bulletText);
4467             }
4468         }
4469     }
4470
4471     // Draw the range for each line, one object at a time.
4472
4473     wxRichTextLineList::compatibility_iterator node = m_cachedLines.GetFirst();
4474     while (node)
4475     {
4476         wxRichTextLine* line = node->GetData();
4477         wxRichTextRange lineRange = line->GetAbsoluteRange();
4478
4479         // Lines are specified relative to the paragraph
4480
4481         wxPoint linePosition = line->GetPosition() + GetPosition();
4482
4483         // Don't draw if off the screen
4484         if (((style & wxRICHTEXT_DRAW_IGNORE_CACHE) != 0) || ((linePosition.y + line->GetSize().y) >= rect.y && linePosition.y <= rect.y + rect.height))
4485         {
4486             wxPoint objectPosition = linePosition;
4487             int maxDescent = line->GetDescent();
4488
4489             // Loop through objects until we get to the one within range
4490             wxRichTextObjectList::compatibility_iterator node2 = m_children.GetFirst();
4491
4492             int i = 0;
4493             while (node2)
4494             {
4495                 wxRichTextObject* child = node2->GetData();
4496
4497                 if (!child->IsFloating() && child->GetRange().GetLength() > 0 && !child->GetRange().IsOutside(lineRange) && !lineRange.IsOutside(range))
4498                 {
4499                     // Draw this part of the line at the correct position
4500                     wxRichTextRange objectRange(child->GetRange());
4501                     objectRange.LimitTo(lineRange);
4502
4503                     wxSize objectSize;
4504                     if (child->IsTopLevel())
4505                     {
4506                         objectSize = child->GetCachedSize();
4507                         objectRange = child->GetOwnRange();
4508                     }
4509                     else
4510                     {
4511 #if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING && wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
4512                         if (i < (int) line->GetObjectSizes().GetCount())
4513                         {
4514                             objectSize.x = line->GetObjectSizes()[(size_t) i];
4515                         }
4516                         else
4517 #endif
4518                         {
4519                             int descent = 0;
4520                             child->GetRangeSize(objectRange, objectSize, descent, dc, context, wxRICHTEXT_UNFORMATTED, objectPosition);
4521                         }
4522                     }
4523
4524                     // Use the child object's width, but the whole line's height
4525                     wxRect childRect(objectPosition, wxSize(objectSize.x, line->GetSize().y));
4526                     child->Draw(dc, context, objectRange, selection, childRect, maxDescent, style);
4527
4528                     objectPosition.x += objectSize.x;
4529                     i ++;
4530                 }
4531                 else if (child->GetRange().GetStart() > lineRange.GetEnd())
4532                     // Can break out of inner loop now since we've passed this line's range
4533                     break;
4534
4535                 node2 = node2->GetNext();
4536             }
4537         }
4538
4539         node = node->GetNext();
4540     }
4541
4542     return true;
4543 }
4544
4545 // Get the range width using partial extents calculated for the whole paragraph.
4546 static int wxRichTextGetRangeWidth(const wxRichTextParagraph& para, const wxRichTextRange& range, const wxArrayInt& partialExtents)
4547 {
4548     wxASSERT(partialExtents.GetCount() >= (size_t) range.GetLength());
4549
4550     if (partialExtents.GetCount() < (size_t) range.GetLength())
4551         return 0;
4552
4553     int leftMostPos = 0;
4554     if (range.GetStart() - para.GetRange().GetStart() > 0)
4555         leftMostPos = partialExtents[range.GetStart() - para.GetRange().GetStart() - 1];
4556
4557     int rightMostPos = partialExtents[range.GetEnd() - para.GetRange().GetStart()];
4558
4559     int w = rightMostPos - leftMostPos;
4560
4561     return w;
4562 }
4563
4564 /// Lay the item out
4565 bool wxRichTextParagraph::Layout(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, const wxRect& parentRect, int style)
4566 {
4567     // Deal with floating objects firstly before the normal layout
4568     wxRichTextBuffer* buffer = GetBuffer();
4569     wxASSERT(buffer);
4570     wxRichTextFloatCollector* collector = GetContainer()->GetFloatCollector();
4571     wxASSERT(collector);
4572     LayoutFloat(dc, context, rect, style, collector);
4573
4574     wxRichTextAttr attr = GetCombinedAttributes();
4575     context.ApplyVirtualAttributes(attr, this);
4576
4577     // ClearLines();
4578
4579     // Increase the size of the paragraph due to spacing
4580     int spaceBeforePara = ConvertTenthsMMToPixels(dc, attr.GetParagraphSpacingBefore());
4581     int spaceAfterPara = ConvertTenthsMMToPixels(dc, attr.GetParagraphSpacingAfter());
4582     int leftIndent = ConvertTenthsMMToPixels(dc, attr.GetLeftIndent());
4583     int leftSubIndent = ConvertTenthsMMToPixels(dc, attr.GetLeftSubIndent());
4584     int rightIndent = ConvertTenthsMMToPixels(dc, attr.GetRightIndent());
4585
4586     int lineSpacing = 0;
4587
4588     // Let's assume line spacing of 10 is normal, 15 is 1.5, 20 is 2, etc.
4589     if (attr.HasLineSpacing() && attr.GetLineSpacing() > 0 && attr.GetFont().IsOk())
4590     {
4591         wxCheckSetFont(dc, attr.GetFont());
4592         lineSpacing = (int) (double(dc.GetCharHeight()) * (double(attr.GetLineSpacing())/10.0 - 1.0));
4593     }
4594
4595     // Start position for each line relative to the paragraph
4596     int startPositionFirstLine = leftIndent;
4597     int startPositionSubsequentLines = leftIndent + leftSubIndent;
4598
4599     // If we have a bullet in this paragraph, the start position for the first line's text
4600     // is actually leftIndent + leftSubIndent.
4601     if (attr.GetBulletStyle() != wxTEXT_ATTR_BULLET_STYLE_NONE)
4602         startPositionFirstLine = startPositionSubsequentLines;
4603
4604     long lastEndPos = GetRange().GetStart()-1;
4605     long lastCompletedEndPos = lastEndPos;
4606
4607     int currentWidth = 0;
4608     SetPosition(rect.GetPosition());
4609
4610     wxPoint currentPosition(0, spaceBeforePara); // We will calculate lines relative to paragraph
4611     int lineHeight = 0;
4612     int maxWidth = 0;
4613     int maxHeight = currentPosition.y;
4614     int maxAscent = 0;
4615     int maxDescent = 0;
4616     int lineCount = 0;
4617     int lineAscent = 0;
4618     int lineDescent = 0;
4619
4620     wxRichTextObjectList::compatibility_iterator node;
4621
4622 #if wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
4623     wxUnusedVar(style);
4624     wxArrayInt partialExtents;
4625
4626     wxSize paraSize;
4627     int paraDescent = 0;
4628
4629     // This calculates the partial text extents
4630     GetRangeSize(GetRange(), paraSize, paraDescent, dc, context, wxRICHTEXT_UNFORMATTED|wxRICHTEXT_CACHE_SIZE, rect.GetPosition(), & partialExtents);
4631 #else
4632     node = m_children.GetFirst();
4633     while (node)
4634     {
4635         wxRichTextObject* child = node->GetData();
4636
4637         //child->SetCachedSize(wxDefaultSize);
4638         child->Layout(dc, context, rect, style);
4639
4640         node = node->GetNext();
4641     }
4642 #endif
4643
4644     // Split up lines
4645
4646     // We may need to go back to a previous child, in which case create the new line,
4647     // find the child corresponding to the start position of the string, and
4648     // continue.
4649
4650     wxRect availableRect;
4651
4652     node = m_children.GetFirst();
4653     while (node)
4654     {
4655         wxRichTextObject* child = node->GetData();
4656
4657         // If floating, ignore. We already laid out floats.
4658         // Also ignore if empty object, except if we haven't got any
4659         // size yet.
4660         if (child->IsFloating() || !child->IsShown() ||
4661             (child->GetRange().GetLength() == 0 && maxHeight > spaceBeforePara)
4662             )
4663         {
4664             node = node->GetNext();
4665             continue;
4666         }
4667
4668         // If this is e.g. a composite text box, it will need to be laid out itself.
4669         // But if just a text fragment or image, for example, this will
4670         // do nothing. NB: won't we need to set the position after layout?
4671         // since for example if position is dependent on vertical line size, we
4672         // can't tell the position until the size is determined. So possibly introduce
4673         // another layout phase.
4674
4675         // We may only be looking at part of a child, if we searched back for wrapping
4676         // and found a suitable point some way into the child. So get the size for the fragment
4677         // if necessary.
4678
4679         long nextBreakPos = GetFirstLineBreakPosition(lastEndPos+1);
4680         long lastPosToUse = child->GetRange().GetEnd();
4681         bool lineBreakInThisObject = (nextBreakPos > -1 && nextBreakPos <= child->GetRange().GetEnd());
4682
4683         if (lineBreakInThisObject)
4684             lastPosToUse = nextBreakPos;
4685
4686         wxSize childSize;
4687         int childDescent = 0;
4688
4689         int startOffset = (lineCount == 0 ? startPositionFirstLine : startPositionSubsequentLines);
4690         availableRect = wxRect(rect.x + startOffset, rect.y + currentPosition.y,
4691                                      rect.width - startOffset - rightIndent, rect.height);
4692
4693         if (child->IsTopLevel())
4694         {
4695             wxSize oldSize = child->GetCachedSize();
4696
4697             child->Invalidate(wxRICHTEXT_ALL);
4698             child->SetPosition(wxPoint(0, 0));
4699
4700             // Lays out the object first with a given amount of space, and then if no width was specified in attr,
4701             // lays out the object again using the minimum size
4702             // The position will be determined by its location in its line,
4703             // and not by the child's actual position.
4704             child->LayoutToBestSize(dc, context, buffer,
4705                     attr, child->GetAttributes(), availableRect, parentRect, style);
4706
4707             if (oldSize != child->GetCachedSize())
4708             {
4709                 partialExtents.Clear();
4710
4711                 // Recalculate the partial text extents since the child object changed size
4712                 GetRangeSize(GetRange(), paraSize, paraDescent, dc, context, wxRICHTEXT_UNFORMATTED|wxRICHTEXT_CACHE_SIZE, wxPoint(0,0), & partialExtents);
4713             }
4714         }
4715
4716         // Problem: we need to layout composites here for which we need the available width,
4717         // but we can't get the available width without using the float collector which
4718         // needs to know the object height.
4719
4720         if ((nextBreakPos == -1) && (lastEndPos == child->GetRange().GetStart() - 1)) // i.e. we want to get the whole thing
4721         {
4722             childSize = child->GetCachedSize();
4723             childDescent = child->GetDescent();
4724         }
4725         else
4726         {
4727 #if wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
4728             // Get height only, then the width using the partial extents
4729             GetRangeSize(wxRichTextRange(lastEndPos+1, lastPosToUse), childSize, childDescent, dc, context, wxRICHTEXT_UNFORMATTED|wxRICHTEXT_HEIGHT_ONLY);
4730             childSize.x = wxRichTextGetRangeWidth(*this, wxRichTextRange(lastEndPos+1, lastPosToUse), partialExtents);
4731 #else
4732             GetRangeSize(wxRichTextRange(lastEndPos+1, lastPosToUse), childSize, childDescent, dc, context, wxRICHTEXT_UNFORMATTED, rect.GetPosition());
4733 #endif
4734         }
4735
4736         bool doLoop = true;
4737         int loopIterations = 0;
4738
4739         // If there are nested objects that need to lay themselves out, we have to do this in a
4740         // loop because the height of the object may well depend on the available width.
4741         // And because of floating object positioning, the available width depends on the
4742         // height of the object and whether it will clash with the floating objects.
4743         // So, we see whether the available width changes due to the presence of floating images.
4744         // If it does, then we'll use the new restricted width to find the object height again.
4745         // If this causes another restriction in the available width, we'll try again, until
4746         // either we lose patience or the available width settles down.
4747         do
4748         {
4749             loopIterations ++;
4750
4751             wxRect oldAvailableRect = availableRect;
4752
4753             // Available width depends on the floating objects and the line height.
4754             // Note: the floating objects may be placed vertically along the two sides of
4755             // buffer, so we may have different available line widths with different
4756             // [startY, endY]. So, we can't determine how wide the available
4757             // space is until we know the exact line height.
4758             if (childDescent == 0)
4759             {
4760                 lineHeight = wxMax(lineHeight, childSize.y);
4761                 lineDescent = maxDescent;
4762                 lineAscent = maxAscent;
4763             }
4764             else
4765             {
4766                 lineDescent = wxMax(childDescent, maxDescent);
4767                 lineAscent = wxMax(childSize.y-childDescent, maxAscent);
4768             }
4769             lineHeight = wxMax(lineHeight, (lineDescent + lineAscent));
4770             wxRect floatAvailableRect = collector->GetAvailableRect(rect.y + currentPosition.y, rect.y + currentPosition.y + lineHeight);
4771
4772             // Adjust availableRect to the space that is available when taking floating objects into account.
4773
4774             if (floatAvailableRect.x + startOffset > availableRect.x)
4775             {
4776                 int newX = floatAvailableRect.x + startOffset;
4777                 int newW = availableRect.width - (newX - availableRect.x);
4778                 availableRect.x = newX;
4779                 availableRect.width = newW;
4780             }
4781
4782             if (floatAvailableRect.width < availableRect.width)
4783                 availableRect.width = floatAvailableRect.width;
4784
4785             currentPosition.x = availableRect.x - rect.x;
4786
4787             if (child->IsTopLevel() && loopIterations <= 20)
4788             {
4789                 if (availableRect != oldAvailableRect)
4790                 {
4791                     wxSize oldSize = child->GetCachedSize();
4792
4793                     // Lays out the object first with a given amount of space, and then if no width was specified in attr,
4794                     // lays out the object again using the minimum size
4795                     child->Invalidate(wxRICHTEXT_ALL);
4796                     child->LayoutToBestSize(dc, context, buffer,
4797                                 attr, child->GetAttributes(), availableRect, parentRect, style);
4798                     childSize = child->GetCachedSize();
4799                     childDescent = child->GetDescent();
4800
4801                     if (oldSize != child->GetCachedSize())
4802                     {
4803                         partialExtents.Clear();
4804
4805                         // Recalculate the partial text extents since the child object changed size
4806                         GetRangeSize(GetRange(), paraSize, paraDescent, dc, context, wxRICHTEXT_UNFORMATTED|wxRICHTEXT_CACHE_SIZE, wxPoint(0,0), & partialExtents);
4807                     }
4808
4809                     // Go around the loop finding the available rect for the given floating objects
4810                 }
4811                 else
4812                     doLoop = false;
4813             }
4814             else
4815                 doLoop = false;
4816         }
4817         while (doLoop);
4818
4819         if (child->IsTopLevel())
4820         {
4821             // We can move it to the correct position at this point
4822             // TODO: probably need to add margin
4823             child->Move(GetPosition() + wxPoint(currentWidth + (wxMax(leftIndent, leftIndent + leftSubIndent)), currentPosition.y));
4824         }
4825
4826         // Cases:
4827         // 1) There was a line break BEFORE the natural break
4828         // 2) There was a line break AFTER the natural break
4829         // 3) It's the last line
4830         // 4) The child still fits (carry on) - 'else' clause
4831
4832         if ((lineBreakInThisObject && (childSize.x + currentWidth <= availableRect.width))
4833             ||
4834             (childSize.x + currentWidth > availableRect.width)
4835             ||
4836             ((childSize.x + currentWidth <= availableRect.width) && !node->GetNext())
4837
4838             )
4839         {
4840             long wrapPosition = 0;
4841             if ((childSize.x + currentWidth <= availableRect.width) && !node->GetNext() && !lineBreakInThisObject)
4842                 wrapPosition = child->GetRange().GetEnd();
4843             else
4844
4845             // Find a place to wrap. This may walk back to previous children,
4846             // for example if a word spans several objects.
4847             // Note: one object must contains only one wxTextAtrr, so the line height will not
4848             //       change inside one object. Thus, we can pass the remain line width to the
4849             //       FindWrapPosition function.
4850             if (!FindWrapPosition(wxRichTextRange(lastCompletedEndPos+1, child->GetRange().GetEnd()), dc, context, availableRect.width, wrapPosition, & partialExtents))
4851             {
4852                 // If the function failed, just cut it off at the end of this child.
4853                 wrapPosition = child->GetRange().GetEnd();
4854             }
4855
4856             // FindWrapPosition can still return a value that will put us in an endless wrapping loop
4857             if (wrapPosition <= lastCompletedEndPos)
4858                 wrapPosition = wxMax(lastCompletedEndPos+1,child->GetRange().GetEnd());
4859
4860             // Line end position shouldn't be the same as the end, or greater.
4861             if (wrapPosition >= GetRange().GetEnd())
4862                 wrapPosition = wxMax(0, GetRange().GetEnd()-1);
4863
4864             // wxLogDebug(wxT("Split at %ld"), wrapPosition);
4865
4866             // Let's find the actual size of the current line now
4867             wxSize actualSize;
4868             wxRichTextRange actualRange(lastCompletedEndPos+1, wrapPosition);
4869
4870             childDescent = 0;
4871
4872 #if wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
4873             if (!child->IsEmpty())
4874             {
4875                 // Get height only, then the width using the partial extents
4876                 GetRangeSize(actualRange, actualSize, childDescent, dc, context, wxRICHTEXT_UNFORMATTED|wxRICHTEXT_HEIGHT_ONLY);
4877                 actualSize.x = wxRichTextGetRangeWidth(*this, actualRange, partialExtents);
4878             }
4879             else
4880 #endif
4881                 GetRangeSize(actualRange, actualSize, childDescent, dc, context, wxRICHTEXT_UNFORMATTED);
4882
4883             currentWidth = actualSize.x;
4884
4885             // The descent for the whole line at this point, is the correct max descent
4886             maxDescent = childDescent;
4887             // Maximum ascent
4888             maxAscent = actualSize.y-childDescent;
4889
4890             // lineHeight is given by the height for the whole line, since it will
4891             // take into account ascend/descend.
4892             lineHeight = actualSize.y;
4893
4894             if (lineHeight == 0 && buffer)
4895             {
4896                 wxFont font(buffer->GetFontTable().FindFont(attr));
4897                 wxCheckSetFont(dc, font);
4898                 lineHeight = dc.GetCharHeight();
4899             }
4900
4901             if (maxDescent == 0)
4902             {
4903                 int w, h;
4904                 dc.GetTextExtent(wxT("X"), & w, &h, & maxDescent);
4905             }
4906
4907             // Add a new line
4908             wxRichTextLine* line = AllocateLine(lineCount);
4909
4910             // Set relative range so we won't have to change line ranges when paragraphs are moved
4911             line->SetRange(wxRichTextRange(actualRange.GetStart() - GetRange().GetStart(), actualRange.GetEnd() - GetRange().GetStart()));
4912             line->SetPosition(currentPosition);
4913             line->SetSize(wxSize(currentWidth, lineHeight));
4914             line->SetDescent(maxDescent);
4915
4916             maxHeight = currentPosition.y + lineHeight;
4917
4918             // Now move down a line. TODO: add margins, spacing
4919             currentPosition.y += lineHeight;
4920             currentPosition.y += lineSpacing;
4921             maxDescent = 0;
4922             maxAscent = 0;
4923             maxWidth = wxMax(maxWidth, currentWidth+startOffset);
4924             currentWidth = 0;
4925
4926             lineCount ++;
4927
4928             // TODO: account for zero-length objects
4929             // wxASSERT(wrapPosition > lastCompletedEndPos);
4930
4931             lastEndPos = wrapPosition;
4932             lastCompletedEndPos = lastEndPos;
4933
4934             lineHeight = 0;
4935
4936             if (wrapPosition < GetRange().GetEnd()-1)
4937             {
4938                 // May need to set the node back to a previous one, due to searching back in wrapping
4939                 wxRichTextObject* childAfterWrapPosition = FindObjectAtPosition(wrapPosition+1);
4940                 if (childAfterWrapPosition)
4941                     node = m_children.Find(childAfterWrapPosition);
4942                 else
4943                     node = node->GetNext();
4944             }
4945             else
4946                 node = node->GetNext();
4947
4948             // Apply paragraph styles such as alignment to the wrapped line
4949             ApplyParagraphStyle(line, attr, availableRect, dc);
4950         }
4951         else
4952         {
4953             // We still fit, so don't add a line, and keep going
4954             currentWidth += childSize.x;
4955
4956             if (childDescent == 0)
4957             {
4958                 // An object with a zero descend value wants to take up the whole
4959                 // height regardless of baseline
4960                 lineHeight = wxMax(lineHeight, childSize.y);
4961             }
4962             else
4963             {
4964                 maxDescent = wxMax(childDescent, maxDescent);
4965                 maxAscent = wxMax(childSize.y-childDescent, maxAscent);
4966             }
4967
4968             lineHeight = wxMax(lineHeight, (maxDescent + maxAscent));
4969
4970             maxWidth = wxMax(maxWidth, currentWidth+startOffset);
4971             lastEndPos = child->GetRange().GetEnd();
4972
4973             node = node->GetNext();
4974         }
4975     }
4976
4977     //wxASSERT(!(lastCompletedEndPos != -1 && lastCompletedEndPos < GetRange().GetEnd()-1));
4978
4979     // Remove remaining unused line objects, if any
4980     ClearUnusedLines(lineCount);
4981
4982     // We need to add back the margins etc.
4983     {
4984         wxRect marginRect, borderRect, contentRect, paddingRect, outlineRect;
4985         contentRect = wxRect(wxPoint(0, 0), wxSize(maxWidth, currentPosition.y + spaceAfterPara));
4986         GetBoxRects(dc, buffer, attr, marginRect, borderRect, contentRect, paddingRect, outlineRect);
4987         SetCachedSize(marginRect.GetSize());
4988     }
4989
4990     // The maximum size is the length of the paragraph stretched out into a line.
4991     // So if there were a single word, or an image, or a fixed-size text box, the object could be shrunk around
4992     // this size. TODO: take into account line breaks.
4993     {
4994         wxRect marginRect, borderRect, contentRect, paddingRect, outlineRect;
4995         contentRect = wxRect(wxPoint(0, 0), wxSize(paraSize.x + wxMax(leftIndent, leftIndent + leftSubIndent) + rightIndent, currentPosition.y + spaceAfterPara));
4996         GetBoxRects(dc, buffer, attr, marginRect, borderRect, contentRect, paddingRect, outlineRect);
4997         SetMaxSize(marginRect.GetSize());
4998     }
4999
5000     // Find the greatest minimum size. Currently we only look at non-text objects,
5001     // which isn't ideal but it would be slow to find the maximum word width to
5002     // use as the minimum.
5003     {
5004         int minWidth = 0;
5005         node = m_children.GetFirst();
5006         while (node)
5007         {
5008             wxRichTextObject* child = node->GetData();
5009
5010             // If floating, ignore. We already laid out floats.
5011             // Also ignore if empty object, except if we haven't got any
5012             // size yet.
5013             if (!child->IsFloating() && child->GetRange().GetLength() != 0 && !wxDynamicCast(child, wxRichTextPlainText))
5014             {
5015                 if (child->GetCachedSize().x > minWidth)
5016                     minWidth = child->GetMinSize().x;
5017             }
5018             node = node->GetNext();
5019         }
5020
5021         wxRect marginRect, borderRect, contentRect, paddingRect, outlineRect;
5022         contentRect = wxRect(wxPoint(0, 0), wxSize(minWidth, currentPosition.y + spaceAfterPara));
5023         GetBoxRects(dc, buffer, attr, marginRect, borderRect, contentRect, paddingRect, outlineRect);
5024         SetMinSize(marginRect.GetSize());
5025     }
5026
5027 #if wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
5028 #if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING
5029     // Use the text extents to calculate the size of each fragment in each line
5030     wxRichTextLineList::compatibility_iterator lineNode = m_cachedLines.GetFirst();
5031     while (lineNode)
5032     {
5033         wxRichTextLine* line = lineNode->GetData();
5034         wxRichTextRange lineRange = line->GetAbsoluteRange();
5035
5036         // Loop through objects until we get to the one within range
5037         wxRichTextObjectList::compatibility_iterator node2 = m_children.GetFirst();
5038
5039         while (node2)
5040         {
5041             wxRichTextObject* child = node2->GetData();
5042
5043             if (child->GetRange().GetLength() > 0 && !child->GetRange().IsOutside(lineRange))
5044             {
5045                 wxRichTextRange rangeToUse = lineRange;
5046                 rangeToUse.LimitTo(child->GetRange());
5047
5048                 // Find the size of the child from the text extents, and store in an array
5049                 // for drawing later
5050                 int left = 0;
5051                 if (rangeToUse.GetStart() > GetRange().GetStart())
5052                     left = partialExtents[(rangeToUse.GetStart()-1) - GetRange().GetStart()];
5053                 int right = partialExtents[rangeToUse.GetEnd() - GetRange().GetStart()];
5054                 int sz = right - left;
5055                 line->GetObjectSizes().Add(sz);
5056             }
5057             else if (child->GetRange().GetStart() > lineRange.GetEnd())
5058                 // Can break out of inner loop now since we've passed this line's range
5059                 break;
5060
5061             node2 = node2->GetNext();
5062         }
5063
5064         lineNode = lineNode->GetNext();
5065     }
5066 #endif
5067 #endif
5068
5069     return true;
5070 }
5071
5072 /// Apply paragraph styles, such as centering, to wrapped lines
5073 /// TODO: take into account box attributes, possibly
5074 void wxRichTextParagraph::ApplyParagraphStyle(wxRichTextLine* line, const wxRichTextAttr& attr, const wxRect& rect, wxDC& dc)
5075 {
5076     if (!attr.HasAlignment())
5077         return;
5078
5079     wxPoint pos = line->GetPosition();
5080     wxPoint originalPos = pos;
5081     wxSize size = line->GetSize();
5082
5083     // centering, right-justification
5084     if (attr.HasAlignment() && attr.GetAlignment() == wxTEXT_ALIGNMENT_CENTRE)
5085     {
5086         int rightIndent = ConvertTenthsMMToPixels(dc, attr.GetRightIndent());
5087         pos.x = (rect.GetWidth() - rightIndent - size.x)/2 + pos.x;
5088         line->SetPosition(pos);
5089     }
5090     else if (attr.HasAlignment() && attr.GetAlignment() == wxTEXT_ALIGNMENT_RIGHT)
5091     {
5092         int rightIndent = ConvertTenthsMMToPixels(dc, attr.GetRightIndent());
5093         pos.x = pos.x + rect.GetWidth() - size.x - rightIndent;
5094         line->SetPosition(pos);
5095     }
5096
5097     if (pos != originalPos)
5098     {
5099         wxPoint inc = pos - originalPos;
5100
5101         wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
5102
5103         while (node)
5104         {
5105             wxRichTextObject* child = node->GetData();
5106             if (child->IsTopLevel() && !child->GetRange().IsOutside(line->GetAbsoluteRange()))
5107                 child->Move(child->GetPosition() + inc);
5108
5109             node = node->GetNext();
5110         }
5111     }
5112 }
5113
5114 /// Insert text at the given position
5115 bool wxRichTextParagraph::InsertText(long pos, const wxString& text)
5116 {
5117     wxRichTextObject* childToUse = NULL;
5118     wxRichTextObjectList::compatibility_iterator nodeToUse = wxRichTextObjectList::compatibility_iterator();
5119
5120     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
5121     while (node)
5122     {
5123         wxRichTextObject* child = node->GetData();
5124         if (child->GetRange().Contains(pos) && child->GetRange().GetLength() > 0)
5125         {
5126             childToUse = child;
5127             nodeToUse = node;
5128             break;
5129         }
5130
5131         node = node->GetNext();
5132     }
5133
5134     if (childToUse)
5135     {
5136         wxRichTextPlainText* textObject = wxDynamicCast(childToUse, wxRichTextPlainText);
5137         if (textObject)
5138         {
5139             int posInString = pos - textObject->GetRange().GetStart();
5140
5141             wxString newText = textObject->GetText().Mid(0, posInString) +
5142                                text + textObject->GetText().Mid(posInString);
5143             textObject->SetText(newText);
5144
5145             int textLength = text.length();
5146
5147             textObject->SetRange(wxRichTextRange(textObject->GetRange().GetStart(),
5148                                                  textObject->GetRange().GetEnd() + textLength));
5149
5150             // Increment the end range of subsequent fragments in this paragraph.
5151             // We'll set the paragraph range itself at a higher level.
5152
5153             wxRichTextObjectList::compatibility_iterator node = nodeToUse->GetNext();
5154             while (node)
5155             {
5156                 wxRichTextObject* child = node->GetData();
5157                 child->SetRange(wxRichTextRange(textObject->GetRange().GetStart() + textLength,
5158                                                  textObject->GetRange().GetEnd() + textLength));
5159
5160                 node = node->GetNext();
5161             }
5162
5163             return true;
5164         }
5165         else
5166         {
5167             // TODO: if not a text object, insert at closest position, e.g. in front of it
5168         }
5169     }
5170     else
5171     {
5172         // Add at end.
5173         // Don't pass parent initially to suppress auto-setting of parent range.
5174         // We'll do that at a higher level.
5175         wxRichTextPlainText* textObject = new wxRichTextPlainText(text, this);
5176
5177         AppendChild(textObject);
5178         return true;
5179     }
5180
5181     return false;
5182 }
5183
5184 void wxRichTextParagraph::Copy(const wxRichTextParagraph& obj)
5185 {
5186     wxRichTextCompositeObject::Copy(obj);
5187 }
5188
5189 /// Clear the cached lines
5190 void wxRichTextParagraph::ClearLines()
5191 {
5192     WX_CLEAR_LIST(wxRichTextLineList, m_cachedLines);
5193 }
5194
5195 /// Get/set the object size for the given range. Returns false if the range
5196 /// is invalid for this object.
5197 bool wxRichTextParagraph::GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int flags, wxPoint position, wxArrayInt* partialExtents) const
5198 {
5199     if (!range.IsWithin(GetRange()))
5200         return false;
5201
5202     if (flags & wxRICHTEXT_UNFORMATTED)
5203     {
5204         // Just use unformatted data, assume no line breaks
5205         wxSize sz;
5206
5207         wxArrayInt childExtents;
5208         wxArrayInt* p;
5209         if (partialExtents)
5210             p = & childExtents;
5211         else
5212             p = NULL;
5213
5214         int maxDescent = 0;
5215         int maxAscent = 0;
5216         int maxLineHeight = 0;
5217
5218         wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
5219         while (node)
5220         {
5221             wxRichTextObject* child = node->GetData();
5222             if (!child->GetRange().IsOutside(range))
5223             {
5224                 // Floating objects have a zero size within the paragraph.
5225                 if (child->IsFloating())
5226                 {
5227                     if (partialExtents)
5228                     {
5229                         int lastSize;
5230                         if (partialExtents->GetCount() > 0)
5231                             lastSize = (*partialExtents)[partialExtents->GetCount()-1];
5232                         else
5233                             lastSize = 0;
5234
5235                         partialExtents->Add(0 /* zero size */ + lastSize);
5236                     }
5237                 }
5238                 else
5239                 {
5240                     wxSize childSize;
5241
5242                     wxRichTextRange rangeToUse = range;
5243                     rangeToUse.LimitTo(child->GetRange());
5244                     int childDescent = 0;
5245
5246                     // At present wxRICHTEXT_HEIGHT_ONLY is only fast if we've already cached the size,
5247                     // but it's only going to be used after caching has taken place.
5248                     if ((flags & wxRICHTEXT_HEIGHT_ONLY) && child->GetCachedSize().y != 0)
5249                     {
5250                         childDescent = child->GetDescent();
5251                         childSize = child->GetCachedSize();
5252
5253                         if (childDescent == 0)
5254                         {
5255                             maxLineHeight = wxMax(maxLineHeight, childSize.y);
5256                         }
5257                         else
5258                         {
5259                             maxDescent = wxMax(maxDescent, childDescent);
5260                             maxAscent = wxMax(maxAscent, (childSize.y - childDescent));
5261                         }
5262
5263                         maxLineHeight = wxMax(maxLineHeight, (maxAscent + maxDescent));
5264
5265                         sz.y = wxMax(sz.y, maxLineHeight);
5266                         sz.x += childSize.x;
5267                         descent = maxDescent;
5268                     }
5269                     else if (child->IsTopLevel())
5270                     {
5271                         childDescent = child->GetDescent();
5272                         childSize = child->GetCachedSize();
5273
5274                         if (childDescent == 0)
5275                         {
5276                             maxLineHeight = wxMax(maxLineHeight, childSize.y);
5277                         }
5278                         else
5279                         {
5280                             maxDescent = wxMax(maxDescent, childDescent);
5281                             maxAscent = wxMax(maxAscent, (childSize.y - childDescent));
5282                         }
5283
5284                         maxLineHeight = wxMax(maxLineHeight, (maxAscent + maxDescent));
5285
5286                         sz.y = wxMax(sz.y, maxLineHeight);
5287                         sz.x += childSize.x;
5288                         descent = maxDescent;
5289
5290                         // FIXME: this won't change the original values.
5291                         // Should we be calling GetRangeSize above instead of using cached values?
5292 #if 0
5293                         if ((flags & wxRICHTEXT_CACHE_SIZE) && (rangeToUse == child->GetRange()))
5294                         {
5295                             child->SetCachedSize(childSize);
5296                             child->SetDescent(childDescent);
5297                         }
5298 #endif
5299
5300                         if (partialExtents)
5301                         {
5302                             int lastSize;
5303                             if (partialExtents->GetCount() > 0)
5304                                 lastSize = (*partialExtents)[partialExtents->GetCount()-1];
5305                             else
5306                                 lastSize = 0;
5307
5308                             partialExtents->Add(childSize.x + lastSize);
5309                         }
5310                     }
5311                     else if (child->GetRangeSize(rangeToUse, childSize, childDescent, dc, context, flags, wxPoint(position.x + sz.x, position.y), p))
5312                     {
5313                         if (childDescent == 0)
5314                         {
5315                             maxLineHeight = wxMax(maxLineHeight, childSize.y);
5316                         }
5317                         else
5318                         {
5319                             maxDescent = wxMax(maxDescent, childDescent);
5320                             maxAscent = wxMax(maxAscent, (childSize.y - childDescent));
5321                         }
5322
5323                         maxLineHeight = wxMax(maxLineHeight, (maxAscent + maxDescent));
5324
5325                         sz.y = wxMax(sz.y, maxLineHeight);
5326                         sz.x += childSize.x;
5327                         descent = maxDescent;
5328
5329                         if ((flags & wxRICHTEXT_CACHE_SIZE) && (rangeToUse == child->GetRange()))
5330                         {
5331                             child->SetCachedSize(childSize);
5332                             child->SetDescent(childDescent);
5333                         }
5334
5335                         if (partialExtents)
5336                         {
5337                             int lastSize;
5338                             if (partialExtents->GetCount() > 0)
5339                                 lastSize = (*partialExtents)[partialExtents->GetCount()-1];
5340                             else
5341                                 lastSize = 0;
5342
5343                             size_t i;
5344                             for (i = 0; i < childExtents.GetCount(); i++)
5345                             {
5346                                 partialExtents->Add(childExtents[i] + lastSize);
5347                             }
5348                         }
5349                     }
5350                 }
5351
5352                 if (p)
5353                     p->Clear();
5354             }
5355
5356             node = node->GetNext();
5357         }
5358         size = sz;
5359     }
5360     else
5361     {
5362         // Use formatted data, with line breaks
5363         wxSize sz;
5364
5365         // We're going to loop through each line, and then for each line,
5366         // call GetRangeSize for the fragment that comprises that line.
5367         // Only we have to do that multiple times within the line, because
5368         // the line may be broken into pieces. For now ignore line break commands
5369         // (so we can assume that getting the unformatted size for a fragment
5370         // within a line is the actual size)
5371
5372         wxRichTextLineList::compatibility_iterator node = m_cachedLines.GetFirst();
5373         while (node)
5374         {
5375             wxRichTextLine* line = node->GetData();
5376             wxRichTextRange lineRange = line->GetAbsoluteRange();
5377             if (!lineRange.IsOutside(range))
5378             {
5379                 int maxDescent = 0;
5380                 int maxAscent = 0;
5381                 int maxLineHeight = 0;
5382                 int maxLineWidth = 0;
5383
5384                 wxRichTextObjectList::compatibility_iterator node2 = m_children.GetFirst();
5385                 while (node2)
5386                 {
5387                     wxRichTextObject* child = node2->GetData();
5388
5389                     if (!child->IsFloating() && !child->GetRange().IsOutside(lineRange))
5390                     {
5391                         wxRichTextRange rangeToUse = lineRange;
5392                         rangeToUse.LimitTo(child->GetRange());
5393                         if (child->IsTopLevel())
5394                             rangeToUse = child->GetOwnRange();
5395
5396                         wxSize childSize;
5397                         int childDescent = 0;
5398                         if (child->GetRangeSize(rangeToUse, childSize, childDescent, dc, context, flags, wxPoint(position.x + sz.x, position.y)))
5399                         {
5400                             if (childDescent == 0)
5401                             {
5402                                 // Assume that if descent is zero, this child can occupy the full line height
5403                                 // and does not need space for the line's maximum descent. So we influence
5404                                 // the overall max line height only.
5405                                 maxLineHeight = wxMax(maxLineHeight, childSize.y);
5406                             }
5407                             else
5408                             {
5409                                 maxAscent = wxMax(maxAscent, (childSize.y - childDescent));
5410                                 maxDescent = wxMax(maxAscent, childDescent);
5411                             }
5412                             maxLineHeight = wxMax(maxLineHeight, (maxAscent + maxDescent));
5413                             maxLineWidth += childSize.x;
5414                         }
5415                     }
5416
5417                     node2 = node2->GetNext();
5418                 }
5419
5420                 descent = wxMax(descent, maxDescent);
5421
5422                 // Increase size by a line (TODO: paragraph spacing)
5423                 sz.y += maxLineHeight;
5424                 sz.x = wxMax(sz.x, maxLineWidth);
5425             }
5426             node = node->GetNext();
5427         }
5428         size = sz;
5429     }
5430     return true;
5431 }
5432
5433 /// Finds the absolute position and row height for the given character position
5434 bool wxRichTextParagraph::FindPosition(wxDC& dc, wxRichTextDrawingContext& context, long index, wxPoint& pt, int* height, bool forceLineStart)
5435 {
5436     if (index == -1)
5437     {
5438         wxRichTextLine* line = ((wxRichTextParagraphLayoutBox*)GetParent())->GetLineAtPosition(0);
5439         if (line)
5440             *height = line->GetSize().y;
5441         else
5442             *height = dc.GetCharHeight();
5443
5444         // -1 means 'the start of the buffer'.
5445         pt = GetPosition();
5446         if (line)
5447             pt = pt + line->GetPosition();
5448
5449         return true;
5450     }
5451
5452     // The final position in a paragraph is taken to mean the position
5453     // at the start of the next paragraph.
5454     if (index == GetRange().GetEnd())
5455     {
5456         wxRichTextParagraphLayoutBox* parent = wxDynamicCast(GetParent(), wxRichTextParagraphLayoutBox);
5457         wxASSERT( parent != NULL );
5458
5459         // Find the height at the next paragraph, if any
5460         wxRichTextLine* line = parent->GetLineAtPosition(index + 1);
5461         if (line)
5462         {
5463             *height = line->GetSize().y;
5464             pt = line->GetAbsolutePosition();
5465         }
5466         else
5467         {
5468             *height = dc.GetCharHeight();
5469             int indent = ConvertTenthsMMToPixels(dc, m_attributes.GetLeftIndent());
5470             pt = wxPoint(indent, GetCachedSize().y);
5471         }
5472
5473         return true;
5474     }
5475
5476     if (index < GetRange().GetStart() || index > GetRange().GetEnd())
5477         return false;
5478
5479     wxRichTextLineList::compatibility_iterator node = m_cachedLines.GetFirst();
5480     while (node)
5481     {
5482         wxRichTextLine* line = node->GetData();
5483         wxRichTextRange lineRange = line->GetAbsoluteRange();
5484         if (index >= lineRange.GetStart() && index <= lineRange.GetEnd())
5485         {
5486             // If this is the last point in the line, and we're forcing the
5487             // returned value to be the start of the next line, do the required
5488             // thing.
5489             if (index == lineRange.GetEnd() && forceLineStart)
5490             {
5491                 if (node->GetNext())
5492                 {
5493                     wxRichTextLine* nextLine = node->GetNext()->GetData();
5494                     *height = nextLine->GetSize().y;
5495                     pt = nextLine->GetAbsolutePosition();
5496                     return true;
5497                 }
5498             }
5499
5500             pt.y = line->GetPosition().y + GetPosition().y;
5501
5502             wxRichTextRange r(lineRange.GetStart(), index);
5503             wxSize rangeSize;
5504             int descent = 0;
5505
5506             // We find the size of the line up to this point,
5507             // then we can add this size to the line start position and
5508             // paragraph start position to find the actual position.
5509
5510             if (GetRangeSize(r, rangeSize, descent, dc, context, wxRICHTEXT_UNFORMATTED, line->GetPosition()+ GetPosition()))
5511             {
5512                 pt.x = line->GetPosition().x + GetPosition().x + rangeSize.x;
5513                 *height = line->GetSize().y;
5514
5515                 return true;
5516             }
5517
5518         }
5519
5520         node = node->GetNext();
5521     }
5522
5523     return false;
5524 }
5525
5526 /// Hit-testing: returns a flag indicating hit test details, plus
5527 /// information about position
5528 int wxRichTextParagraph::HitTest(wxDC& dc, wxRichTextDrawingContext& context, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags)
5529 {
5530     if (!IsShown())
5531         return wxRICHTEXT_HITTEST_NONE;
5532
5533     // If we're in the top-level container, then we can return
5534     // a suitable hit test code even if the point is outside the container area,
5535     // so that we can position the caret sensibly even if we don't
5536     // click on valid content. If we're not at the top-level, and the point
5537     // is not within this paragraph object, then we don't want to stop more
5538     // precise hit-testing from working prematurely, so return immediately.
5539     // NEW STRATEGY: use the parent boundary to test whether we're in the
5540     // right region, not the paragraph, since the paragraph may be positioned
5541     // some way in from where the user clicks.
5542     {
5543         long tmpPos;
5544         wxRichTextObject* tempObj, *tempContextObj;
5545         if (GetParent() && GetParent()->wxRichTextObject::HitTest(dc, context, pt, tmpPos, & tempObj, & tempContextObj, flags) == wxRICHTEXT_HITTEST_NONE)
5546             return wxRICHTEXT_HITTEST_NONE;
5547     }
5548
5549     wxRichTextObjectList::compatibility_iterator objNode = m_children.GetFirst();
5550     while (objNode)
5551     {
5552         wxRichTextObject* child = objNode->GetData();
5553         // Don't recurse if we have wxRICHTEXT_HITTEST_NO_NESTED_OBJECTS,
5554         // and also, if this seems composite but actually is marked as atomic,
5555         // don't recurse.
5556         if (child->IsTopLevel() && ((flags & wxRICHTEXT_HITTEST_NO_NESTED_OBJECTS) == 0) &&
5557             (! (((flags & wxRICHTEXT_HITTEST_HONOUR_ATOMIC) != 0) && child->IsAtomic())))
5558         {
5559             {
5560                 int hitTest = child->HitTest(dc, context, pt, textPosition, obj, contextObj);
5561                 if (hitTest != wxRICHTEXT_HITTEST_NONE)
5562                     return hitTest;
5563             }
5564         }
5565
5566         objNode = objNode->GetNext();
5567     }
5568
5569     wxPoint paraPos = GetPosition();
5570
5571     wxRichTextLineList::compatibility_iterator node = m_cachedLines.GetFirst();
5572     while (node)
5573     {
5574         wxRichTextLine* line = node->GetData();
5575         wxPoint linePos = paraPos + line->GetPosition();
5576         wxSize lineSize = line->GetSize();
5577         wxRichTextRange lineRange = line->GetAbsoluteRange();
5578
5579         if (pt.y <= linePos.y + lineSize.y)
5580         {
5581             if (pt.x < linePos.x)
5582             {
5583                 textPosition = lineRange.GetStart();
5584                 *obj = FindObjectAtPosition(textPosition);
5585                 *contextObj = GetContainer();
5586                 return wxRICHTEXT_HITTEST_BEFORE|wxRICHTEXT_HITTEST_OUTSIDE;
5587             }
5588             else if (pt.x >= (linePos.x + lineSize.x))
5589             {
5590                 textPosition = lineRange.GetEnd();
5591                 *obj = FindObjectAtPosition(textPosition);
5592                 *contextObj = GetContainer();
5593                 return wxRICHTEXT_HITTEST_AFTER|wxRICHTEXT_HITTEST_OUTSIDE;
5594             }
5595             else
5596             {
5597 #if wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
5598                 wxArrayInt partialExtents;
5599
5600                 wxSize paraSize;
5601                 int paraDescent;
5602
5603                 // This calculates the partial text extents
5604                 GetRangeSize(lineRange, paraSize, paraDescent, dc, context, wxRICHTEXT_UNFORMATTED, linePos, & partialExtents);
5605
5606                 int lastX = linePos.x;
5607                 size_t i;
5608                 for (i = 0; i < partialExtents.GetCount(); i++)
5609                 {
5610                     int nextX = partialExtents[i] + linePos.x;
5611
5612                     if (pt.x >= lastX && pt.x <= nextX)
5613                     {
5614                         textPosition = i + lineRange.GetStart(); // minus 1?
5615
5616                         *obj = FindObjectAtPosition(textPosition);
5617                         *contextObj = GetContainer();
5618
5619                         // So now we know it's between i-1 and i.
5620                         // Let's see if we can be more precise about
5621                         // which side of the position it's on.
5622
5623                         int midPoint = (nextX + lastX)/2;
5624                         if (pt.x >= midPoint)
5625                             return wxRICHTEXT_HITTEST_AFTER;
5626                         else
5627                             return wxRICHTEXT_HITTEST_BEFORE;
5628                     }
5629
5630                     lastX = nextX;
5631                 }
5632 #else
5633                 long i;
5634                 int lastX = linePos.x;
5635                 for (i = lineRange.GetStart(); i <= lineRange.GetEnd(); i++)
5636                 {
5637                     wxSize childSize;
5638                     int descent = 0;
5639
5640                     wxRichTextRange rangeToUse(lineRange.GetStart(), i);
5641
5642                     GetRangeSize(rangeToUse, childSize, descent, dc, context, wxRICHTEXT_UNFORMATTED, linePos);
5643
5644                     int nextX = childSize.x + linePos.x;
5645
5646                     if (pt.x >= lastX && pt.x <= nextX)
5647                     {
5648                         textPosition = i;
5649
5650                         *obj = FindObjectAtPosition(textPosition);
5651                         *contextObj = GetContainer();
5652
5653                         // So now we know it's between i-1 and i.
5654                         // Let's see if we can be more precise about
5655                         // which side of the position it's on.
5656
5657                         int midPoint = (nextX + lastX)/2;
5658                         if (pt.x >= midPoint)
5659                             return wxRICHTEXT_HITTEST_AFTER;
5660                         else
5661                             return wxRICHTEXT_HITTEST_BEFORE;
5662                     }
5663                     else
5664                     {
5665                         lastX = nextX;
5666                     }
5667                 }
5668 #endif
5669             }
5670         }
5671
5672         node = node->GetNext();
5673     }
5674
5675     return wxRICHTEXT_HITTEST_NONE;
5676 }
5677
5678 /// Split an object at this position if necessary, and return
5679 /// the previous object, or NULL if inserting at beginning.
5680 wxRichTextObject* wxRichTextParagraph::SplitAt(long pos, wxRichTextObject** previousObject)
5681 {
5682     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
5683     while (node)
5684     {
5685         wxRichTextObject* child = node->GetData();
5686
5687         if (pos == child->GetRange().GetStart())
5688         {
5689             if (previousObject)
5690             {
5691                 if (node->GetPrevious())
5692                     *previousObject = node->GetPrevious()->GetData();
5693                 else
5694                     *previousObject = NULL;
5695             }
5696
5697             return child;
5698         }
5699
5700         if (child->GetRange().Contains(pos))
5701         {
5702             // This should create a new object, transferring part of
5703             // the content to the old object and the rest to the new object.
5704             wxRichTextObject* newObject = child->DoSplit(pos);
5705
5706             // If we couldn't split this object, just insert in front of it.
5707             if (!newObject)
5708             {
5709                 // Maybe this is an empty string, try the next one
5710                 // return child;
5711             }
5712             else
5713             {
5714                 // Insert the new object after 'child'
5715                 if (node->GetNext())
5716                     m_children.Insert(node->GetNext(), newObject);
5717                 else
5718                     m_children.Append(newObject);
5719                 newObject->SetParent(this);
5720
5721                 if (previousObject)
5722                     *previousObject = child;
5723
5724                 return newObject;
5725             }
5726         }
5727
5728         node = node->GetNext();
5729     }
5730     if (previousObject)
5731         *previousObject = NULL;
5732     return NULL;
5733 }
5734
5735 /// Move content to a list from obj on
5736 void wxRichTextParagraph::MoveToList(wxRichTextObject* obj, wxList& list)
5737 {
5738     wxRichTextObjectList::compatibility_iterator node = m_children.Find(obj);
5739     while (node)
5740     {
5741         wxRichTextObject* child = node->GetData();
5742         list.Append(child);
5743
5744         wxRichTextObjectList::compatibility_iterator oldNode = node;
5745
5746         node = node->GetNext();
5747
5748         m_children.DeleteNode(oldNode);
5749     }
5750 }
5751
5752 /// Add content back from list
5753 void wxRichTextParagraph::MoveFromList(wxList& list)
5754 {
5755     for (wxList::compatibility_iterator node = list.GetFirst(); node; node = node->GetNext())
5756     {
5757         AppendChild((wxRichTextObject*) node->GetData());
5758     }
5759 }
5760
5761 /// Calculate range
5762 void wxRichTextParagraph::CalculateRange(long start, long& end)
5763 {
5764     wxRichTextCompositeObject::CalculateRange(start, end);
5765
5766     // Add one for end of paragraph
5767     end ++;
5768
5769     m_range.SetRange(start, end);
5770 }
5771
5772 /// Find the object at the given position
5773 wxRichTextObject* wxRichTextParagraph::FindObjectAtPosition(long position)
5774 {
5775     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
5776     while (node)
5777     {
5778         wxRichTextObject* obj = node->GetData();
5779         if (obj->GetRange().Contains(position) ||
5780             obj->GetRange().GetStart() == position ||
5781             obj->GetRange().GetEnd() == position)
5782             return obj;
5783
5784         node = node->GetNext();
5785     }
5786     return NULL;
5787 }
5788
5789 /// Get the plain text searching from the start or end of the range.
5790 /// The resulting string may be shorter than the range given.
5791 bool wxRichTextParagraph::GetContiguousPlainText(wxString& text, const wxRichTextRange& range, bool fromStart)
5792 {
5793     text = wxEmptyString;
5794
5795     if (fromStart)
5796     {
5797         wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
5798         while (node)
5799         {
5800             wxRichTextObject* obj = node->GetData();
5801             if (!obj->GetRange().IsOutside(range))
5802             {
5803                 wxRichTextPlainText* textObj = wxDynamicCast(obj, wxRichTextPlainText);
5804                 if (textObj)
5805                 {
5806                     text += textObj->GetTextForRange(range);
5807                 }
5808                 else
5809                 {
5810                     text += wxT(" ");
5811                 }
5812             }
5813
5814             node = node->GetNext();
5815         }
5816     }
5817     else
5818     {
5819         wxRichTextObjectList::compatibility_iterator node = m_children.GetLast();
5820         while (node)
5821         {
5822             wxRichTextObject* obj = node->GetData();
5823             if (!obj->GetRange().IsOutside(range))
5824             {
5825                 wxRichTextPlainText* textObj = wxDynamicCast(obj, wxRichTextPlainText);
5826                 if (textObj)
5827                 {
5828                     text = textObj->GetTextForRange(range) + text;
5829                 }
5830                 else
5831                 {
5832                     text = wxT(" ") + text;
5833                 }
5834             }
5835
5836             node = node->GetPrevious();
5837         }
5838     }
5839
5840     return true;
5841 }
5842
5843 /// Find a suitable wrap position.
5844 bool wxRichTextParagraph::FindWrapPosition(const wxRichTextRange& range, wxDC& dc, wxRichTextDrawingContext& context, int availableSpace, long& wrapPosition, wxArrayInt* partialExtents)
5845 {
5846     if (range.GetLength() <= 0)
5847         return false;
5848
5849     // Find the first position where the line exceeds the available space.
5850     wxSize sz;
5851     long breakPosition = range.GetEnd();
5852
5853 #if wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
5854     if (partialExtents && partialExtents->GetCount() >= (size_t) (GetRange().GetLength()-1)) // the final position in a paragraph is the newline
5855     {
5856         int widthBefore;
5857
5858         if (range.GetStart() > GetRange().GetStart())
5859             widthBefore = (*partialExtents)[range.GetStart() - GetRange().GetStart() - 1];
5860         else
5861             widthBefore = 0;
5862
5863         size_t i;
5864         for (i = (size_t) range.GetStart(); i <= (size_t) range.GetEnd(); i++)
5865         {
5866             int widthFromStartOfThisRange = (*partialExtents)[i - GetRange().GetStart()] - widthBefore;
5867
5868             if (widthFromStartOfThisRange > availableSpace)
5869             {
5870                 breakPosition = i-1;
5871                 break;
5872             }
5873         }
5874     }
5875     else
5876 #endif
5877     {
5878         // Binary chop for speed
5879         long minPos = range.GetStart();
5880         long maxPos = range.GetEnd();
5881         while (true)
5882         {
5883             if (minPos == maxPos)
5884             {
5885                 int descent = 0;
5886                 GetRangeSize(wxRichTextRange(range.GetStart(), minPos), sz, descent, dc, context, wxRICHTEXT_UNFORMATTED);
5887
5888                 if (sz.x > availableSpace)
5889                     breakPosition = minPos - 1;
5890                 break;
5891             }
5892             else if ((maxPos - minPos) == 1)
5893             {
5894                 int descent = 0;
5895                 GetRangeSize(wxRichTextRange(range.GetStart(), minPos), sz, descent, dc, context, wxRICHTEXT_UNFORMATTED);
5896
5897                 if (sz.x > availableSpace)
5898                     breakPosition = minPos - 1;
5899                 else
5900                 {
5901                     GetRangeSize(wxRichTextRange(range.GetStart(), maxPos), sz, descent, dc, context, wxRICHTEXT_UNFORMATTED);
5902                     if (sz.x > availableSpace)
5903                         breakPosition = maxPos-1;
5904                 }
5905                 break;
5906             }
5907             else
5908             {
5909                 long nextPos = minPos + ((maxPos - minPos) / 2);
5910
5911                 int descent = 0;
5912                 GetRangeSize(wxRichTextRange(range.GetStart(), nextPos), sz, descent, dc, context, wxRICHTEXT_UNFORMATTED);
5913
5914                 if (sz.x > availableSpace)
5915                 {
5916                     maxPos = nextPos;
5917                 }
5918                 else
5919                 {
5920                     minPos = nextPos;
5921                 }
5922             }
5923         }
5924     }
5925
5926     // Now we know the last position on the line.
5927     // Let's try to find a word break.
5928
5929     wxString plainText;
5930     if (GetContiguousPlainText(plainText, wxRichTextRange(range.GetStart(), breakPosition), false))
5931     {
5932         int newLinePos = plainText.Find(wxRichTextLineBreakChar);
5933         if (newLinePos != wxNOT_FOUND)
5934         {
5935             breakPosition = wxMax(0, range.GetStart() + newLinePos);
5936         }
5937         else
5938         {
5939             int spacePos = plainText.Find(wxT(' '), true);
5940             int tabPos = plainText.Find(wxT('\t'), true);
5941             int pos = wxMax(spacePos, tabPos);
5942             if (pos != wxNOT_FOUND)
5943             {
5944                 int positionsFromEndOfString = plainText.length() - pos - 1;
5945                 breakPosition = breakPosition - positionsFromEndOfString;
5946             }
5947         }
5948     }
5949
5950     wrapPosition = breakPosition;
5951
5952     return true;
5953 }
5954
5955 /// Get the bullet text for this paragraph.
5956 wxString wxRichTextParagraph::GetBulletText()
5957 {
5958     if (GetAttributes().GetBulletStyle() == wxTEXT_ATTR_BULLET_STYLE_NONE ||
5959         (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_BITMAP))
5960         return wxEmptyString;
5961
5962     int number = GetAttributes().GetBulletNumber();
5963
5964     wxString text;
5965     if ((GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ARABIC) || (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_OUTLINE))
5966     {
5967         text.Printf(wxT("%d"), number);
5968     }
5969     else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_LETTERS_UPPER)
5970     {
5971         // TODO: Unicode, and also check if number > 26
5972         text.Printf(wxT("%c"), (wxChar) (number+64));
5973     }
5974     else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_LETTERS_LOWER)
5975     {
5976         // TODO: Unicode, and also check if number > 26
5977         text.Printf(wxT("%c"), (wxChar) (number+96));
5978     }
5979     else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ROMAN_UPPER)
5980     {
5981         text = wxRichTextDecimalToRoman(number);
5982     }
5983     else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ROMAN_LOWER)
5984     {
5985         text = wxRichTextDecimalToRoman(number);
5986         text.MakeLower();
5987     }
5988     else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_SYMBOL)
5989     {
5990         text = GetAttributes().GetBulletText();
5991     }
5992
5993     if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_OUTLINE)
5994     {
5995         // The outline style relies on the text being computed statically,
5996         // since it depends on other levels points (e.g. 1.2.1.1). So normally the bullet text
5997         // should be stored in the attributes; if not, just use the number for this
5998         // level, as previously computed.
5999         if (!GetAttributes().GetBulletText().IsEmpty())
6000             text = GetAttributes().GetBulletText();
6001     }
6002
6003     if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_PARENTHESES)
6004     {
6005         text = wxT("(") + text + wxT(")");
6006     }
6007     else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_RIGHT_PARENTHESIS)
6008     {
6009         text = text + wxT(")");
6010     }
6011
6012     if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_PERIOD)
6013     {
6014         text += wxT(".");
6015     }
6016
6017     return text;
6018 }
6019
6020 /// Allocate or reuse a line object
6021 wxRichTextLine* wxRichTextParagraph::AllocateLine(int pos)
6022 {
6023     if (pos < (int) m_cachedLines.GetCount())
6024     {
6025         wxRichTextLine* line = m_cachedLines.Item(pos)->GetData();
6026         line->Init(this);
6027         return line;
6028     }
6029     else
6030     {
6031         wxRichTextLine* line = new wxRichTextLine(this);
6032         m_cachedLines.Append(line);
6033         return line;
6034     }
6035 }
6036
6037 /// Clear remaining unused line objects, if any
6038 bool wxRichTextParagraph::ClearUnusedLines(int lineCount)
6039 {
6040     int cachedLineCount = m_cachedLines.GetCount();
6041     if ((int) cachedLineCount > lineCount)
6042     {
6043         for (int i = 0; i < (int) (cachedLineCount - lineCount); i ++)
6044         {
6045             wxRichTextLineList::compatibility_iterator node = m_cachedLines.GetLast();
6046             wxRichTextLine* line = node->GetData();
6047             m_cachedLines.Erase(node);
6048             delete line;
6049         }
6050     }
6051     return true;
6052 }
6053
6054 /// Get combined attributes of the base style, paragraph style and character style. We use this to dynamically
6055 /// retrieve the actual style.
6056 wxRichTextAttr wxRichTextParagraph::GetCombinedAttributes(const wxRichTextAttr& contentStyle, bool includingBoxAttr) const
6057 {
6058     wxRichTextAttr attr;
6059     wxRichTextParagraphLayoutBox* buf = wxDynamicCast(GetParent(), wxRichTextParagraphLayoutBox);
6060     if (buf)
6061     {
6062         attr = buf->GetBasicStyle();
6063         if (!includingBoxAttr)
6064         {
6065             attr.GetTextBoxAttr().Reset();
6066             // The background colour will be painted by the container, and we don't
6067             // want to unnecessarily overwrite the background when we're drawing text
6068             // because this may erase the guideline (which appears just under the text
6069             // if there's no padding).
6070             attr.SetFlags(attr.GetFlags() & ~wxTEXT_ATTR_BACKGROUND_COLOUR);
6071         }
6072         wxRichTextApplyStyle(attr, GetAttributes());
6073     }
6074     else
6075         attr = GetAttributes();
6076
6077     wxRichTextApplyStyle(attr, contentStyle);
6078     return attr;
6079 }
6080
6081 /// Get combined attributes of the base style and paragraph style.
6082 wxRichTextAttr wxRichTextParagraph::GetCombinedAttributes(bool includingBoxAttr) const
6083 {
6084     wxRichTextAttr attr;
6085     wxRichTextParagraphLayoutBox* buf = wxDynamicCast(GetParent(), wxRichTextParagraphLayoutBox);
6086     if (buf)
6087     {
6088         attr = buf->GetBasicStyle();
6089         if (!includingBoxAttr)
6090             attr.GetTextBoxAttr().Reset();
6091         wxRichTextApplyStyle(attr, GetAttributes());
6092     }
6093     else
6094         attr = GetAttributes();
6095
6096     return attr;
6097 }
6098
6099 // Create default tabstop array
6100 void wxRichTextParagraph::InitDefaultTabs()
6101 {
6102     // create a default tab list at 10 mm each.
6103     for (int i = 0; i < 20; ++i)
6104     {
6105         sm_defaultTabs.Add(i*100);
6106     }
6107 }
6108
6109 // Clear default tabstop array
6110 void wxRichTextParagraph::ClearDefaultTabs()
6111 {
6112     sm_defaultTabs.Clear();
6113 }
6114
6115 void wxRichTextParagraph::LayoutFloat(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, int style, wxRichTextFloatCollector* floatCollector)
6116 {
6117     wxRichTextObjectList::compatibility_iterator node = GetChildren().GetFirst();
6118     while (node)
6119     {
6120         wxRichTextObject* anchored = node->GetData();
6121         if (anchored && anchored->IsFloating() && !floatCollector->HasFloat(anchored))
6122         {
6123             wxSize size;
6124             int descent, x = 0;
6125             anchored->GetRangeSize(anchored->GetRange(), size, descent, dc, context, style);
6126
6127             int offsetY = 0;
6128             if (anchored->GetAttributes().GetTextBoxAttr().GetTop().IsValid())
6129             {
6130                 offsetY = anchored->GetAttributes().GetTextBoxAttr().GetTop().GetValue();
6131                 if (anchored->GetAttributes().GetTextBoxAttr().GetTop().GetUnits() == wxTEXT_ATTR_UNITS_TENTHS_MM)
6132                 {
6133                     offsetY = ConvertTenthsMMToPixels(dc, offsetY);
6134                 }
6135             }
6136
6137             int pos = floatCollector->GetFitPosition(anchored->GetAttributes().GetTextBoxAttr().GetFloatMode(), rect.y + offsetY, size.y);
6138
6139             /* Update the offset */
6140             int newOffsetY = pos - rect.y;
6141             if (newOffsetY != offsetY)
6142             {
6143                 if (anchored->GetAttributes().GetTextBoxAttr().GetTop().GetUnits() == wxTEXT_ATTR_UNITS_TENTHS_MM)
6144                     newOffsetY = ConvertPixelsToTenthsMM(dc, newOffsetY);
6145                 anchored->GetAttributes().GetTextBoxAttr().GetTop().SetValue(newOffsetY);
6146             }
6147
6148             if (anchored->GetAttributes().GetTextBoxAttr().GetFloatMode() == wxTEXT_BOX_ATTR_FLOAT_LEFT)
6149                 x = rect.x;
6150             else if (anchored->GetAttributes().GetTextBoxAttr().GetFloatMode() == wxTEXT_BOX_ATTR_FLOAT_RIGHT)
6151                 x = rect.x + rect.width - size.x;
6152
6153             anchored->SetPosition(wxPoint(x, pos));
6154             anchored->SetCachedSize(size);
6155             floatCollector->CollectFloat(this, anchored);
6156         }
6157
6158         node = node->GetNext();
6159     }
6160 }
6161
6162 // Get the first position from pos that has a line break character.
6163 long wxRichTextParagraph::GetFirstLineBreakPosition(long pos)
6164 {
6165     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
6166     while (node)
6167     {
6168         wxRichTextObject* obj = node->GetData();
6169         if (pos >= obj->GetRange().GetStart() && pos <= obj->GetRange().GetEnd())
6170         {
6171             wxRichTextPlainText* textObj = wxDynamicCast(obj, wxRichTextPlainText);
6172             if (textObj)
6173             {
6174                 long breakPos = textObj->GetFirstLineBreakPosition(pos);
6175                 if (breakPos > -1)
6176                     return breakPos;
6177             }
6178         }
6179         node = node->GetNext();
6180     }
6181     return -1;
6182 }
6183
6184 /*!
6185  * wxRichTextLine
6186  * This object represents a line in a paragraph, and stores
6187  * offsets from the start of the paragraph representing the
6188  * start and end positions of the line.
6189  */
6190
6191 wxRichTextLine::wxRichTextLine(wxRichTextParagraph* parent)
6192 {
6193     Init(parent);
6194 }
6195
6196 /// Initialisation
6197 void wxRichTextLine::Init(wxRichTextParagraph* parent)
6198 {
6199     m_parent = parent;
6200     m_range.SetRange(-1, -1);
6201     m_pos = wxPoint(0, 0);
6202     m_size = wxSize(0, 0);
6203     m_descent = 0;
6204 #if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING
6205     m_objectSizes.Clear();
6206 #endif
6207 }
6208
6209 /// Copy
6210 void wxRichTextLine::Copy(const wxRichTextLine& obj)
6211 {
6212     m_range = obj.m_range;
6213 #if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING
6214     m_objectSizes = obj.m_objectSizes;
6215 #endif
6216 }
6217
6218 /// Get the absolute object position
6219 wxPoint wxRichTextLine::GetAbsolutePosition() const
6220 {
6221     return m_parent->GetPosition() + m_pos;
6222 }
6223
6224 /// Get the absolute range
6225 wxRichTextRange wxRichTextLine::GetAbsoluteRange() const
6226 {
6227     wxRichTextRange range(m_range.GetStart() + m_parent->GetRange().GetStart(), 0);
6228     range.SetEnd(range.GetStart() + m_range.GetLength()-1);
6229     return range;
6230 }
6231
6232 /*!
6233  * wxRichTextPlainText
6234  * This object represents a single piece of text.
6235  */
6236
6237 IMPLEMENT_DYNAMIC_CLASS(wxRichTextPlainText, wxRichTextObject)
6238
6239 wxRichTextPlainText::wxRichTextPlainText(const wxString& text, wxRichTextObject* parent, wxRichTextAttr* style):
6240     wxRichTextObject(parent)
6241 {
6242     if (style)
6243         SetAttributes(*style);
6244
6245     m_text = text;
6246 }
6247
6248 #define USE_KERNING_FIX 1
6249
6250 // If insufficient tabs are defined, this is the tab width used
6251 #define WIDTH_FOR_DEFAULT_TABS 50
6252
6253 /// Draw the item
6254 bool wxRichTextPlainText::Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int WXUNUSED(style))
6255 {
6256     wxRichTextParagraph* para = wxDynamicCast(GetParent(), wxRichTextParagraph);
6257     wxASSERT (para != NULL);
6258
6259     wxRichTextAttr textAttr(para ? para->GetCombinedAttributes(GetAttributes(), false /* no box attributes */) : GetAttributes());
6260     context.ApplyVirtualAttributes(textAttr, this);
6261
6262     // Let's make the assumption for now that for content in a paragraph, including
6263     // text, we never have a discontinuous selection. So we only deal with a
6264     // single range.
6265     wxRichTextRange selectionRange;
6266     if (selection.IsValid())
6267     {
6268         wxRichTextRangeArray selectionRanges = selection.GetSelectionForObject(this);
6269         if (selectionRanges.GetCount() > 0)
6270             selectionRange = selectionRanges[0];
6271         else
6272             selectionRange = wxRICHTEXT_NO_SELECTION;
6273     }
6274     else
6275         selectionRange = wxRICHTEXT_NO_SELECTION;
6276
6277     int offset = GetRange().GetStart();
6278
6279     // Replace line break characters with spaces
6280     wxString str = m_text;
6281     wxString toRemove = wxRichTextLineBreakChar;
6282     str.Replace(toRemove, wxT(" "));
6283     if (textAttr.HasTextEffects() && (textAttr.GetTextEffects() & (wxTEXT_ATTR_EFFECT_CAPITALS|wxTEXT_ATTR_EFFECT_SMALL_CAPITALS)))
6284         str.MakeUpper();
6285
6286     long len = range.GetLength();
6287     wxString stringChunk = str.Mid(range.GetStart() - offset, (size_t) len);
6288
6289     // Test for the optimized situations where all is selected, or none
6290     // is selected.
6291
6292     wxFont textFont(GetBuffer()->GetFontTable().FindFont(textAttr));
6293     wxCheckSetFont(dc, textFont);
6294     int charHeight = dc.GetCharHeight();
6295
6296     int x, y;
6297     if ( textFont.IsOk() )
6298     {
6299         if (textAttr.HasTextEffects() && (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_SMALL_CAPITALS))
6300         {
6301             textFont.SetPointSize((int) (textFont.GetPointSize()*0.75));
6302             wxCheckSetFont(dc, textFont);
6303             charHeight = dc.GetCharHeight();
6304         }
6305
6306         if ( textAttr.HasTextEffects() && (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_SUPERSCRIPT) )
6307         {
6308             if (textFont.IsUsingSizeInPixels())
6309             {
6310                 double size = static_cast<double>(textFont.GetPixelSize().y) / wxSCRIPT_MUL_FACTOR;
6311                 textFont.SetPixelSize(wxSize(0, static_cast<int>(size)));
6312                 x = rect.x;
6313                 y = rect.y;
6314             }
6315             else
6316             {
6317                 double size = static_cast<double>(textFont.GetPointSize()) / wxSCRIPT_MUL_FACTOR;
6318                 textFont.SetPointSize(static_cast<int>(size));
6319                 x = rect.x;
6320                 y = rect.y;
6321             }
6322             wxCheckSetFont(dc, textFont);
6323         }
6324         else if ( textAttr.HasTextEffects() && (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_SUBSCRIPT) )
6325         {
6326             if (textFont.IsUsingSizeInPixels())
6327             {
6328                 double size = static_cast<double>(textFont.GetPixelSize().y) / wxSCRIPT_MUL_FACTOR;
6329                 textFont.SetPixelSize(wxSize(0, static_cast<int>(size)));
6330                 x = rect.x;
6331                 int sub_height = static_cast<int>(static_cast<double>(charHeight) / wxSCRIPT_MUL_FACTOR);
6332                 y = rect.y + (rect.height - sub_height + (descent - m_descent));
6333             }
6334             else
6335             {
6336                 double size = static_cast<double>(textFont.GetPointSize()) / wxSCRIPT_MUL_FACTOR;
6337                 textFont.SetPointSize(static_cast<int>(size));
6338                 x = rect.x;
6339                 int sub_height = static_cast<int>(static_cast<double>(charHeight) / wxSCRIPT_MUL_FACTOR);
6340                 y = rect.y + (rect.height - sub_height + (descent - m_descent));
6341             }
6342             wxCheckSetFont(dc, textFont);
6343         }
6344         else
6345         {
6346             x = rect.x;
6347             y = rect.y + (rect.height - charHeight - (descent - m_descent));
6348         }
6349     }
6350     else
6351     {
6352         x = rect.x;
6353         y = rect.y + (rect.height - charHeight - (descent - m_descent));
6354     }
6355
6356     // TODO: new selection code
6357
6358     // (a) All selected.
6359     if (selectionRange.GetStart() <= range.GetStart() && selectionRange.GetEnd() >= range.GetEnd())
6360     {
6361         DrawTabbedString(dc, textAttr, rect, stringChunk, x, y, true);
6362     }
6363     // (b) None selected.
6364     else if (selectionRange.GetEnd() < range.GetStart() || selectionRange.GetStart() > range.GetEnd())
6365     {
6366         // Draw all unselected
6367         DrawTabbedString(dc, textAttr, rect, stringChunk, x, y, false);
6368     }
6369     else
6370     {
6371         // (c) Part selected, part not
6372         // Let's draw unselected chunk, selected chunk, then unselected chunk.
6373
6374         dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
6375
6376         // 1. Initial unselected chunk, if any, up until start of selection.
6377         if (selectionRange.GetStart() > range.GetStart() && selectionRange.GetStart() <= range.GetEnd())
6378         {
6379             int r1 = range.GetStart();
6380             int s1 = selectionRange.GetStart()-1;
6381             int fragmentLen = s1 - r1 + 1;
6382             if (fragmentLen < 0)
6383             {
6384                 wxLogDebug(wxT("Mid(%d, %d"), (int)(r1 - offset), (int)fragmentLen);
6385             }
6386             wxString stringFragment = str.Mid(r1 - offset, fragmentLen);
6387
6388             DrawTabbedString(dc, textAttr, rect, stringFragment, x, y, false);
6389
6390 #if USE_KERNING_FIX
6391             if (stringChunk.Find(wxT("\t")) == wxNOT_FOUND)
6392             {
6393                 // Compensate for kerning difference
6394                 wxString stringFragment2(str.Mid(r1 - offset, fragmentLen+1));
6395                 wxString stringFragment3(str.Mid(r1 - offset + fragmentLen, 1));
6396
6397                 wxCoord w1, h1, w2, h2, w3, h3;
6398                 dc.GetTextExtent(stringFragment,  & w1, & h1);
6399                 dc.GetTextExtent(stringFragment2, & w2, & h2);
6400                 dc.GetTextExtent(stringFragment3, & w3, & h3);
6401
6402                 int kerningDiff = (w1 + w3) - w2;
6403                 x = x - kerningDiff;
6404             }
6405 #endif
6406         }
6407
6408         // 2. Selected chunk, if any.
6409         if (selectionRange.GetEnd() >= range.GetStart())
6410         {
6411             int s1 = wxMax(selectionRange.GetStart(), range.GetStart());
6412             int s2 = wxMin(selectionRange.GetEnd(), range.GetEnd());
6413
6414             int fragmentLen = s2 - s1 + 1;
6415             if (fragmentLen < 0)
6416             {
6417                 wxLogDebug(wxT("Mid(%d, %d"), (int)(s1 - offset), (int)fragmentLen);
6418             }
6419             wxString stringFragment = str.Mid(s1 - offset, fragmentLen);
6420
6421             DrawTabbedString(dc, textAttr, rect, stringFragment, x, y, true);
6422
6423 #if USE_KERNING_FIX
6424             if (stringChunk.Find(wxT("\t")) == wxNOT_FOUND)
6425             {
6426                 // Compensate for kerning difference
6427                 wxString stringFragment2(str.Mid(s1 - offset, fragmentLen+1));
6428                 wxString stringFragment3(str.Mid(s1 - offset + fragmentLen, 1));
6429
6430                 wxCoord w1, h1, w2, h2, w3, h3;
6431                 dc.GetTextExtent(stringFragment,  & w1, & h1);
6432                 dc.GetTextExtent(stringFragment2, & w2, & h2);
6433                 dc.GetTextExtent(stringFragment3, & w3, & h3);
6434
6435                 int kerningDiff = (w1 + w3) - w2;
6436                 x = x - kerningDiff;
6437             }
6438 #endif
6439         }
6440
6441         // 3. Remaining unselected chunk, if any
6442         if (selectionRange.GetEnd() < range.GetEnd())
6443         {
6444             int s2 = wxMin(selectionRange.GetEnd()+1, range.GetEnd());
6445             int r2 = range.GetEnd();
6446
6447             int fragmentLen = r2 - s2 + 1;
6448             if (fragmentLen < 0)
6449             {
6450                 wxLogDebug(wxT("Mid(%d, %d"), (int)(s2 - offset), (int)fragmentLen);
6451             }
6452             wxString stringFragment = str.Mid(s2 - offset, fragmentLen);
6453
6454             DrawTabbedString(dc, textAttr, rect, stringFragment, x, y, false);
6455         }
6456     }
6457
6458     return true;
6459 }
6460
6461 bool wxRichTextPlainText::DrawTabbedString(wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect,wxString& str, wxCoord& x, wxCoord& y, bool selected)
6462 {
6463     bool hasTabs = (str.Find(wxT('\t')) != wxNOT_FOUND);
6464
6465     wxArrayInt tabArray;
6466     int tabCount;
6467     if (hasTabs)
6468     {
6469         if (attr.GetTabs().IsEmpty())
6470             tabArray = wxRichTextParagraph::GetDefaultTabs();
6471         else
6472             tabArray = attr.GetTabs();
6473         tabCount = tabArray.GetCount();
6474
6475         for (int i = 0; i < tabCount; ++i)
6476         {
6477             int pos = tabArray[i];
6478             pos = ConvertTenthsMMToPixels(dc, pos);
6479             tabArray[i] = pos;
6480         }
6481     }
6482     else
6483         tabCount = 0;
6484
6485     int nextTabPos = -1;
6486     int tabPos = -1;
6487     wxCoord w, h;
6488
6489     if (selected)
6490     {
6491         wxColour highlightColour(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT));
6492         wxColour highlightTextColour(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT));
6493
6494         wxCheckSetBrush(dc, wxBrush(highlightColour));
6495         wxCheckSetPen(dc, wxPen(highlightColour));
6496         dc.SetTextForeground(highlightTextColour);
6497         dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
6498     }
6499     else
6500     {
6501         dc.SetTextForeground(attr.GetTextColour());
6502
6503         if (attr.HasFlag(wxTEXT_ATTR_BACKGROUND_COLOUR) && attr.GetBackgroundColour().IsOk())
6504         {
6505             dc.SetBackgroundMode(wxBRUSHSTYLE_SOLID);
6506             dc.SetTextBackground(attr.GetBackgroundColour());
6507         }
6508         else
6509             dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
6510     }
6511
6512     wxCoord x_orig = GetParent()->GetPosition().x;
6513     while (hasTabs)
6514     {
6515         // the string has a tab
6516         // break up the string at the Tab
6517         wxString stringChunk = str.BeforeFirst(wxT('\t'));
6518         str = str.AfterFirst(wxT('\t'));
6519         dc.GetTextExtent(stringChunk, & w, & h);
6520         tabPos = x + w;
6521         bool not_found = true;
6522         for (int i = 0; i < tabCount && not_found; ++i)
6523         {
6524             nextTabPos = tabArray.Item(i) + x_orig;
6525
6526             // Find the next tab position.
6527             // Even if we're at the end of the tab array, we must still draw the chunk.
6528
6529             if (nextTabPos > tabPos || (i == (tabCount - 1)))
6530             {
6531                 if (nextTabPos <= tabPos)
6532                 {
6533                     int defaultTabWidth = ConvertTenthsMMToPixels(dc, WIDTH_FOR_DEFAULT_TABS);
6534                     nextTabPos = tabPos + defaultTabWidth;
6535                 }
6536
6537                 not_found = false;
6538                 if (selected)
6539                 {
6540                     w = nextTabPos - x;
6541                     wxRect selRect(x, rect.y, w, rect.GetHeight());
6542                     dc.DrawRectangle(selRect);
6543                 }
6544                 dc.DrawText(stringChunk, x, y);
6545
6546                 if (attr.HasTextEffects() && (attr.GetTextEffects() & wxTEXT_ATTR_EFFECT_STRIKETHROUGH))
6547                 {
6548                     wxPen oldPen = dc.GetPen();
6549                     wxCheckSetPen(dc, wxPen(attr.GetTextColour(), 1));
6550                     dc.DrawLine(x, (int) (y+(h/2)+0.5), x+w, (int) (y+(h/2)+0.5));
6551                     wxCheckSetPen(dc, oldPen);
6552                 }
6553
6554                 x = nextTabPos;
6555             }
6556         }
6557         hasTabs = (str.Find(wxT('\t')) != wxNOT_FOUND);
6558     }
6559
6560     if (!str.IsEmpty())
6561     {
6562         dc.GetTextExtent(str, & w, & h);
6563         if (selected)
6564         {
6565             wxRect selRect(x, rect.y, w, rect.GetHeight());
6566             dc.DrawRectangle(selRect);
6567         }
6568         dc.DrawText(str, x, y);
6569
6570         if (attr.HasTextEffects() && (attr.GetTextEffects() & wxTEXT_ATTR_EFFECT_STRIKETHROUGH))
6571         {
6572             wxPen oldPen = dc.GetPen();
6573             wxCheckSetPen(dc, wxPen(attr.GetTextColour(), 1));
6574             dc.DrawLine(x, (int) (y+(h/2)+0.5), x+w, (int) (y+(h/2)+0.5));
6575             wxCheckSetPen(dc, oldPen);
6576         }
6577
6578         x += w;
6579     }
6580
6581     return true;
6582 }
6583
6584 /// Lay the item out
6585 bool wxRichTextPlainText::Layout(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& WXUNUSED(rect), const wxRect& WXUNUSED(parentRect), int WXUNUSED(style))
6586 {
6587     // Only lay out if we haven't already cached the size
6588     if (m_size.x == -1)
6589         GetRangeSize(GetRange(), m_size, m_descent, dc, context, 0, wxPoint(0, 0));
6590     m_maxSize = m_size;
6591     // Eventually we want to have a reasonable estimate of minimum size.
6592     m_minSize = wxSize(0, 0);
6593     return true;
6594 }
6595
6596 /// Copy
6597 void wxRichTextPlainText::Copy(const wxRichTextPlainText& obj)
6598 {
6599     wxRichTextObject::Copy(obj);
6600
6601     m_text = obj.m_text;
6602 }
6603
6604 /// Get/set the object size for the given range. Returns false if the range
6605 /// is invalid for this object.
6606 bool wxRichTextPlainText::GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int WXUNUSED(flags), wxPoint position, wxArrayInt* partialExtents) const
6607 {
6608     if (!range.IsWithin(GetRange()))
6609         return false;
6610
6611     wxRichTextParagraph* para = wxDynamicCast(GetParent(), wxRichTextParagraph);
6612     wxASSERT (para != NULL);
6613
6614     int relativeX = position.x - GetParent()->GetPosition().x;
6615
6616     wxRichTextAttr textAttr(para ? para->GetCombinedAttributes(GetAttributes()) : GetAttributes());
6617     context.ApplyVirtualAttributes(textAttr, (wxRichTextObject*) this);
6618
6619     // Always assume unformatted text, since at this level we have no knowledge
6620     // of line breaks - and we don't need it, since we'll calculate size within
6621     // formatted text by doing it in chunks according to the line ranges
6622
6623     bool bScript(false);
6624     wxFont font(GetBuffer()->GetFontTable().FindFont(textAttr));
6625     if (font.IsOk())
6626     {
6627         if ( textAttr.HasTextEffects() && ( (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_SUPERSCRIPT)
6628             || (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_SUBSCRIPT) ) )
6629         {
6630             wxFont textFont = font;
6631             if (textFont.IsUsingSizeInPixels())
6632             {
6633                 double size = static_cast<double>(textFont.GetPixelSize().y) / wxSCRIPT_MUL_FACTOR;
6634                 textFont.SetPixelSize(wxSize(0, static_cast<int>(size)));
6635             }
6636             else
6637             {
6638                 double size = static_cast<double>(textFont.GetPointSize()) / wxSCRIPT_MUL_FACTOR;
6639                 textFont.SetPointSize(static_cast<int>(size));
6640             }
6641             wxCheckSetFont(dc, textFont);
6642             bScript = true;
6643         }
6644         else if (textAttr.HasTextEffects() && (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_SMALL_CAPITALS))
6645         {
6646             wxFont textFont = font;
6647             textFont.SetPointSize((int) (textFont.GetPointSize()*0.75));
6648             wxCheckSetFont(dc, textFont);
6649             bScript = true;
6650         }
6651         else
6652         {
6653             wxCheckSetFont(dc, font);
6654         }
6655     }
6656
6657     bool haveDescent = false;
6658     int startPos = range.GetStart() - GetRange().GetStart();
6659     long len = range.GetLength();
6660
6661     wxString str(m_text);
6662     wxString toReplace = wxRichTextLineBreakChar;
6663     str.Replace(toReplace, wxT(" "));
6664
6665     wxString stringChunk = str.Mid(startPos, (size_t) len);
6666
6667     if (textAttr.HasTextEffects() && (textAttr.GetTextEffects() & (wxTEXT_ATTR_EFFECT_CAPITALS|wxTEXT_ATTR_EFFECT_SMALL_CAPITALS)))
6668         stringChunk.MakeUpper();
6669
6670     wxCoord w, h;
6671     int width = 0;
6672     if (stringChunk.Find(wxT('\t')) != wxNOT_FOUND)
6673     {
6674         // the string has a tab
6675         wxArrayInt tabArray;
6676         if (textAttr.GetTabs().IsEmpty())
6677             tabArray = wxRichTextParagraph::GetDefaultTabs();
6678         else
6679             tabArray = textAttr.GetTabs();
6680
6681         int tabCount = tabArray.GetCount();
6682
6683         for (int i = 0; i < tabCount; ++i)
6684         {
6685             int pos = tabArray[i];
6686             pos = ((wxRichTextPlainText*) this)->ConvertTenthsMMToPixels(dc, pos);
6687             tabArray[i] = pos;
6688         }
6689
6690         int nextTabPos = -1;
6691
6692         while (stringChunk.Find(wxT('\t')) >= 0)
6693         {
6694             int absoluteWidth = 0;
6695
6696             // the string has a tab
6697             // break up the string at the Tab
6698             wxString stringFragment = stringChunk.BeforeFirst(wxT('\t'));
6699             stringChunk = stringChunk.AfterFirst(wxT('\t'));
6700
6701             if (partialExtents)
6702             {
6703                 int oldWidth;
6704                 if (partialExtents->GetCount() > 0)
6705                     oldWidth = (*partialExtents)[partialExtents->GetCount()-1];
6706                 else
6707                     oldWidth = 0;
6708
6709                 // Add these partial extents
6710                 wxArrayInt p;
6711                 dc.GetPartialTextExtents(stringFragment, p);
6712                 size_t j;
6713                 for (j = 0; j < p.GetCount(); j++)
6714                     partialExtents->Add(oldWidth + p[j]);
6715
6716                 if (partialExtents->GetCount() > 0)
6717                     absoluteWidth = (*partialExtents)[(*partialExtents).GetCount()-1] + relativeX;
6718                 else
6719                     absoluteWidth = relativeX;
6720             }
6721             else
6722             {
6723                 dc.GetTextExtent(stringFragment, & w, & h);
6724                 width += w;
6725                 absoluteWidth = width + relativeX;
6726                 haveDescent = true;
6727             }
6728
6729             bool notFound = true;
6730             for (int i = 0; i < tabCount && notFound; ++i)
6731             {
6732                 nextTabPos = tabArray.Item(i);
6733
6734                 // Find the next tab position.
6735                 // Even if we're at the end of the tab array, we must still process the chunk.
6736
6737                 if (nextTabPos > absoluteWidth || (i == (tabCount - 1)))
6738                 {
6739                     if (nextTabPos <= absoluteWidth)
6740                     {
6741                         int defaultTabWidth = ((wxRichTextPlainText*) this)->ConvertTenthsMMToPixels(dc, WIDTH_FOR_DEFAULT_TABS);
6742                         nextTabPos = absoluteWidth + defaultTabWidth;
6743                     }
6744
6745                     notFound = false;
6746                     width = nextTabPos - relativeX;
6747
6748                     if (partialExtents)
6749                         partialExtents->Add(width);
6750                 }
6751             }
6752         }
6753     }
6754
6755     if (!stringChunk.IsEmpty())
6756     {
6757         if (partialExtents)
6758         {
6759             int oldWidth;
6760             if (partialExtents->GetCount() > 0)
6761                 oldWidth = (*partialExtents)[partialExtents->GetCount()-1];
6762             else
6763                 oldWidth = 0;
6764
6765             // Add these partial extents
6766             wxArrayInt p;
6767             dc.GetPartialTextExtents(stringChunk, p);
6768             size_t j;
6769             for (j = 0; j < p.GetCount(); j++)
6770                 partialExtents->Add(oldWidth + p[j]);
6771         }
6772         else
6773         {
6774             dc.GetTextExtent(stringChunk, & w, & h, & descent);
6775             width += w;
6776             haveDescent = true;
6777         }
6778     }
6779
6780     if (partialExtents)
6781     {
6782         int charHeight = dc.GetCharHeight();
6783         if ((*partialExtents).GetCount() > 0)
6784             w = (*partialExtents)[partialExtents->GetCount()-1];
6785         else
6786             w = 0;
6787         size = wxSize(w, charHeight);
6788     }
6789     else
6790     {
6791         size = wxSize(width, dc.GetCharHeight());
6792     }
6793
6794     if (!haveDescent)
6795         dc.GetTextExtent(wxT("X"), & w, & h, & descent);
6796
6797     if ( bScript )
6798         dc.SetFont(font);
6799
6800     return true;
6801 }
6802
6803 /// Do a split, returning an object containing the second part, and setting
6804 /// the first part in 'this'.
6805 wxRichTextObject* wxRichTextPlainText::DoSplit(long pos)
6806 {
6807     long index = pos - GetRange().GetStart();
6808
6809     if (index < 0 || index >= (int) m_text.length())
6810         return NULL;
6811
6812     wxString firstPart = m_text.Mid(0, index);
6813     wxString secondPart = m_text.Mid(index);
6814
6815     m_text = firstPart;
6816
6817     wxRichTextPlainText* newObject = new wxRichTextPlainText(secondPart);
6818     newObject->SetAttributes(GetAttributes());
6819     newObject->SetProperties(GetProperties());
6820
6821     newObject->SetRange(wxRichTextRange(pos, GetRange().GetEnd()));
6822     GetRange().SetEnd(pos-1);
6823
6824     return newObject;
6825 }
6826
6827 /// Calculate range
6828 void wxRichTextPlainText::CalculateRange(long start, long& end)
6829 {
6830     end = start + m_text.length() - 1;
6831     m_range.SetRange(start, end);
6832 }
6833
6834 /// Delete range
6835 bool wxRichTextPlainText::DeleteRange(const wxRichTextRange& range)
6836 {
6837     wxRichTextRange r = range;
6838
6839     r.LimitTo(GetRange());
6840
6841     if (r.GetStart() == GetRange().GetStart() && r.GetEnd() == GetRange().GetEnd())
6842     {
6843         m_text.Empty();
6844         return true;
6845     }
6846
6847     long startIndex = r.GetStart() - GetRange().GetStart();
6848     long len = r.GetLength();
6849
6850     m_text = m_text.Mid(0, startIndex) + m_text.Mid(startIndex+len);
6851     return true;
6852 }
6853
6854 /// Get text for the given range.
6855 wxString wxRichTextPlainText::GetTextForRange(const wxRichTextRange& range) const
6856 {
6857     wxRichTextRange r = range;
6858
6859     r.LimitTo(GetRange());
6860
6861     long startIndex = r.GetStart() - GetRange().GetStart();
6862     long len = r.GetLength();
6863
6864     return m_text.Mid(startIndex, len);
6865 }
6866
6867 /// Returns true if this object can merge itself with the given one.
6868 bool wxRichTextPlainText::CanMerge(wxRichTextObject* object) const
6869 {
6870     return object->GetClassInfo() == wxCLASSINFO(wxRichTextPlainText) &&
6871         (m_text.empty() || (wxTextAttrEq(GetAttributes(), object->GetAttributes()) && m_properties == object->GetProperties()));
6872 }
6873
6874 /// Returns true if this object merged itself with the given one.
6875 /// The calling code will then delete the given object.
6876 bool wxRichTextPlainText::Merge(wxRichTextObject* object)
6877 {
6878     wxRichTextPlainText* textObject = wxDynamicCast(object, wxRichTextPlainText);
6879     wxASSERT( textObject != NULL );
6880
6881     if (textObject)
6882     {
6883         m_text += textObject->GetText();
6884         wxRichTextApplyStyle(m_attributes, textObject->GetAttributes());
6885         return true;
6886     }
6887     else
6888         return false;
6889 }
6890
6891 /// Dump to output stream for debugging
6892 void wxRichTextPlainText::Dump(wxTextOutputStream& stream)
6893 {
6894     wxRichTextObject::Dump(stream);
6895     stream << m_text << wxT("\n");
6896 }
6897
6898 /// Get the first position from pos that has a line break character.
6899 long wxRichTextPlainText::GetFirstLineBreakPosition(long pos)
6900 {
6901     int i;
6902     int len = m_text.length();
6903     int startPos = pos - m_range.GetStart();
6904     for (i = startPos; i < len; i++)
6905     {
6906         wxChar ch = m_text[i];
6907         if (ch == wxRichTextLineBreakChar)
6908         {
6909             return i + m_range.GetStart();
6910         }
6911     }
6912     return -1;
6913 }
6914
6915 /*!
6916  * wxRichTextBuffer
6917  * This is a kind of box, used to represent the whole buffer
6918  */
6919
6920 IMPLEMENT_DYNAMIC_CLASS(wxRichTextBuffer, wxRichTextParagraphLayoutBox)
6921
6922 wxList                      wxRichTextBuffer::sm_handlers;
6923 wxList                      wxRichTextBuffer::sm_drawingHandlers;
6924 wxRichTextFieldTypeHashMap  wxRichTextBuffer::sm_fieldTypes;
6925 wxRichTextRenderer*         wxRichTextBuffer::sm_renderer = NULL;
6926 int                         wxRichTextBuffer::sm_bulletRightMargin = 20;
6927 float                       wxRichTextBuffer::sm_bulletProportion = (float) 0.3;
6928
6929 /// Initialisation
6930 void wxRichTextBuffer::Init()
6931 {
6932     m_commandProcessor = new wxCommandProcessor;
6933     m_styleSheet = NULL;
6934     m_modified = false;
6935     m_batchedCommandDepth = 0;
6936     m_batchedCommand = NULL;
6937     m_suppressUndo = 0;
6938     m_handlerFlags = 0;
6939     m_scale = 1.0;
6940     m_dimensionScale = 1.0;
6941     m_fontScale = 1.0;
6942     SetMargins(4);
6943 }
6944
6945 /// Initialisation
6946 wxRichTextBuffer::~wxRichTextBuffer()
6947 {
6948     delete m_commandProcessor;
6949     delete m_batchedCommand;
6950
6951     ClearStyleStack();
6952     ClearEventHandlers();
6953 }
6954
6955 void wxRichTextBuffer::ResetAndClearCommands()
6956 {
6957     Reset();
6958
6959     GetCommandProcessor()->ClearCommands();
6960
6961     Modify(false);
6962     Invalidate(wxRICHTEXT_ALL);
6963 }
6964
6965 void wxRichTextBuffer::Copy(const wxRichTextBuffer& obj)
6966 {
6967     wxRichTextParagraphLayoutBox::Copy(obj);
6968
6969     m_styleSheet = obj.m_styleSheet;
6970     m_modified = obj.m_modified;
6971     m_batchedCommandDepth = 0;
6972     if (m_batchedCommand)
6973         delete m_batchedCommand;
6974     m_batchedCommand = NULL;
6975     m_suppressUndo = obj.m_suppressUndo;
6976     m_invalidRange = obj.m_invalidRange;
6977     m_dimensionScale = obj.m_dimensionScale;
6978     m_fontScale = obj.m_fontScale;
6979 }
6980
6981 /// Push style sheet to top of stack
6982 bool wxRichTextBuffer::PushStyleSheet(wxRichTextStyleSheet* styleSheet)
6983 {
6984     if (m_styleSheet)
6985         styleSheet->InsertSheet(m_styleSheet);
6986
6987     SetStyleSheet(styleSheet);
6988
6989     return true;
6990 }
6991
6992 /// Pop style sheet from top of stack
6993 wxRichTextStyleSheet* wxRichTextBuffer::PopStyleSheet()
6994 {
6995     if (m_styleSheet)
6996     {
6997         wxRichTextStyleSheet* oldSheet = m_styleSheet;
6998         m_styleSheet = oldSheet->GetNextSheet();
6999         oldSheet->Unlink();
7000
7001         return oldSheet;
7002     }
7003     else
7004         return NULL;
7005 }
7006
7007 /// Submit command to insert paragraphs
7008 bool wxRichTextBuffer::InsertParagraphsWithUndo(long pos, const wxRichTextParagraphLayoutBox& paragraphs, wxRichTextCtrl* ctrl, int flags)
7009 {
7010     return ctrl->GetFocusObject()->InsertParagraphsWithUndo(this, pos, paragraphs, ctrl, flags);
7011 }
7012
7013 /// Submit command to insert paragraphs
7014 bool wxRichTextParagraphLayoutBox::InsertParagraphsWithUndo(wxRichTextBuffer* buffer, long pos, const wxRichTextParagraphLayoutBox& paragraphs, wxRichTextCtrl* ctrl, int WXUNUSED(flags))
7015 {
7016     wxRichTextAction* action = new wxRichTextAction(NULL, _("Insert Text"), wxRICHTEXT_INSERT, buffer, this, ctrl, false);
7017
7018     action->GetNewParagraphs() = paragraphs;
7019
7020     action->SetPosition(pos);
7021
7022     wxRichTextRange range = wxRichTextRange(pos, pos + paragraphs.GetOwnRange().GetEnd() - 1);
7023     if (!paragraphs.GetPartialParagraph())
7024         range.SetEnd(range.GetEnd()+1);
7025
7026     // Set the range we'll need to delete in Undo
7027     action->SetRange(range);
7028
7029     buffer->SubmitAction(action);
7030
7031     return true;
7032 }
7033
7034 /// Submit command to insert the given text
7035 bool wxRichTextBuffer::InsertTextWithUndo(long pos, const wxString& text, wxRichTextCtrl* ctrl, int flags)
7036 {
7037     return ctrl->GetFocusObject()->InsertTextWithUndo(this, pos, text, ctrl, flags);
7038 }
7039
7040 /// Submit command to insert the given text
7041 bool wxRichTextParagraphLayoutBox::InsertTextWithUndo(wxRichTextBuffer* buffer, long pos, const wxString& text, wxRichTextCtrl* ctrl, int flags)
7042 {
7043     wxRichTextAction* action = new wxRichTextAction(NULL, _("Insert Text"), wxRICHTEXT_INSERT, buffer, this, ctrl, false);
7044
7045     wxRichTextAttr* p = NULL;
7046     wxRichTextAttr paraAttr;
7047     if (flags & wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE)
7048     {
7049         // Get appropriate paragraph style
7050         paraAttr = GetStyleForNewParagraph(buffer, pos, false, false);
7051         if (!paraAttr.IsDefault())
7052             p = & paraAttr;
7053     }
7054
7055     action->GetNewParagraphs().AddParagraphs(text, p);
7056
7057     int length = action->GetNewParagraphs().GetOwnRange().GetLength();
7058
7059     if (!text.empty() && text.Last() != wxT('\n'))
7060     {
7061         // Don't count the newline when undoing
7062         length --;
7063         action->GetNewParagraphs().SetPartialParagraph(true);
7064     }
7065     else if (!text.empty() && text.Last() == wxT('\n'))
7066         length --;
7067
7068     action->SetPosition(pos);
7069
7070     // Set the range we'll need to delete in Undo
7071     action->SetRange(wxRichTextRange(pos, pos + length - 1));
7072
7073     buffer->SubmitAction(action);
7074
7075     return true;
7076 }
7077
7078 /// Submit command to insert the given text
7079 bool wxRichTextBuffer::InsertNewlineWithUndo(long pos, wxRichTextCtrl* ctrl, int flags)
7080 {
7081     return ctrl->GetFocusObject()->InsertNewlineWithUndo(this, pos, ctrl, flags);
7082 }
7083
7084 /// Submit command to insert the given text
7085 bool wxRichTextParagraphLayoutBox::InsertNewlineWithUndo(wxRichTextBuffer* buffer, long pos, wxRichTextCtrl* ctrl, int flags)
7086 {
7087     wxRichTextAction* action = new wxRichTextAction(NULL, _("Insert Text"), wxRICHTEXT_INSERT, buffer, this, ctrl, false);
7088
7089     wxRichTextAttr* p = NULL;
7090     wxRichTextAttr paraAttr;
7091     if (flags & wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE)
7092     {
7093         paraAttr = GetStyleForNewParagraph(buffer, pos, false, true /* look for next paragraph style */);
7094         if (!paraAttr.IsDefault())
7095             p = & paraAttr;
7096     }
7097
7098     wxRichTextAttr attr(buffer->GetDefaultStyle());
7099     // Don't include box attributes such as margins
7100     attr.GetTextBoxAttr().Reset();
7101
7102     wxRichTextParagraph* newPara = new wxRichTextParagraph(wxEmptyString, this, & attr);
7103     action->GetNewParagraphs().AppendChild(newPara);
7104     action->GetNewParagraphs().UpdateRanges();
7105     action->GetNewParagraphs().SetPartialParagraph(false);
7106     wxRichTextParagraph* para = GetParagraphAtPosition(pos, false);
7107     long pos1 = pos;
7108
7109     if (p)
7110         newPara->SetAttributes(*p);
7111
7112     if (flags & wxRICHTEXT_INSERT_INTERACTIVE)
7113     {
7114         if (para && para->GetRange().GetEnd() == pos)
7115             pos1 ++;
7116
7117         // Now see if we need to number the paragraph.
7118         if (newPara->GetAttributes().HasBulletNumber())
7119         {
7120             wxRichTextAttr numberingAttr;
7121             if (FindNextParagraphNumber(para, numberingAttr))
7122                 wxRichTextApplyStyle(newPara->GetAttributes(), (const wxRichTextAttr&) numberingAttr);
7123         }
7124     }
7125
7126     action->SetPosition(pos);
7127
7128     // Use the default character style
7129     if (!buffer->GetDefaultStyle().IsDefault() && newPara->GetChildren().GetFirst())
7130     {
7131         // Check whether the default style merely reflects the paragraph/basic style,
7132         // in which case don't apply it.
7133         wxRichTextAttr defaultStyle(buffer->GetDefaultStyle());
7134         defaultStyle.GetTextBoxAttr().Reset();
7135         wxRichTextAttr toApply;
7136         if (para)
7137         {
7138             wxRichTextAttr combinedAttr = para->GetCombinedAttributes(true /* include box attributes */);
7139             wxRichTextAttr newAttr;
7140             // This filters out attributes that are accounted for by the current
7141             // paragraph/basic style
7142             wxRichTextApplyStyle(toApply, defaultStyle, & combinedAttr);
7143         }
7144         else
7145             toApply = defaultStyle;
7146
7147         if (!toApply.IsDefault())
7148             newPara->GetChildren().GetFirst()->GetData()->SetAttributes(toApply);
7149     }
7150
7151     // Set the range we'll need to delete in Undo
7152     action->SetRange(wxRichTextRange(pos1, pos1));
7153
7154     buffer->SubmitAction(action);
7155
7156     return true;
7157 }
7158
7159 /// Submit command to insert the given image
7160 bool wxRichTextBuffer::InsertImageWithUndo(long pos, const wxRichTextImageBlock& imageBlock, wxRichTextCtrl* ctrl, int flags,
7161                                             const wxRichTextAttr& textAttr)
7162 {
7163     return ctrl->GetFocusObject()->InsertImageWithUndo(this, pos, imageBlock, ctrl, flags, textAttr);
7164 }
7165
7166 /// Submit command to insert the given image
7167 bool wxRichTextParagraphLayoutBox::InsertImageWithUndo(wxRichTextBuffer* buffer, long pos, const wxRichTextImageBlock& imageBlock,
7168                                                         wxRichTextCtrl* ctrl, int flags,
7169                                                         const wxRichTextAttr& textAttr)
7170 {
7171     wxRichTextAction* action = new wxRichTextAction(NULL, _("Insert Image"), wxRICHTEXT_INSERT, buffer, this, ctrl, false);
7172
7173     wxRichTextAttr* p = NULL;
7174     wxRichTextAttr paraAttr;
7175     if (flags & wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE)
7176     {
7177         paraAttr = GetStyleForNewParagraph(buffer, pos);
7178         if (!paraAttr.IsDefault())
7179             p = & paraAttr;
7180     }
7181
7182     wxRichTextAttr attr(buffer->GetDefaultStyle());
7183
7184     // Don't include box attributes such as margins
7185     attr.GetTextBoxAttr().Reset();
7186
7187     wxRichTextParagraph* newPara = new wxRichTextParagraph(this, & attr);
7188     if (p)
7189         newPara->SetAttributes(*p);
7190
7191     wxRichTextImage* imageObject = new wxRichTextImage(imageBlock, newPara);
7192     newPara->AppendChild(imageObject);
7193     imageObject->SetAttributes(textAttr);
7194     action->GetNewParagraphs().AppendChild(newPara);
7195     action->GetNewParagraphs().UpdateRanges();
7196
7197     action->GetNewParagraphs().SetPartialParagraph(true);
7198
7199     action->SetPosition(pos);
7200
7201     // Set the range we'll need to delete in Undo
7202     action->SetRange(wxRichTextRange(pos, pos));
7203
7204     buffer->SubmitAction(action);
7205
7206     return true;
7207 }
7208
7209 // Insert an object with no change of it
7210 wxRichTextObject* wxRichTextBuffer::InsertObjectWithUndo(long pos, wxRichTextObject *object, wxRichTextCtrl* ctrl, int flags)
7211 {
7212     return ctrl->GetFocusObject()->InsertObjectWithUndo(this, pos, object, ctrl, flags);
7213 }
7214
7215 // Insert an object with no change of it
7216 wxRichTextObject* wxRichTextParagraphLayoutBox::InsertObjectWithUndo(wxRichTextBuffer* buffer, long pos, wxRichTextObject *object, wxRichTextCtrl* ctrl, int flags)
7217 {
7218     wxRichTextAction* action = new wxRichTextAction(NULL, _("Insert Object"), wxRICHTEXT_INSERT, buffer, this, ctrl, false);
7219
7220     wxRichTextAttr* p = NULL;
7221     wxRichTextAttr paraAttr;
7222     if (flags & wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE)
7223     {
7224         paraAttr = GetStyleForNewParagraph(buffer, pos);
7225         if (!paraAttr.IsDefault())
7226             p = & paraAttr;
7227     }
7228
7229     wxRichTextAttr attr(buffer->GetDefaultStyle());
7230
7231     // Don't include box attributes such as margins
7232     attr.GetTextBoxAttr().Reset();
7233
7234     wxRichTextParagraph* newPara = new wxRichTextParagraph(this, & attr);
7235     if (p)
7236         newPara->SetAttributes(*p);
7237
7238     newPara->AppendChild(object);
7239     action->GetNewParagraphs().AppendChild(newPara);
7240     action->GetNewParagraphs().UpdateRanges();
7241
7242     action->GetNewParagraphs().SetPartialParagraph(true);
7243
7244     action->SetPosition(pos);
7245
7246     // Set the range we'll need to delete in Undo
7247     action->SetRange(wxRichTextRange(pos, pos));
7248
7249     buffer->SubmitAction(action);
7250
7251     wxRichTextObject* obj = GetLeafObjectAtPosition(pos);
7252     return obj;
7253 }
7254
7255 wxRichTextField* wxRichTextParagraphLayoutBox::InsertFieldWithUndo(wxRichTextBuffer* buffer, long pos, const wxString& fieldType,
7256                                                         const wxRichTextProperties& properties,
7257                                                         wxRichTextCtrl* ctrl, int flags,
7258                                                         const wxRichTextAttr& textAttr)
7259 {
7260     wxRichTextAction* action = new wxRichTextAction(NULL, _("Insert Field"), wxRICHTEXT_INSERT, buffer, this, ctrl, false);
7261
7262     wxRichTextAttr* p = NULL;
7263     wxRichTextAttr paraAttr;
7264     if (flags & wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE)
7265     {
7266         paraAttr = GetStyleForNewParagraph(buffer, pos);
7267         if (!paraAttr.IsDefault())
7268             p = & paraAttr;
7269     }
7270
7271     wxRichTextAttr attr(buffer->GetDefaultStyle());
7272
7273     // Don't include box attributes such as margins
7274     attr.GetTextBoxAttr().Reset();
7275
7276     wxRichTextParagraph* newPara = new wxRichTextParagraph(this, & attr);
7277     if (p)
7278         newPara->SetAttributes(*p);
7279
7280     wxRichTextField* fieldObject = new wxRichTextField();
7281     fieldObject->wxRichTextObject::SetProperties(properties);
7282     fieldObject->SetFieldType(fieldType);
7283     fieldObject->SetAttributes(textAttr);
7284     newPara->AppendChild(fieldObject);
7285     action->GetNewParagraphs().AppendChild(newPara);
7286     action->GetNewParagraphs().UpdateRanges();
7287     action->GetNewParagraphs().SetPartialParagraph(true);
7288     action->SetPosition(pos);
7289
7290     // Set the range we'll need to delete in Undo
7291     action->SetRange(wxRichTextRange(pos, pos));
7292
7293     buffer->SubmitAction(action);
7294
7295     wxRichTextField* obj = wxDynamicCast(GetLeafObjectAtPosition(pos), wxRichTextField);
7296     return obj;
7297 }
7298
7299 /// Get the style that is appropriate for a new paragraph at this position.
7300 /// If the previous paragraph has a paragraph style name, look up the next-paragraph
7301 /// style.
7302 wxRichTextAttr wxRichTextParagraphLayoutBox::GetStyleForNewParagraph(wxRichTextBuffer* buffer, long pos, bool caretPosition, bool lookUpNewParaStyle) const
7303 {
7304     wxRichTextParagraph* para = GetParagraphAtPosition(pos, caretPosition);
7305     if (para)
7306     {
7307         wxRichTextAttr attr;
7308         bool foundAttributes = false;
7309
7310         // Look for a matching paragraph style
7311         if (lookUpNewParaStyle && !para->GetAttributes().GetParagraphStyleName().IsEmpty() && buffer->GetStyleSheet())
7312         {
7313             wxRichTextParagraphStyleDefinition* paraDef = buffer->GetStyleSheet()->FindParagraphStyle(para->GetAttributes().GetParagraphStyleName());
7314             if (paraDef)
7315             {
7316                 // If we're not at the end of the paragraph, then we apply THIS style, and not the designated next style.
7317                 if (para->GetRange().GetEnd() == pos && !paraDef->GetNextStyle().IsEmpty())
7318                 {
7319                     wxRichTextParagraphStyleDefinition* nextParaDef = buffer->GetStyleSheet()->FindParagraphStyle(paraDef->GetNextStyle());
7320                     if (nextParaDef)
7321                     {
7322                         foundAttributes = true;
7323                         attr = nextParaDef->GetStyleMergedWithBase(buffer->GetStyleSheet());
7324                     }
7325                 }
7326
7327                 // If we didn't find the 'next style', use this style instead.
7328                 if (!foundAttributes)
7329                 {
7330                     foundAttributes = true;
7331                     attr = paraDef->GetStyleMergedWithBase(buffer->GetStyleSheet());
7332                 }
7333             }
7334         }
7335
7336         // Also apply list style if present
7337         if (lookUpNewParaStyle && !para->GetAttributes().GetListStyleName().IsEmpty() && buffer->GetStyleSheet())
7338         {
7339             wxRichTextListStyleDefinition* listDef = buffer->GetStyleSheet()->FindListStyle(para->GetAttributes().GetListStyleName());
7340             if (listDef)
7341             {
7342                 int thisIndent = para->GetAttributes().GetLeftIndent();
7343                 int thisLevel = para->GetAttributes().HasOutlineLevel() ? para->GetAttributes().GetOutlineLevel() : listDef->FindLevelForIndent(thisIndent);
7344
7345                 // Apply the overall list style, and item style for this level
7346                 wxRichTextAttr listStyle(listDef->GetCombinedStyleForLevel(thisLevel, buffer->GetStyleSheet()));
7347                 wxRichTextApplyStyle(attr, listStyle);
7348                 attr.SetOutlineLevel(thisLevel);
7349                 if (para->GetAttributes().HasBulletNumber())
7350                     attr.SetBulletNumber(para->GetAttributes().GetBulletNumber());
7351             }
7352         }
7353
7354         if (!foundAttributes)
7355         {
7356             attr = para->GetAttributes();
7357             int flags = attr.GetFlags();
7358
7359             // Eliminate character styles
7360             flags &= ( (~ wxTEXT_ATTR_FONT) |
7361                     (~ wxTEXT_ATTR_TEXT_COLOUR) |
7362                     (~ wxTEXT_ATTR_BACKGROUND_COLOUR) );
7363             attr.SetFlags(flags);
7364         }
7365
7366         return attr;
7367     }
7368     else
7369         return wxRichTextAttr();
7370 }
7371
7372 /// Submit command to delete this range
7373 bool wxRichTextBuffer::DeleteRangeWithUndo(const wxRichTextRange& range, wxRichTextCtrl* ctrl)
7374 {
7375     return ctrl->GetFocusObject()->DeleteRangeWithUndo(range, ctrl, this);
7376 }
7377
7378 /// Submit command to delete this range
7379 bool wxRichTextParagraphLayoutBox::DeleteRangeWithUndo(const wxRichTextRange& range, wxRichTextCtrl* ctrl, wxRichTextBuffer* buffer)
7380 {
7381     wxRichTextAction* action = new wxRichTextAction(NULL, _("Delete"), wxRICHTEXT_DELETE, buffer, this, ctrl);
7382
7383     action->SetPosition(ctrl->GetCaretPosition());
7384
7385     // Set the range to delete
7386     action->SetRange(range);
7387
7388     // Copy the fragment that we'll need to restore in Undo
7389     CopyFragment(range, action->GetOldParagraphs());
7390
7391     // See if we're deleting a paragraph marker, in which case we need to
7392     // make a note not to copy the attributes from the 2nd paragraph to the 1st.
7393     if (range.GetStart() == range.GetEnd())
7394     {
7395         wxRichTextParagraph* para = GetParagraphAtPosition(range.GetStart());
7396         if (para && para->GetRange().GetEnd() == range.GetEnd())
7397         {
7398             wxRichTextParagraph* nextPara = GetParagraphAtPosition(range.GetStart()+1);
7399             if (nextPara && nextPara != para)
7400             {
7401                 action->GetOldParagraphs().GetChildren().GetFirst()->GetData()->SetAttributes(nextPara->GetAttributes());
7402                 action->GetOldParagraphs().GetAttributes().SetFlags(action->GetOldParagraphs().GetAttributes().GetFlags() | wxTEXT_ATTR_KEEP_FIRST_PARA_STYLE);
7403             }
7404         }
7405     }
7406
7407     buffer->SubmitAction(action);
7408
7409     return true;
7410 }
7411
7412 /// Collapse undo/redo commands
7413 bool wxRichTextBuffer::BeginBatchUndo(const wxString& cmdName)
7414 {
7415     if (m_batchedCommandDepth == 0)
7416     {
7417         wxASSERT(m_batchedCommand == NULL);
7418         if (m_batchedCommand)
7419         {
7420             GetCommandProcessor()->Store(m_batchedCommand);
7421         }
7422         m_batchedCommand = new wxRichTextCommand(cmdName);
7423     }
7424
7425     m_batchedCommandDepth ++;
7426
7427     return true;
7428 }
7429
7430 /// Collapse undo/redo commands
7431 bool wxRichTextBuffer::EndBatchUndo()
7432 {
7433     m_batchedCommandDepth --;
7434
7435     wxASSERT(m_batchedCommandDepth >= 0);
7436     wxASSERT(m_batchedCommand != NULL);
7437
7438     if (m_batchedCommandDepth == 0)
7439     {
7440         GetCommandProcessor()->Store(m_batchedCommand);
7441         m_batchedCommand = NULL;
7442     }
7443
7444     return true;
7445 }
7446
7447 /// Submit immediately, or delay according to whether collapsing is on
7448 bool wxRichTextBuffer::SubmitAction(wxRichTextAction* action)
7449 {
7450     if (action && !action->GetNewParagraphs().IsEmpty())
7451         PrepareContent(action->GetNewParagraphs());
7452
7453     if (BatchingUndo() && m_batchedCommand && !SuppressingUndo())
7454     {
7455         wxRichTextCommand* cmd = new wxRichTextCommand(action->GetName());
7456         cmd->AddAction(action);
7457         cmd->Do();
7458         cmd->GetActions().Clear();
7459         delete cmd;
7460
7461         m_batchedCommand->AddAction(action);
7462     }
7463     else
7464     {
7465         wxRichTextCommand* cmd = new wxRichTextCommand(action->GetName());
7466         cmd->AddAction(action);
7467
7468         // Only store it if we're not suppressing undo.
7469         return GetCommandProcessor()->Submit(cmd, !SuppressingUndo());
7470     }
7471
7472     return true;
7473 }
7474
7475 /// Begin suppressing undo/redo commands.
7476 bool wxRichTextBuffer::BeginSuppressUndo()
7477 {
7478     m_suppressUndo ++;
7479
7480     return true;
7481 }
7482
7483 /// End suppressing undo/redo commands.
7484 bool wxRichTextBuffer::EndSuppressUndo()
7485 {
7486     m_suppressUndo --;
7487
7488     return true;
7489 }
7490
7491 /// Begin using a style
7492 bool wxRichTextBuffer::BeginStyle(const wxRichTextAttr& style)
7493 {
7494     wxRichTextAttr newStyle(GetDefaultStyle());
7495     newStyle.GetTextBoxAttr().Reset();
7496
7497     // Save the old default style
7498     m_attributeStack.Append((wxObject*) new wxRichTextAttr(newStyle));
7499
7500     wxRichTextApplyStyle(newStyle, style);
7501     newStyle.SetFlags(style.GetFlags()|newStyle.GetFlags());
7502
7503     SetDefaultStyle(newStyle);
7504
7505     return true;
7506 }
7507
7508 /// End the style
7509 bool wxRichTextBuffer::EndStyle()
7510 {
7511     if (!m_attributeStack.GetFirst())
7512     {
7513         wxLogDebug(_("Too many EndStyle calls!"));
7514         return false;
7515     }
7516
7517     wxList::compatibility_iterator node = m_attributeStack.GetLast();
7518     wxRichTextAttr* attr = (wxRichTextAttr*)node->GetData();
7519     m_attributeStack.Erase(node);
7520
7521     SetDefaultStyle(*attr);
7522
7523     delete attr;
7524     return true;
7525 }
7526
7527 /// End all styles
7528 bool wxRichTextBuffer::EndAllStyles()
7529 {
7530     while (m_attributeStack.GetCount() != 0)
7531         EndStyle();
7532     return true;
7533 }
7534
7535 /// Clear the style stack
7536 void wxRichTextBuffer::ClearStyleStack()
7537 {
7538     for (wxList::compatibility_iterator node = m_attributeStack.GetFirst(); node; node = node->GetNext())
7539         delete (wxRichTextAttr*) node->GetData();
7540     m_attributeStack.Clear();
7541 }
7542
7543 /// Begin using bold
7544 bool wxRichTextBuffer::BeginBold()
7545 {
7546     wxRichTextAttr attr;
7547     attr.SetFontWeight(wxFONTWEIGHT_BOLD);
7548
7549     return BeginStyle(attr);
7550 }
7551
7552 /// Begin using italic
7553 bool wxRichTextBuffer::BeginItalic()
7554 {
7555     wxRichTextAttr attr;
7556     attr.SetFontStyle(wxFONTSTYLE_ITALIC);
7557
7558     return BeginStyle(attr);
7559 }
7560
7561 /// Begin using underline
7562 bool wxRichTextBuffer::BeginUnderline()
7563 {
7564     wxRichTextAttr attr;
7565     attr.SetFontUnderlined(true);
7566
7567     return BeginStyle(attr);
7568 }
7569
7570 /// Begin using point size
7571 bool wxRichTextBuffer::BeginFontSize(int pointSize)
7572 {
7573     wxRichTextAttr attr;
7574     attr.SetFontSize(pointSize);
7575
7576     return BeginStyle(attr);
7577 }
7578
7579 /// Begin using this font
7580 bool wxRichTextBuffer::BeginFont(const wxFont& font)
7581 {
7582     wxRichTextAttr attr;
7583     attr.SetFont(font);
7584
7585     return BeginStyle(attr);
7586 }
7587
7588 /// Begin using this colour
7589 bool wxRichTextBuffer::BeginTextColour(const wxColour& colour)
7590 {
7591     wxRichTextAttr attr;
7592     attr.SetFlags(wxTEXT_ATTR_TEXT_COLOUR);
7593     attr.SetTextColour(colour);
7594
7595     return BeginStyle(attr);
7596 }
7597
7598 /// Begin using alignment
7599 bool wxRichTextBuffer::BeginAlignment(wxTextAttrAlignment alignment)
7600 {
7601     wxRichTextAttr attr;
7602     attr.SetFlags(wxTEXT_ATTR_ALIGNMENT);
7603     attr.SetAlignment(alignment);
7604
7605     return BeginStyle(attr);
7606 }
7607
7608 /// Begin left indent
7609 bool wxRichTextBuffer::BeginLeftIndent(int leftIndent, int leftSubIndent)
7610 {
7611     wxRichTextAttr attr;
7612     attr.SetFlags(wxTEXT_ATTR_LEFT_INDENT);
7613     attr.SetLeftIndent(leftIndent, leftSubIndent);
7614
7615     return BeginStyle(attr);
7616 }
7617
7618 /// Begin right indent
7619 bool wxRichTextBuffer::BeginRightIndent(int rightIndent)
7620 {
7621     wxRichTextAttr attr;
7622     attr.SetFlags(wxTEXT_ATTR_RIGHT_INDENT);
7623     attr.SetRightIndent(rightIndent);
7624
7625     return BeginStyle(attr);
7626 }
7627
7628 /// Begin paragraph spacing
7629 bool wxRichTextBuffer::BeginParagraphSpacing(int before, int after)
7630 {
7631     long flags = 0;
7632     if (before != 0)
7633         flags |= wxTEXT_ATTR_PARA_SPACING_BEFORE;
7634     if (after != 0)
7635         flags |= wxTEXT_ATTR_PARA_SPACING_AFTER;
7636
7637     wxRichTextAttr attr;
7638     attr.SetFlags(flags);
7639     attr.SetParagraphSpacingBefore(before);
7640     attr.SetParagraphSpacingAfter(after);
7641
7642     return BeginStyle(attr);
7643 }
7644
7645 /// Begin line spacing
7646 bool wxRichTextBuffer::BeginLineSpacing(int lineSpacing)
7647 {
7648     wxRichTextAttr attr;
7649     attr.SetFlags(wxTEXT_ATTR_LINE_SPACING);
7650     attr.SetLineSpacing(lineSpacing);
7651
7652     return BeginStyle(attr);
7653 }
7654
7655 /// Begin numbered bullet
7656 bool wxRichTextBuffer::BeginNumberedBullet(int bulletNumber, int leftIndent, int leftSubIndent, int bulletStyle)
7657 {
7658     wxRichTextAttr attr;
7659     attr.SetFlags(wxTEXT_ATTR_BULLET_STYLE|wxTEXT_ATTR_LEFT_INDENT);
7660     attr.SetBulletStyle(bulletStyle);
7661     attr.SetBulletNumber(bulletNumber);
7662     attr.SetLeftIndent(leftIndent, leftSubIndent);
7663
7664     return BeginStyle(attr);
7665 }
7666
7667 /// Begin symbol bullet
7668 bool wxRichTextBuffer::BeginSymbolBullet(const wxString& symbol, int leftIndent, int leftSubIndent, int bulletStyle)
7669 {
7670     wxRichTextAttr attr;
7671     attr.SetFlags(wxTEXT_ATTR_BULLET_STYLE|wxTEXT_ATTR_LEFT_INDENT);
7672     attr.SetBulletStyle(bulletStyle);
7673     attr.SetLeftIndent(leftIndent, leftSubIndent);
7674     attr.SetBulletText(symbol);
7675
7676     return BeginStyle(attr);
7677 }
7678
7679 /// Begin standard bullet
7680 bool wxRichTextBuffer::BeginStandardBullet(const wxString& bulletName, int leftIndent, int leftSubIndent, int bulletStyle)
7681 {
7682     wxRichTextAttr attr;
7683     attr.SetFlags(wxTEXT_ATTR_BULLET_STYLE|wxTEXT_ATTR_LEFT_INDENT);
7684     attr.SetBulletStyle(bulletStyle);
7685     attr.SetLeftIndent(leftIndent, leftSubIndent);
7686     attr.SetBulletName(bulletName);
7687
7688     return BeginStyle(attr);
7689 }
7690
7691 /// Begin named character style
7692 bool wxRichTextBuffer::BeginCharacterStyle(const wxString& characterStyle)
7693 {
7694     if (GetStyleSheet())
7695     {
7696         wxRichTextCharacterStyleDefinition* def = GetStyleSheet()->FindCharacterStyle(characterStyle);
7697         if (def)
7698         {
7699             wxRichTextAttr attr = def->GetStyleMergedWithBase(GetStyleSheet());
7700             return BeginStyle(attr);
7701         }
7702     }
7703     return false;
7704 }
7705
7706 /// Begin named paragraph style
7707 bool wxRichTextBuffer::BeginParagraphStyle(const wxString& paragraphStyle)
7708 {
7709     if (GetStyleSheet())
7710     {
7711         wxRichTextParagraphStyleDefinition* def = GetStyleSheet()->FindParagraphStyle(paragraphStyle);
7712         if (def)
7713         {
7714             wxRichTextAttr attr = def->GetStyleMergedWithBase(GetStyleSheet());
7715             return BeginStyle(attr);
7716         }
7717     }
7718     return false;
7719 }
7720
7721 /// Begin named list style
7722 bool wxRichTextBuffer::BeginListStyle(const wxString& listStyle, int level, int number)
7723 {
7724     if (GetStyleSheet())
7725     {
7726         wxRichTextListStyleDefinition* def = GetStyleSheet()->FindListStyle(listStyle);
7727         if (def)
7728         {
7729             wxRichTextAttr attr(def->GetCombinedStyleForLevel(level));
7730
7731             attr.SetBulletNumber(number);
7732
7733             return BeginStyle(attr);
7734         }
7735     }
7736     return false;
7737 }
7738
7739 /// Begin URL
7740 bool wxRichTextBuffer::BeginURL(const wxString& url, const wxString& characterStyle)
7741 {
7742     wxRichTextAttr attr;
7743
7744     if (!characterStyle.IsEmpty() && GetStyleSheet())
7745     {
7746         wxRichTextCharacterStyleDefinition* def = GetStyleSheet()->FindCharacterStyle(characterStyle);
7747         if (def)
7748         {
7749             attr = def->GetStyleMergedWithBase(GetStyleSheet());
7750         }
7751     }
7752     attr.SetURL(url);
7753
7754     return BeginStyle(attr);
7755 }
7756
7757 /// Adds a handler to the end
7758 void wxRichTextBuffer::AddHandler(wxRichTextFileHandler *handler)
7759 {
7760     sm_handlers.Append(handler);
7761 }
7762
7763 /// Inserts a handler at the front
7764 void wxRichTextBuffer::InsertHandler(wxRichTextFileHandler *handler)
7765 {
7766     sm_handlers.Insert( handler );
7767 }
7768
7769 /// Removes a handler
7770 bool wxRichTextBuffer::RemoveHandler(const wxString& name)
7771 {
7772     wxRichTextFileHandler *handler = FindHandler(name);
7773     if (handler)
7774     {
7775         sm_handlers.DeleteObject(handler);
7776         delete handler;
7777         return true;
7778     }
7779     else
7780         return false;
7781 }
7782
7783 /// Finds a handler by filename or, if supplied, type
7784 wxRichTextFileHandler *wxRichTextBuffer::FindHandlerFilenameOrType(const wxString& filename,
7785                                                                    wxRichTextFileType imageType)
7786 {
7787     if (imageType != wxRICHTEXT_TYPE_ANY)
7788         return FindHandler(imageType);
7789     else if (!filename.IsEmpty())
7790     {
7791         wxString path, file, ext;
7792         wxFileName::SplitPath(filename, & path, & file, & ext);
7793         return FindHandler(ext, imageType);
7794     }
7795     else
7796         return NULL;
7797 }
7798
7799
7800 /// Finds a handler by name
7801 wxRichTextFileHandler* wxRichTextBuffer::FindHandler(const wxString& name)
7802 {
7803     wxList::compatibility_iterator node = sm_handlers.GetFirst();
7804     while (node)
7805     {
7806         wxRichTextFileHandler *handler = (wxRichTextFileHandler*)node->GetData();
7807         if (handler->GetName().Lower() == name.Lower()) return handler;
7808
7809         node = node->GetNext();
7810     }
7811     return NULL;
7812 }
7813
7814 /// Finds a handler by extension and type
7815 wxRichTextFileHandler* wxRichTextBuffer::FindHandler(const wxString& extension, wxRichTextFileType type)
7816 {
7817     wxList::compatibility_iterator node = sm_handlers.GetFirst();
7818     while (node)
7819     {
7820         wxRichTextFileHandler *handler = (wxRichTextFileHandler*)node->GetData();
7821         if ( handler->GetExtension().Lower() == extension.Lower() &&
7822             (type == wxRICHTEXT_TYPE_ANY || handler->GetType() == type) )
7823             return handler;
7824         node = node->GetNext();
7825     }
7826     return 0;
7827 }
7828
7829 /// Finds a handler by type
7830 wxRichTextFileHandler* wxRichTextBuffer::FindHandler(wxRichTextFileType type)
7831 {
7832     wxList::compatibility_iterator node = sm_handlers.GetFirst();
7833     while (node)
7834     {
7835         wxRichTextFileHandler *handler = (wxRichTextFileHandler *)node->GetData();
7836         if (handler->GetType() == type) return handler;
7837         node = node->GetNext();
7838     }
7839     return NULL;
7840 }
7841
7842 void wxRichTextBuffer::InitStandardHandlers()
7843 {
7844     if (!FindHandler(wxRICHTEXT_TYPE_TEXT))
7845         AddHandler(new wxRichTextPlainTextHandler);
7846 }
7847
7848 void wxRichTextBuffer::CleanUpHandlers()
7849 {
7850     wxList::compatibility_iterator node = sm_handlers.GetFirst();
7851     while (node)
7852     {
7853         wxRichTextFileHandler* handler = (wxRichTextFileHandler*)node->GetData();
7854         wxList::compatibility_iterator next = node->GetNext();
7855         delete handler;
7856         node = next;
7857     }
7858
7859     sm_handlers.Clear();
7860 }
7861
7862 wxString wxRichTextBuffer::GetExtWildcard(bool combine, bool save, wxArrayInt* types)
7863 {
7864     if (types)
7865         types->Clear();
7866
7867     wxString wildcard;
7868
7869     wxList::compatibility_iterator node = GetHandlers().GetFirst();
7870     int count = 0;
7871     while (node)
7872     {
7873         wxRichTextFileHandler* handler = (wxRichTextFileHandler*) node->GetData();
7874         if (handler->IsVisible() && ((save && handler->CanSave()) || (!save && handler->CanLoad())))
7875         {
7876             if (combine)
7877             {
7878                 if (count > 0)
7879                     wildcard += wxT(";");
7880                 wildcard += wxT("*.") + handler->GetExtension();
7881             }
7882             else
7883             {
7884                 if (count > 0)
7885                     wildcard += wxT("|");
7886                 wildcard += handler->GetName();
7887                 wildcard += wxT(" ");
7888                 wildcard += _("files");
7889                 wildcard += wxT(" (*.");
7890                 wildcard += handler->GetExtension();
7891                 wildcard += wxT(")|*.");
7892                 wildcard += handler->GetExtension();
7893                 if (types)
7894                     types->Add(handler->GetType());
7895             }
7896             count ++;
7897         }
7898
7899         node = node->GetNext();
7900     }
7901
7902     if (combine)
7903         wildcard = wxT("(") + wildcard + wxT(")|") + wildcard;
7904     return wildcard;
7905 }
7906
7907 /// Load a file
7908 bool wxRichTextBuffer::LoadFile(const wxString& filename, wxRichTextFileType type)
7909 {
7910     wxRichTextFileHandler* handler = FindHandlerFilenameOrType(filename, type);
7911     if (handler)
7912     {
7913         SetDefaultStyle(wxRichTextAttr());
7914         handler->SetFlags(GetHandlerFlags());
7915         bool success = handler->LoadFile(this, filename);
7916         Invalidate(wxRICHTEXT_ALL);
7917         return success;
7918     }
7919     else
7920         return false;
7921 }
7922
7923 /// Save a file
7924 bool wxRichTextBuffer::SaveFile(const wxString& filename, wxRichTextFileType type)
7925 {
7926     wxRichTextFileHandler* handler = FindHandlerFilenameOrType(filename, type);
7927     if (handler)
7928     {
7929         handler->SetFlags(GetHandlerFlags());
7930         return handler->SaveFile(this, filename);
7931     }
7932     else
7933         return false;
7934 }
7935
7936 /// Load from a stream
7937 bool wxRichTextBuffer::LoadFile(wxInputStream& stream, wxRichTextFileType type)
7938 {
7939     wxRichTextFileHandler* handler = FindHandler(type);
7940     if (handler)
7941     {
7942         SetDefaultStyle(wxRichTextAttr());
7943         handler->SetFlags(GetHandlerFlags());
7944         bool success = handler->LoadFile(this, stream);
7945         Invalidate(wxRICHTEXT_ALL);
7946         return success;
7947     }
7948     else
7949         return false;
7950 }
7951
7952 /// Save to a stream
7953 bool wxRichTextBuffer::SaveFile(wxOutputStream& stream, wxRichTextFileType type)
7954 {
7955     wxRichTextFileHandler* handler = FindHandler(type);
7956     if (handler)
7957     {
7958         handler->SetFlags(GetHandlerFlags());
7959         return handler->SaveFile(this, stream);
7960     }
7961     else
7962         return false;
7963 }
7964
7965 /// Copy the range to the clipboard
7966 bool wxRichTextBuffer::CopyToClipboard(const wxRichTextRange& range)
7967 {
7968     bool success = false;
7969     wxRichTextParagraphLayoutBox* container = this;
7970     if (GetRichTextCtrl())
7971         container = GetRichTextCtrl()->GetFocusObject();
7972
7973 #if wxUSE_CLIPBOARD && wxUSE_DATAOBJ
7974
7975     if (!wxTheClipboard->IsOpened() && wxTheClipboard->Open())
7976     {
7977         wxTheClipboard->Clear();
7978
7979         // Add composite object
7980
7981         wxDataObjectComposite* compositeObject = new wxDataObjectComposite();
7982
7983         {
7984             wxString text = container->GetTextForRange(range);
7985
7986 #ifdef __WXMSW__
7987             text = wxTextFile::Translate(text, wxTextFileType_Dos);
7988 #endif
7989
7990             compositeObject->Add(new wxTextDataObject(text), false /* not preferred */);
7991         }
7992
7993         // Add rich text buffer data object. This needs the XML handler to be present.
7994
7995         if (FindHandler(wxRICHTEXT_TYPE_XML))
7996         {
7997             wxRichTextBuffer* richTextBuf = new wxRichTextBuffer;
7998             container->CopyFragment(range, *richTextBuf);
7999
8000             compositeObject->Add(new wxRichTextBufferDataObject(richTextBuf), true /* preferred */);
8001         }
8002
8003         if (wxTheClipboard->SetData(compositeObject))
8004             success = true;
8005
8006         wxTheClipboard->Close();
8007     }
8008
8009 #else
8010     wxUnusedVar(range);
8011 #endif
8012     return success;
8013 }
8014
8015 /// Paste the clipboard content to the buffer
8016 bool wxRichTextBuffer::PasteFromClipboard(long position)
8017 {
8018     bool success = false;
8019     wxRichTextParagraphLayoutBox* container = this;
8020     if (GetRichTextCtrl())
8021         container = GetRichTextCtrl()->GetFocusObject();
8022
8023 #if wxUSE_CLIPBOARD && wxUSE_DATAOBJ
8024     if (CanPasteFromClipboard())
8025     {
8026         if (wxTheClipboard->Open())
8027         {
8028             if (wxTheClipboard->IsSupported(wxDataFormat(wxRichTextBufferDataObject::GetRichTextBufferFormatId())))
8029             {
8030                 wxRichTextBufferDataObject data;
8031                 wxTheClipboard->GetData(data);
8032                 wxRichTextBuffer* richTextBuffer = data.GetRichTextBuffer();
8033                 if (richTextBuffer)
8034                 {
8035                     container->InsertParagraphsWithUndo(this, position+1, *richTextBuffer, GetRichTextCtrl(), 0);
8036                     if (GetRichTextCtrl())
8037                         GetRichTextCtrl()->ShowPosition(position + richTextBuffer->GetOwnRange().GetEnd());
8038                     delete richTextBuffer;
8039                 }
8040             }
8041             else if (wxTheClipboard->IsSupported(wxDF_TEXT)
8042  #if wxUSE_UNICODE
8043                      || wxTheClipboard->IsSupported(wxDF_UNICODETEXT)
8044  #endif
8045                     )
8046             {
8047                 wxTextDataObject data;
8048                 wxTheClipboard->GetData(data);
8049                 wxString text(data.GetText());
8050 #ifdef __WXMSW__
8051                 wxString text2;
8052                 text2.Alloc(text.Length()+1);
8053                 size_t i;
8054                 for (i = 0; i < text.Length(); i++)
8055                 {
8056                     wxChar ch = text[i];
8057                     if (ch != wxT('\r'))
8058                         text2 += ch;
8059                 }
8060 #else
8061                 wxString text2 = text;
8062 #endif
8063                 container->InsertTextWithUndo(this, position+1, text2, GetRichTextCtrl(), wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE);
8064
8065                 if (GetRichTextCtrl())
8066                     GetRichTextCtrl()->ShowPosition(position + text2.Length());
8067
8068                 success = true;
8069             }
8070             else if (wxTheClipboard->IsSupported(wxDF_BITMAP))
8071             {
8072                 wxBitmapDataObject data;
8073                 wxTheClipboard->GetData(data);
8074                 wxBitmap bitmap(data.GetBitmap());
8075                 wxImage image(bitmap.ConvertToImage());
8076
8077                 wxRichTextAction* action = new wxRichTextAction(NULL, _("Insert Image"), wxRICHTEXT_INSERT, this, container, GetRichTextCtrl(), false);
8078
8079                 action->GetNewParagraphs().AddImage(image);
8080
8081                 if (action->GetNewParagraphs().GetChildCount() == 1)
8082                     action->GetNewParagraphs().SetPartialParagraph(true);
8083
8084                 action->SetPosition(position+1);
8085
8086                 // Set the range we'll need to delete in Undo
8087                 action->SetRange(wxRichTextRange(position+1, position+1));
8088
8089                 SubmitAction(action);
8090
8091                 success = true;
8092             }
8093             wxTheClipboard->Close();
8094         }
8095     }
8096 #else
8097     wxUnusedVar(position);
8098 #endif
8099     return success;
8100 }
8101
8102 /// Can we paste from the clipboard?
8103 bool wxRichTextBuffer::CanPasteFromClipboard() const
8104 {
8105     bool canPaste = false;
8106 #if wxUSE_CLIPBOARD && wxUSE_DATAOBJ
8107     if (!wxTheClipboard->IsOpened() && wxTheClipboard->Open())
8108     {
8109         if (wxTheClipboard->IsSupported(wxDF_TEXT)
8110 #if wxUSE_UNICODE
8111             || wxTheClipboard->IsSupported(wxDF_UNICODETEXT)
8112 #endif
8113             || wxTheClipboard->IsSupported(wxDataFormat(wxRichTextBufferDataObject::GetRichTextBufferFormatId())) ||
8114             wxTheClipboard->IsSupported(wxDF_BITMAP))
8115         {
8116             canPaste = true;
8117         }
8118         wxTheClipboard->Close();
8119     }
8120 #endif
8121     return canPaste;
8122 }
8123
8124 /// Dumps contents of buffer for debugging purposes
8125 void wxRichTextBuffer::Dump()
8126 {
8127     wxString text;
8128     {
8129         wxStringOutputStream stream(& text);
8130         wxTextOutputStream textStream(stream);
8131         Dump(textStream);
8132     }
8133
8134     wxLogDebug(text);
8135 }
8136
8137 /// Add an event handler
8138 bool wxRichTextBuffer::AddEventHandler(wxEvtHandler* handler)
8139 {
8140     m_eventHandlers.Append(handler);
8141     return true;
8142 }
8143
8144 /// Remove an event handler
8145 bool wxRichTextBuffer::RemoveEventHandler(wxEvtHandler* handler, bool deleteHandler)
8146 {
8147     wxList::compatibility_iterator node = m_eventHandlers.Find(handler);
8148     if (node)
8149     {
8150         m_eventHandlers.Erase(node);
8151         if (deleteHandler)
8152             delete handler;
8153
8154         return true;
8155     }
8156     else
8157         return false;
8158 }
8159
8160 /// Clear event handlers
8161 void wxRichTextBuffer::ClearEventHandlers()
8162 {
8163     m_eventHandlers.Clear();
8164 }
8165
8166 /// Send event to event handlers. If sendToAll is true, will send to all event handlers,
8167 /// otherwise will stop at the first successful one.
8168 bool wxRichTextBuffer::SendEvent(wxEvent& event, bool sendToAll)
8169 {
8170     bool success = false;
8171     for (wxList::compatibility_iterator node = m_eventHandlers.GetFirst(); node; node = node->GetNext())
8172     {
8173         wxEvtHandler* handler = (wxEvtHandler*) node->GetData();
8174         if (handler->ProcessEvent(event))
8175         {
8176             success = true;
8177             if (!sendToAll)
8178                 return true;
8179         }
8180     }
8181     return success;
8182 }
8183
8184 /// Set style sheet and notify of the change
8185 bool wxRichTextBuffer::SetStyleSheetAndNotify(wxRichTextStyleSheet* sheet)
8186 {
8187     wxRichTextStyleSheet* oldSheet = GetStyleSheet();
8188
8189     wxWindowID winid = wxID_ANY;
8190     if (GetRichTextCtrl())
8191         winid = GetRichTextCtrl()->GetId();
8192
8193     wxRichTextEvent event(wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACING, winid);
8194     event.SetEventObject(GetRichTextCtrl());
8195     event.SetContainer(GetRichTextCtrl()->GetFocusObject());
8196     event.SetOldStyleSheet(oldSheet);
8197     event.SetNewStyleSheet(sheet);
8198     event.Allow();
8199
8200     if (SendEvent(event) && !event.IsAllowed())
8201     {
8202         if (sheet != oldSheet)
8203             delete sheet;
8204
8205         return false;
8206     }
8207
8208     if (oldSheet && oldSheet != sheet)
8209         delete oldSheet;
8210
8211     SetStyleSheet(sheet);
8212
8213     event.SetEventType(wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACED);
8214     event.SetOldStyleSheet(NULL);
8215     event.Allow();
8216
8217     return SendEvent(event);
8218 }
8219
8220 /// Set renderer, deleting old one
8221 void wxRichTextBuffer::SetRenderer(wxRichTextRenderer* renderer)
8222 {
8223     if (sm_renderer)
8224         delete sm_renderer;
8225     sm_renderer = renderer;
8226 }
8227
8228 /// Hit-testing: returns a flag indicating hit test details, plus
8229 /// information about position
8230 int wxRichTextBuffer::HitTest(wxDC& dc, wxRichTextDrawingContext& context, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags)
8231 {
8232     int ret = wxRichTextParagraphLayoutBox::HitTest(dc, context, pt, textPosition, obj, contextObj, flags);
8233     if (ret != wxRICHTEXT_HITTEST_NONE)
8234     {
8235         return ret;
8236     }
8237     else
8238     {
8239         textPosition = m_ownRange.GetEnd()-1;
8240         *obj = this;
8241         *contextObj = this;
8242         return wxRICHTEXT_HITTEST_AFTER|wxRICHTEXT_HITTEST_OUTSIDE;
8243     }
8244 }
8245
8246 void wxRichTextBuffer::SetFontScale(double fontScale)
8247 {
8248     m_fontScale = fontScale;
8249     m_fontTable.SetFontScale(fontScale);
8250 }
8251
8252 void wxRichTextBuffer::SetDimensionScale(double dimScale)
8253 {
8254     m_dimensionScale = dimScale;
8255 }
8256
8257 bool wxRichTextStdRenderer::DrawStandardBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& bulletAttr, const wxRect& rect)
8258 {
8259     if (bulletAttr.GetTextColour().IsOk())
8260     {
8261         wxCheckSetPen(dc, wxPen(bulletAttr.GetTextColour()));
8262         wxCheckSetBrush(dc, wxBrush(bulletAttr.GetTextColour()));
8263     }
8264     else
8265     {
8266         wxCheckSetPen(dc, *wxBLACK_PEN);
8267         wxCheckSetBrush(dc, *wxBLACK_BRUSH);
8268     }
8269
8270     wxFont font;
8271     if (bulletAttr.HasFont())
8272     {
8273         font = paragraph->GetBuffer()->GetFontTable().FindFont(bulletAttr);
8274     }
8275     else
8276         font = (*wxNORMAL_FONT);
8277
8278     wxCheckSetFont(dc, font);
8279
8280     int charHeight = dc.GetCharHeight();
8281
8282     int bulletWidth = (int) (((float) charHeight) * wxRichTextBuffer::GetBulletProportion());
8283     int bulletHeight = bulletWidth;
8284
8285     int x = rect.x;
8286
8287     // Calculate the top position of the character (as opposed to the whole line height)
8288     int y = rect.y + (rect.height - charHeight);
8289
8290     // Calculate where the bullet should be positioned
8291     y = y + (charHeight+1)/2 - (bulletHeight+1)/2;
8292
8293     // The margin between a bullet and text.
8294     int margin = paragraph->ConvertTenthsMMToPixels(dc, wxRichTextBuffer::GetBulletRightMargin());
8295
8296     if (bulletAttr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ALIGN_RIGHT)
8297         x = rect.x + rect.width - bulletWidth - margin;
8298     else if (bulletAttr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ALIGN_CENTRE)
8299         x = x + (rect.width)/2 - bulletWidth/2;
8300
8301     if (bulletAttr.GetBulletName() == wxT("standard/square"))
8302     {
8303         dc.DrawRectangle(x, y, bulletWidth, bulletHeight);
8304     }
8305     else if (bulletAttr.GetBulletName() == wxT("standard/diamond"))
8306     {
8307         wxPoint pts[5];
8308         pts[0].x = x;                   pts[0].y = y + bulletHeight/2;
8309         pts[1].x = x + bulletWidth/2;   pts[1].y = y;
8310         pts[2].x = x + bulletWidth;     pts[2].y = y + bulletHeight/2;
8311         pts[3].x = x + bulletWidth/2;   pts[3].y = y + bulletHeight;
8312
8313         dc.DrawPolygon(4, pts);
8314     }
8315     else if (bulletAttr.GetBulletName() == wxT("standard/triangle"))
8316     {
8317         wxPoint pts[3];
8318         pts[0].x = x;                   pts[0].y = y;
8319         pts[1].x = x + bulletWidth;     pts[1].y = y + bulletHeight/2;
8320         pts[2].x = x;                   pts[2].y = y + bulletHeight;
8321
8322         dc.DrawPolygon(3, pts);
8323     }
8324     else if (bulletAttr.GetBulletName() == wxT("standard/circle-outline"))
8325     {
8326         wxCheckSetBrush(dc, *wxTRANSPARENT_BRUSH);
8327         dc.DrawEllipse(x, y, bulletWidth, bulletHeight);
8328     }
8329     else // "standard/circle", and catch-all
8330     {
8331         dc.DrawEllipse(x, y, bulletWidth, bulletHeight);
8332     }
8333
8334     return true;
8335 }
8336
8337 bool wxRichTextStdRenderer::DrawTextBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect, const wxString& text)
8338 {
8339     if (!text.empty())
8340     {
8341         wxFont font;
8342         if ((attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_SYMBOL) && !attr.GetBulletFont().IsEmpty() && attr.HasFont())
8343         {
8344             wxRichTextAttr fontAttr;
8345             if (attr.HasFontPixelSize())
8346                 fontAttr.SetFontPixelSize(attr.GetFontSize());
8347             else
8348                 fontAttr.SetFontPointSize(attr.GetFontSize());
8349             fontAttr.SetFontStyle(attr.GetFontStyle());
8350             fontAttr.SetFontWeight(attr.GetFontWeight());
8351             fontAttr.SetFontUnderlined(attr.GetFontUnderlined());
8352             fontAttr.SetFontFaceName(attr.GetBulletFont());
8353             font = paragraph->GetBuffer()->GetFontTable().FindFont(fontAttr);
8354         }
8355         else if (attr.HasFont())
8356             font = paragraph->GetBuffer()->GetFontTable().FindFont(attr);
8357         else
8358             font = (*wxNORMAL_FONT);
8359
8360         wxCheckSetFont(dc, font);
8361
8362         if (attr.GetTextColour().IsOk())
8363             dc.SetTextForeground(attr.GetTextColour());
8364
8365         dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
8366
8367         int charHeight = dc.GetCharHeight();
8368         wxCoord tw, th;
8369         dc.GetTextExtent(text, & tw, & th);
8370
8371         int x = rect.x;
8372
8373         // Calculate the top position of the character (as opposed to the whole line height)
8374         int y = rect.y + (rect.height - charHeight);
8375
8376         // The margin between a bullet and text.
8377         int margin = paragraph->ConvertTenthsMMToPixels(dc, wxRichTextBuffer::GetBulletRightMargin());
8378
8379         if (attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ALIGN_RIGHT)
8380             x = (rect.x + rect.width) - tw - margin;
8381         else if (attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ALIGN_CENTRE)
8382             x = x + (rect.width)/2 - tw/2;
8383
8384         dc.DrawText(text, x, y);
8385
8386         return true;
8387     }
8388     else
8389         return false;
8390 }
8391
8392 bool wxRichTextStdRenderer::DrawBitmapBullet(wxRichTextParagraph* WXUNUSED(paragraph), wxDC& WXUNUSED(dc), const wxRichTextAttr& WXUNUSED(attr), const wxRect& WXUNUSED(rect))
8393 {
8394     // Currently unimplemented. The intention is to store bitmaps by name in a media store associated
8395     // with the buffer. The store will allow retrieval from memory, disk or other means.
8396     return false;
8397 }
8398
8399 /// Enumerate the standard bullet names currently supported
8400 bool wxRichTextStdRenderer::EnumerateStandardBulletNames(wxArrayString& bulletNames)
8401 {
8402     bulletNames.Add(wxTRANSLATE("standard/circle"));
8403     bulletNames.Add(wxTRANSLATE("standard/circle-outline"));
8404     bulletNames.Add(wxTRANSLATE("standard/square"));
8405     bulletNames.Add(wxTRANSLATE("standard/diamond"));
8406     bulletNames.Add(wxTRANSLATE("standard/triangle"));
8407
8408     return true;
8409 }
8410
8411 /*!
8412  * wxRichTextBox
8413  */
8414
8415 IMPLEMENT_DYNAMIC_CLASS(wxRichTextBox, wxRichTextParagraphLayoutBox)
8416
8417 wxRichTextBox::wxRichTextBox(wxRichTextObject* parent):
8418     wxRichTextParagraphLayoutBox(parent)
8419 {
8420 }
8421
8422 /// Draw the item
8423 bool wxRichTextBox::Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style)
8424 {
8425     if (!IsShown())
8426         return true;
8427
8428     // TODO: if the active object in the control, draw an indication.
8429     // We need to add the concept of active object, and not just focus object,
8430     // so we can apply commands (properties, delete, ...) to objects such as text boxes and images.
8431     // Ultimately we would like to be able to interactively resize an active object
8432     // using drag handles.
8433     return wxRichTextParagraphLayoutBox::Draw(dc, context, range, selection, rect, descent, style);
8434 }
8435
8436 /// Copy
8437 void wxRichTextBox::Copy(const wxRichTextBox& obj)
8438 {
8439     wxRichTextParagraphLayoutBox::Copy(obj);
8440 }
8441
8442 // Edit properties via a GUI
8443 bool wxRichTextBox::EditProperties(wxWindow* parent, wxRichTextBuffer* buffer)
8444 {
8445     wxRichTextObjectPropertiesDialog boxDlg(this, wxGetTopLevelParent(parent), wxID_ANY, _("Box Properties"));
8446     boxDlg.SetAttributes(GetAttributes());
8447
8448     if (boxDlg.ShowModal() == wxID_OK)
8449     {
8450         // By passing wxRICHTEXT_SETSTYLE_RESET, indeterminate attributes set by the user will be set as
8451         // indeterminate in the object.
8452         boxDlg.ApplyStyle(buffer->GetRichTextCtrl(), wxRICHTEXT_SETSTYLE_WITH_UNDO|wxRICHTEXT_SETSTYLE_RESET);
8453         return true;
8454     }
8455     else
8456         return false;
8457 }
8458
8459 /*!
8460  * wxRichTextField
8461  */
8462
8463 IMPLEMENT_DYNAMIC_CLASS(wxRichTextField, wxRichTextParagraphLayoutBox)
8464
8465 wxRichTextField::wxRichTextField(const wxString& fieldType, wxRichTextObject* parent):
8466     wxRichTextParagraphLayoutBox(parent)
8467 {
8468     SetFieldType(fieldType);
8469 }
8470
8471 /// Draw the item
8472 bool wxRichTextField::Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style)
8473 {
8474     if (!IsShown())
8475         return true;
8476
8477     wxRichTextFieldType* fieldType = wxRichTextBuffer::FindFieldType(GetFieldType());
8478     if (fieldType && fieldType->Draw(this, dc, context, range, selection, rect, descent, style))
8479         return true;
8480
8481     // Fallback; but don't draw guidelines.
8482     style &= ~wxRICHTEXT_DRAW_GUIDELINES;
8483     return wxRichTextParagraphLayoutBox::Draw(dc, context, range, selection, rect, descent, style);
8484 }
8485
8486 bool wxRichTextField::Layout(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, const wxRect& parentRect, int style)
8487 {
8488     wxRichTextFieldType* fieldType = wxRichTextBuffer::FindFieldType(GetFieldType());
8489     if (fieldType && fieldType->Layout(this, dc, context, rect, parentRect, style))
8490         return true;
8491
8492     // Fallback
8493     return wxRichTextParagraphLayoutBox::Layout(dc, context, rect, parentRect, style);
8494 }
8495
8496 bool wxRichTextField::GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int flags, wxPoint position, wxArrayInt* partialExtents) const
8497 {
8498     wxRichTextFieldType* fieldType = wxRichTextBuffer::FindFieldType(GetFieldType());
8499     if (fieldType)
8500         return fieldType->GetRangeSize((wxRichTextField*) this, range, size, descent, dc, context, flags, position, partialExtents);
8501
8502     return wxRichTextParagraphLayoutBox::GetRangeSize(range, size, descent, dc, context, flags, position, partialExtents);
8503 }
8504
8505 /// Calculate range
8506 void wxRichTextField::CalculateRange(long start, long& end)
8507 {
8508     if (IsTopLevel())
8509         wxRichTextParagraphLayoutBox::CalculateRange(start, end);
8510     else
8511         wxRichTextObject::CalculateRange(start, end);
8512 }
8513
8514 /// Copy
8515 void wxRichTextField::Copy(const wxRichTextField& obj)
8516 {
8517     wxRichTextParagraphLayoutBox::Copy(obj);
8518
8519     UpdateField(GetBuffer());
8520 }
8521
8522 // Edit properties via a GUI
8523 bool wxRichTextField::EditProperties(wxWindow* parent, wxRichTextBuffer* buffer)
8524 {
8525     wxRichTextFieldType* fieldType = wxRichTextBuffer::FindFieldType(GetFieldType());
8526     if (fieldType)
8527         return fieldType->EditProperties(this, parent, buffer);
8528
8529     return false;
8530 }
8531
8532 bool wxRichTextField::CanEditProperties() const
8533 {
8534     wxRichTextFieldType* fieldType = wxRichTextBuffer::FindFieldType(GetFieldType());
8535     if (fieldType)
8536         return fieldType->CanEditProperties((wxRichTextField*) this);
8537
8538     return false;
8539 }
8540
8541 wxString wxRichTextField::GetPropertiesMenuLabel() const
8542 {
8543     wxRichTextFieldType* fieldType = wxRichTextBuffer::FindFieldType(GetFieldType());
8544     if (fieldType)
8545         return fieldType->GetPropertiesMenuLabel((wxRichTextField*) this);
8546
8547     return wxEmptyString;
8548 }
8549
8550 bool wxRichTextField::UpdateField(wxRichTextBuffer* buffer)
8551 {
8552     wxRichTextFieldType* fieldType = wxRichTextBuffer::FindFieldType(GetFieldType());
8553     if (fieldType)
8554         return fieldType->UpdateField(buffer, (wxRichTextField*) this);
8555
8556     return false;
8557 }
8558
8559 bool wxRichTextField::IsTopLevel() const
8560 {
8561     wxRichTextFieldType* fieldType = wxRichTextBuffer::FindFieldType(GetFieldType());
8562     if (fieldType)
8563         return fieldType->IsTopLevel((wxRichTextField*) this);
8564
8565     return true;
8566 }
8567
8568 IMPLEMENT_CLASS(wxRichTextFieldType, wxObject)
8569
8570 IMPLEMENT_CLASS(wxRichTextFieldTypeStandard, wxRichTextFieldType)
8571
8572 wxRichTextFieldTypeStandard::wxRichTextFieldTypeStandard(const wxString& name, const wxString& label, int displayStyle)
8573 {
8574     Init();
8575
8576     SetName(name);
8577     SetLabel(label);
8578     SetDisplayStyle(displayStyle);
8579 }
8580
8581 wxRichTextFieldTypeStandard::wxRichTextFieldTypeStandard(const wxString& name, const wxBitmap& bitmap, int displayStyle)
8582 {
8583     Init();
8584
8585     SetName(name);
8586     SetBitmap(bitmap);
8587     SetDisplayStyle(displayStyle);
8588 }
8589
8590 void wxRichTextFieldTypeStandard::Init()
8591 {
8592     m_displayStyle = wxRICHTEXT_FIELD_STYLE_RECTANGLE;
8593     m_font = wxFont(6, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
8594     m_textColour = *wxWHITE;
8595     m_borderColour = *wxBLACK;
8596     m_backgroundColour = *wxBLACK;
8597     m_verticalPadding = 1;
8598     m_horizontalPadding = 3;
8599     m_horizontalMargin = 2;
8600     m_verticalMargin = 0;
8601 }
8602
8603 void wxRichTextFieldTypeStandard::Copy(const wxRichTextFieldTypeStandard& field)
8604 {
8605     wxRichTextFieldType::Copy(field);
8606
8607     m_label = field.m_label;
8608     m_displayStyle = field.m_displayStyle;
8609     m_font = field.m_font;
8610     m_textColour = field.m_textColour;
8611     m_borderColour = field.m_borderColour;
8612     m_backgroundColour = field.m_backgroundColour;
8613     m_verticalPadding = field.m_verticalPadding;
8614     m_horizontalPadding = field.m_horizontalPadding;
8615     m_horizontalMargin = field.m_horizontalMargin;
8616     m_bitmap = field.m_bitmap;
8617 }
8618
8619 bool wxRichTextFieldTypeStandard::Draw(wxRichTextField* obj, wxDC& dc, wxRichTextDrawingContext& WXUNUSED(context), const wxRichTextRange& WXUNUSED(range), const wxRichTextSelection& selection, const wxRect& rect, int descent, int WXUNUSED(style))
8620 {
8621     if (m_displayStyle == wxRICHTEXT_FIELD_STYLE_COMPOSITE)
8622         return false; // USe default composite drawing
8623     else // if (m_displayStyle == wxRICHTEXT_FIELD_STYLE_RECTANGLE || m_displayStyle == wxRICHTEXT_FIELD_STYLE_NOBORDER)
8624     {
8625         int borderSize = 1;
8626
8627         wxPen borderPen(m_borderColour, 1, wxSOLID);
8628         wxBrush backgroundBrush(m_backgroundColour);
8629         wxColour textColour(m_textColour);
8630
8631         if (selection.WithinSelection(obj->GetRange().GetStart(), obj))
8632         {
8633             wxColour highlightColour(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT));
8634             wxColour highlightTextColour(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT));
8635
8636             borderPen = wxPen(highlightTextColour, 1, wxSOLID);
8637             backgroundBrush = wxBrush(highlightColour);
8638
8639             wxCheckSetBrush(dc, backgroundBrush);
8640             wxCheckSetPen(dc, wxPen(highlightColour, 1, wxSOLID));
8641             dc.DrawRectangle(rect);
8642         }
8643
8644         if (m_displayStyle != wxRICHTEXT_FIELD_STYLE_NO_BORDER)
8645             borderSize = 0;
8646
8647         // objectRect is the area where the content is drawn, after margins around it have been taken into account
8648         wxRect objectRect = wxRect(wxPoint(rect.x + m_horizontalMargin, rect.y + wxMax(0, rect.height - descent - obj->GetCachedSize().y)),
8649             wxSize(obj->GetCachedSize().x - 2*m_horizontalMargin - borderSize, obj->GetCachedSize().y));
8650
8651         // clientArea is where the text is actually written
8652         wxRect clientArea = objectRect;
8653
8654         if (m_displayStyle == wxRICHTEXT_FIELD_STYLE_RECTANGLE)
8655         {
8656             dc.SetPen(borderPen);
8657             dc.SetBrush(backgroundBrush);
8658             dc.DrawRoundedRectangle(objectRect, 4.0);
8659         }
8660         else if (m_displayStyle == wxRICHTEXT_FIELD_STYLE_START_TAG)
8661         {
8662             int arrowLength = objectRect.height/2;
8663             clientArea.width -= (arrowLength - m_horizontalPadding);
8664
8665             wxPoint pts[5];
8666             pts[0].x = objectRect.x; pts[0].y = objectRect.y;
8667             pts[1].x = objectRect.x + objectRect.width - arrowLength; pts[1].y = objectRect.y;
8668             pts[2].x = objectRect.x + objectRect.width; pts[2].y = objectRect.y + (objectRect.height/2);
8669             pts[3].x = objectRect.x + objectRect.width - arrowLength; pts[3].y = objectRect.y + objectRect.height;
8670             pts[4].x = objectRect.x; pts[4].y = objectRect.y + objectRect.height;
8671             dc.SetPen(borderPen);
8672             dc.SetBrush(backgroundBrush);
8673             dc.DrawPolygon(5, pts);
8674         }
8675         else if (m_displayStyle == wxRICHTEXT_FIELD_STYLE_END_TAG)
8676         {
8677             int arrowLength = objectRect.height/2;
8678             clientArea.width -= (arrowLength - m_horizontalPadding);
8679             clientArea.x += (arrowLength - m_horizontalPadding);
8680
8681             wxPoint pts[5];
8682             pts[0].x = objectRect.x + objectRect.width; pts[0].y = objectRect.y;
8683             pts[1].x = objectRect.x + arrowLength; pts[1].y = objectRect.y;
8684             pts[2].x = objectRect.x; pts[2].y = objectRect.y + (objectRect.height/2);
8685             pts[3].x = objectRect.x + arrowLength; pts[3].y = objectRect.y + objectRect.height;
8686             pts[4].x = objectRect.x + objectRect.width; pts[4].y = objectRect.y + objectRect.height;
8687             dc.SetPen(borderPen);
8688             dc.SetBrush(backgroundBrush);
8689             dc.DrawPolygon(5, pts);
8690         }
8691
8692         if (m_bitmap.IsOk())
8693         {
8694             int x = clientArea.x + (clientArea.width - m_bitmap.GetWidth())/2;
8695             int y = clientArea.y + m_verticalPadding;
8696             dc.DrawBitmap(m_bitmap, x, y, true);
8697
8698             if (selection.WithinSelection(obj->GetRange().GetStart(), obj))
8699             {
8700                 wxCheckSetBrush(dc, *wxBLACK_BRUSH);
8701                 wxCheckSetPen(dc, *wxBLACK_PEN);
8702                 dc.SetLogicalFunction(wxINVERT);
8703                 dc.DrawRectangle(wxRect(x, y, m_bitmap.GetWidth(), m_bitmap.GetHeight()));
8704                 dc.SetLogicalFunction(wxCOPY);
8705             }
8706         }
8707         else
8708         {
8709             wxString label(m_label);
8710             if (label.IsEmpty())
8711                 label = wxT("??");
8712             int w, h, maxDescent;
8713             dc.SetFont(m_font);
8714             dc.GetTextExtent(m_label, & w, &h, & maxDescent);
8715             dc.SetTextForeground(textColour);
8716
8717             int x = clientArea.x + (clientArea.width - w)/2;
8718             int y = clientArea.y + (clientArea.height - (h - maxDescent))/2;
8719             dc.DrawText(m_label, x, y);
8720         }
8721     }
8722
8723     return true;
8724 }
8725
8726 bool wxRichTextFieldTypeStandard::Layout(wxRichTextField* obj, wxDC& dc, wxRichTextDrawingContext& context, const wxRect& WXUNUSED(rect), const wxRect& WXUNUSED(parentRect), int style)
8727 {
8728     if (m_displayStyle == wxRICHTEXT_FIELD_STYLE_COMPOSITE)
8729         return false; // USe default composite layout
8730
8731     wxSize size = GetSize(obj, dc, context, style);
8732     obj->SetCachedSize(size);
8733     obj->SetMinSize(size);
8734     obj->SetMaxSize(size);
8735     return true;
8736 }
8737
8738 bool wxRichTextFieldTypeStandard::GetRangeSize(wxRichTextField* obj, const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int flags, wxPoint position, wxArrayInt* partialExtents) const
8739 {
8740     if (IsTopLevel(obj))
8741         return obj->wxRichTextParagraphLayoutBox::GetRangeSize(range, size, descent, dc, context, flags, position);
8742     else
8743     {
8744         wxSize sz = GetSize(obj, dc, context, 0);
8745         if (partialExtents)
8746         {
8747             int lastSize;
8748             if (partialExtents->GetCount() > 0)
8749                 lastSize = (*partialExtents)[partialExtents->GetCount()-1];
8750             else
8751                 lastSize = 0;
8752             partialExtents->Add(lastSize + sz.x);
8753         }
8754         size = sz;
8755        return true;
8756     }
8757 }
8758
8759 wxSize wxRichTextFieldTypeStandard::GetSize(wxRichTextField* WXUNUSED(obj), wxDC& dc, wxRichTextDrawingContext& WXUNUSED(context), int WXUNUSED(style)) const
8760 {
8761     int borderSize = 1;
8762     int w = 0, h = 0, maxDescent = 0;
8763
8764     wxSize sz;
8765     if (m_bitmap.IsOk())
8766     {
8767         w = m_bitmap.GetWidth();
8768         h = m_bitmap.GetHeight();
8769
8770         sz = wxSize(w + m_horizontalMargin*2, h + m_verticalMargin*2);
8771     }
8772     else
8773     {
8774         wxString label(m_label);
8775         if (label.IsEmpty())
8776             label = wxT("??");
8777         dc.SetFont(m_font);
8778         dc.GetTextExtent(label, & w, &h, & maxDescent);
8779
8780         sz = wxSize(w + m_horizontalPadding*2 + m_horizontalMargin*2, h + m_verticalPadding *2 + m_verticalMargin*2);
8781     }
8782
8783     if (m_displayStyle != wxRICHTEXT_FIELD_STYLE_NO_BORDER)
8784     {
8785         sz.x += borderSize*2;
8786         sz.y += borderSize*2;
8787     }
8788
8789     if (m_displayStyle == wxRICHTEXT_FIELD_STYLE_START_TAG || m_displayStyle == wxRICHTEXT_FIELD_STYLE_END_TAG)
8790     {
8791         // Add space for the arrow
8792         sz.x += (sz.y/2 - m_horizontalPadding);
8793     }
8794
8795     return sz;
8796 }
8797
8798 IMPLEMENT_DYNAMIC_CLASS(wxRichTextCell, wxRichTextBox)
8799
8800 wxRichTextCell::wxRichTextCell(wxRichTextObject* parent):
8801     wxRichTextBox(parent)
8802 {
8803 }
8804
8805 /// Draw the item
8806 bool wxRichTextCell::Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style)
8807 {
8808     return wxRichTextBox::Draw(dc, context, range, selection, rect, descent, style);
8809 }
8810
8811 /// Copy
8812 void wxRichTextCell::Copy(const wxRichTextCell& obj)
8813 {
8814     wxRichTextBox::Copy(obj);
8815 }
8816
8817 // Edit properties via a GUI
8818 bool wxRichTextCell::EditProperties(wxWindow* parent, wxRichTextBuffer* buffer)
8819 {
8820     // We need to gather common attributes for all selected cells.
8821
8822     wxRichTextTable* table = wxDynamicCast(GetParent(), wxRichTextTable);
8823     bool multipleCells = false;
8824     wxRichTextAttr attr;
8825
8826     if (table && buffer && buffer->GetRichTextCtrl() && buffer->GetRichTextCtrl()->GetSelection().IsValid() &&
8827         buffer->GetRichTextCtrl()->GetSelection().GetContainer() == GetParent())
8828     {
8829         wxRichTextAttr clashingAttr, absentAttr;
8830         const wxRichTextSelection& sel = buffer->GetRichTextCtrl()->GetSelection();
8831         size_t i;
8832         int selectedCellCount = 0;
8833         for (i = 0; i < sel.GetCount(); i++)
8834         {
8835             const wxRichTextRange& range = sel[i];
8836             wxRichTextCell* cell = table->GetCell(range.GetStart());
8837             if (cell)
8838             {
8839                 wxRichTextAttr cellStyle = cell->GetAttributes();
8840
8841                 CollectStyle(attr, cellStyle, clashingAttr, absentAttr);
8842
8843                 selectedCellCount ++;
8844             }
8845         }
8846         multipleCells = selectedCellCount > 1;
8847     }
8848     else
8849     {
8850         attr = GetAttributes();
8851     }
8852
8853     wxString caption;
8854     if (multipleCells)
8855         caption = _("Multiple Cell Properties");
8856     else
8857         caption = _("Cell Properties");
8858
8859     wxRichTextObjectPropertiesDialog cellDlg(this, wxGetTopLevelParent(parent), wxID_ANY, caption);
8860     cellDlg.SetAttributes(attr);
8861
8862     wxRichTextSizePage* sizePage = wxDynamicCast(cellDlg.FindPage(wxCLASSINFO(wxRichTextSizePage)), wxRichTextSizePage);
8863     if (sizePage)
8864     {
8865         // We don't want position and floating controls for a cell.
8866         sizePage->ShowPositionControls(false);
8867         sizePage->ShowFloatingControls(false);
8868     }
8869
8870     if (cellDlg.ShowModal() == wxID_OK)
8871     {
8872         if (multipleCells)
8873         {
8874             const wxRichTextSelection& sel = buffer->GetRichTextCtrl()->GetSelection();
8875             // Apply the style; we interpret indeterminate attributes as 'don't touch this attribute'
8876             // since it may represent clashing attributes across multiple objects.
8877             table->SetCellStyle(sel, attr);
8878         }
8879         else
8880             // For a single object, indeterminate attributes set by the user should be reflected in the
8881             // actual object style, so pass the wxRICHTEXT_SETSTYLE_RESET flag to assign
8882             // the style directly instead of applying (which ignores indeterminate attributes,
8883             // leaving them as they were).
8884             cellDlg.ApplyStyle(buffer->GetRichTextCtrl(), wxRICHTEXT_SETSTYLE_WITH_UNDO|wxRICHTEXT_SETSTYLE_RESET);
8885         return true;
8886     }
8887     else
8888         return false;
8889 }
8890
8891 WX_DEFINE_OBJARRAY(wxRichTextObjectPtrArrayArray)
8892
8893 IMPLEMENT_DYNAMIC_CLASS(wxRichTextTable, wxRichTextBox)
8894
8895 wxRichTextTable::wxRichTextTable(wxRichTextObject* parent): wxRichTextBox(parent)
8896 {
8897     m_rowCount = 0;
8898     m_colCount = 0;
8899 }
8900
8901 // Draws the object.
8902 bool wxRichTextTable::Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style)
8903 {
8904     return wxRichTextBox::Draw(dc, context, range, selection, rect, descent, style);
8905 }
8906
8907 WX_DECLARE_OBJARRAY(wxRect, wxRichTextRectArray);
8908 WX_DEFINE_OBJARRAY(wxRichTextRectArray);
8909
8910 // Lays the object out. rect is the space available for layout. Often it will
8911 // be the specified overall space for this object, if trying to constrain
8912 // layout to a particular size, or it could be the total space available in the
8913 // parent. rect is the overall size, so we must subtract margins and padding.
8914 // to get the actual available space.
8915 bool wxRichTextTable::Layout(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, const wxRect& WXUNUSED(parentRect), int style)
8916 {
8917     SetPosition(rect.GetPosition());
8918
8919     // TODO: the meaty bit. Calculate sizes of all cells and rows. Try to use
8920     // minimum size if within alloted size, then divide up remaining size
8921     // between rows/cols.
8922
8923     double scale = 1.0;
8924     wxRichTextBuffer* buffer = GetBuffer();
8925     if (buffer) scale = buffer->GetScale();
8926
8927     wxRect availableSpace = GetAvailableContentArea(dc, context, rect);
8928     wxTextAttrDimensionConverter converter(dc, scale, availableSpace.GetSize());
8929
8930     wxRichTextAttr attr(GetAttributes());
8931     context.ApplyVirtualAttributes(attr, this);
8932
8933     // If we have no fixed table size, and assuming we're not pushed for
8934     // space, then we don't have to try to stretch the table to fit the contents.
8935     bool stretchToFitTableWidth = false;
8936
8937     int tableWidth = rect.width;
8938     if (attr.GetTextBoxAttr().GetWidth().IsValid())
8939     {
8940         tableWidth = converter.GetPixels(attr.GetTextBoxAttr().GetWidth());
8941
8942         // Fixed table width, so we do want to stretch columns out if necessary.
8943         stretchToFitTableWidth = true;
8944
8945         // Shouldn't be able to exceed the size passed to this function
8946         tableWidth = wxMin(rect.width, tableWidth);
8947     }
8948
8949     // Get internal padding
8950     int paddingLeft = 0, paddingTop = 0;
8951     if (attr.GetTextBoxAttr().GetPadding().GetLeft().IsValid())
8952         paddingLeft = converter.GetPixels(attr.GetTextBoxAttr().GetPadding().GetLeft());
8953     if (attr.GetTextBoxAttr().GetPadding().GetTop().IsValid())
8954         paddingTop = converter.GetPixels(attr.GetTextBoxAttr().GetPadding().GetTop());
8955
8956     // Assume that left and top padding are also used for inter-cell padding.
8957     int paddingX = paddingLeft;
8958     int paddingY = paddingTop;
8959
8960     int totalLeftMargin = 0, totalRightMargin = 0, totalTopMargin = 0, totalBottomMargin = 0;
8961     GetTotalMargin(dc, buffer, attr, totalLeftMargin, totalRightMargin, totalTopMargin, totalBottomMargin);
8962
8963     // Internal table width - the area for content
8964     int internalTableWidth = tableWidth - totalLeftMargin - totalRightMargin;
8965
8966     int rowCount = m_cells.GetCount();
8967     if (m_colCount == 0 || rowCount == 0)
8968     {
8969         wxRect overallRect(rect.x, rect.y, totalLeftMargin + totalRightMargin, totalTopMargin + totalBottomMargin);
8970         SetCachedSize(overallRect.GetSize());
8971
8972         // Zero content size
8973         SetMinSize(overallRect.GetSize());
8974         SetMaxSize(GetMinSize());
8975         return true;
8976     }
8977
8978     // The final calculated widths
8979     wxArrayInt colWidths;
8980     colWidths.Add(0, m_colCount);
8981
8982     wxArrayInt absoluteColWidths;
8983     absoluteColWidths.Add(0, m_colCount);
8984
8985     wxArrayInt percentageColWidths;
8986     percentageColWidths.Add(0, m_colCount);
8987     // wxArrayInt percentageColWidthsSpanning(m_colCount);
8988     // These are only relevant when the first column contains spanning information.
8989     // wxArrayInt columnSpans(m_colCount); // Each contains 1 for non-spanning cell, > 1 for spanning cell.
8990     wxArrayInt maxColWidths;
8991     maxColWidths.Add(0, m_colCount);
8992     wxArrayInt minColWidths;
8993     minColWidths.Add(0, m_colCount);
8994
8995     wxSize tableSize(tableWidth, 0);
8996
8997     int i, j, k;
8998
8999     for (i = 0; i < m_colCount; i++)
9000     {
9001         absoluteColWidths[i] = 0;
9002         // absoluteColWidthsSpanning[i] = 0;
9003         percentageColWidths[i] = -1;
9004         // percentageColWidthsSpanning[i] = -1;
9005         colWidths[i] = 0;
9006         maxColWidths[i] = 0;
9007         minColWidths[i] = 0;
9008         // columnSpans[i] = 1;
9009     }
9010
9011     // (0) Determine which cells are visible according to spans
9012     //   1  2   3  4   5
9013     //  __________________
9014     // |  |   |      |    | 1
9015     // |------|      |----|
9016     // |------|      |    | 2
9017     // |------|      |    | 3
9018     // |------------------|
9019     // |__________________| 4
9020
9021     // To calculate cell visibility:
9022     // First find all spanning cells. Build an array of span records with start x, y and end x, y.
9023     // Then for each cell, test whether we're within one of those cells, and unless we're at the start of
9024     // that cell, hide the cell.
9025
9026     // We can also use this array to match the size of spanning cells to the grid. Or just do
9027     // this when we iterate through all cells.
9028
9029     // 0.1: add spanning cells to an array
9030     wxRichTextRectArray rectArray;
9031     for (j = 0; j < m_rowCount; j++)
9032     {
9033         for (i = 0; i < m_colCount; i++)
9034         {
9035             wxRichTextBox* cell = GetCell(j, i);
9036             int colSpan = 1, rowSpan = 1;
9037             if (cell->GetProperties().HasProperty(wxT("colspan")))
9038                 colSpan = cell->GetProperties().GetPropertyLong(wxT("colspan"));
9039             if (cell->GetProperties().HasProperty(wxT("rowspan")))
9040                 rowSpan = cell->GetProperties().GetPropertyLong(wxT("rowspan"));
9041             if (colSpan > 1 || rowSpan > 1)
9042             {
9043                 rectArray.Add(wxRect(i, j, colSpan, rowSpan));
9044             }
9045         }
9046     }
9047     // 0.2: find which cells are subsumed by a spanning cell
9048     for (j = 0; j < m_rowCount; j++)
9049     {
9050         for (i = 0; i < m_colCount; i++)
9051         {
9052             wxRichTextBox* cell = GetCell(j, i);
9053             if (rectArray.GetCount() == 0)
9054             {
9055                 cell->Show(true);
9056             }
9057             else
9058             {
9059                 int colSpan = 1, rowSpan = 1;
9060                 if (cell->GetProperties().HasProperty(wxT("colspan")))
9061                     colSpan = cell->GetProperties().GetPropertyLong(wxT("colspan"));
9062                 if (cell->GetProperties().HasProperty(wxT("rowspan")))
9063                     rowSpan = cell->GetProperties().GetPropertyLong(wxT("rowspan"));
9064                 if (colSpan > 1 || rowSpan > 1)
9065                 {
9066                     // Assume all spanning cells are shown
9067                     cell->Show(true);
9068                 }
9069                 else
9070                 {
9071                     bool shown = true;
9072                     for (k = 0; k < (int) rectArray.GetCount(); k++)
9073                     {
9074                         if (rectArray[k].Contains(wxPoint(i, j)))
9075                         {
9076                             shown = false;
9077                             break;
9078                         }
9079                     }
9080                     cell->Show(shown);
9081                 }
9082             }
9083         }
9084     }
9085
9086     // TODO: find the first spanned cell in each row that spans the most columns and doesn't
9087     // overlap with a spanned cell starting at a previous column position.
9088     // This means we need to keep an array of rects so we can check. However
9089     // it does also mean that some spans simply may not be taken into account
9090     // where there are different spans happening on different rows. In these cases,
9091     // they will simply be as wide as their constituent columns.
9092
9093     // (1) Do an initial layout for all cells to get minimum and maximum size, and get
9094     // the absolute or percentage width of each column.
9095
9096     for (j = 0; j < m_rowCount; j++)
9097     {
9098         // First get the overall margins so we can calculate percentage widths based on
9099         // the available content space for all cells on the row
9100
9101         int overallRowContentMargin = 0;
9102         int visibleCellCount = 0;
9103
9104         for (i = 0; i < m_colCount; i++)
9105         {
9106             wxRichTextBox* cell = GetCell(j, i);
9107             if (cell->IsShown())
9108             {
9109                 int cellTotalLeftMargin = 0, cellTotalRightMargin = 0, cellTotalTopMargin = 0, cellTotalBottomMargin = 0;
9110                 GetTotalMargin(dc, buffer, cell->GetAttributes(), cellTotalLeftMargin, cellTotalRightMargin, cellTotalTopMargin, cellTotalBottomMargin);
9111
9112                 overallRowContentMargin += (cellTotalLeftMargin + cellTotalRightMargin);
9113                 visibleCellCount ++;
9114             }
9115         }
9116
9117         // Add in inter-cell padding
9118         overallRowContentMargin += ((visibleCellCount-1) * paddingX);
9119
9120         int rowContentWidth = internalTableWidth - overallRowContentMargin;
9121         wxSize rowTableSize(rowContentWidth, 0);
9122         wxTextAttrDimensionConverter converter(dc, scale, rowTableSize);
9123
9124         for (i = 0; i < m_colCount; i++)
9125         {
9126             wxRichTextBox* cell = GetCell(j, i);
9127             if (cell->IsShown())
9128             {
9129                 int colSpan = 1;
9130                 if (cell->GetProperties().HasProperty(wxT("colspan")))
9131                     colSpan = cell->GetProperties().GetPropertyLong(wxT("colspan"));
9132
9133                 // Lay out cell to find min/max widths
9134                 cell->Invalidate(wxRICHTEXT_ALL);
9135                 cell->Layout(dc, context, availableSpace, availableSpace, style);
9136
9137                 if (colSpan == 1)
9138                 {
9139                     int absoluteCellWidth = -1;
9140                     int percentageCellWidth = -1;
9141
9142                     // I think we need to calculate percentages from the internal table size,
9143                     // minus the padding between cells which we'll need to calculate from the
9144                     // (number of VISIBLE cells - 1)*paddingX. Then percentages that add up to 100%
9145                     // will add up to 100%. In CSS, the width specifies the cell's content rect width,
9146                     // so if we want to conform to that we'll need to add in the overall cell margins.
9147                     // However, this will make it difficult to specify percentages that add up to
9148                     // 100% and still fit within the table width.
9149                     // Let's say two cells have 50% width. They have 10 pixels of overall margin each.
9150                     // The table content rect is 500 pixels and the inter-cell padding is 20 pixels.
9151                     // If we're using internal content size for the width, we would calculate the
9152                     // the overall cell width for n cells as:
9153                     // (500 - 20*(n-1) - overallCellMargin1 - overallCellMargin2 - ...) * percentage / 100
9154                     // + thisOverallCellMargin
9155                     // = 500 - 20 - 10 - 10) * 0.5 + 10 = 240 pixels overall cell width.
9156                     // Adding this back, we get 240 + 240 + 20 = 500 pixels.
9157
9158                     if (cell->GetAttributes().GetTextBoxAttr().GetWidth().IsValid())
9159                     {
9160                         int w = converter.GetPixels(cell->GetAttributes().GetTextBoxAttr().GetWidth());
9161                         if (cell->GetAttributes().GetTextBoxAttr().GetWidth().GetUnits() == wxTEXT_ATTR_UNITS_PERCENTAGE)
9162                         {
9163                             percentageCellWidth = w;
9164                         }
9165                         else
9166                         {
9167                             absoluteCellWidth = w;
9168                         }
9169                         // Override absolute width with minimum width if necessary
9170                         if (cell->GetMinSize().x > 0 && absoluteCellWidth !=1 && cell->GetMinSize().x > absoluteCellWidth)
9171                             absoluteCellWidth = cell->GetMinSize().x;
9172                     }
9173
9174                     if (absoluteCellWidth != -1)
9175                     {
9176                         if (absoluteCellWidth > absoluteColWidths[i])
9177                             absoluteColWidths[i] = absoluteCellWidth;
9178                     }
9179
9180                     if (percentageCellWidth != -1)
9181                     {
9182                         if (percentageCellWidth > percentageColWidths[i])
9183                             percentageColWidths[i] = percentageCellWidth;
9184                     }
9185
9186                     if (colSpan == 1 && cell->GetMinSize().x && cell->GetMinSize().x > minColWidths[i])
9187                         minColWidths[i] = cell->GetMinSize().x;
9188                     if (colSpan == 1 && cell->GetMaxSize().x && cell->GetMaxSize().x > maxColWidths[i])
9189                         maxColWidths[i] = cell->GetMaxSize().x;
9190                 }
9191             }
9192         }
9193     }
9194
9195     // (2) Allocate initial column widths from minimum widths, absolute values and proportions
9196     // TODO: simply merge this into (1).
9197     for (i = 0; i < m_colCount; i++)
9198     {
9199         if (absoluteColWidths[i] > 0)
9200         {
9201             colWidths[i] = absoluteColWidths[i];
9202         }
9203         else if (percentageColWidths[i] > 0)
9204         {
9205             colWidths[i] = percentageColWidths[i];
9206
9207             // This is rubbish - we calculated the absolute widths from percentages, so
9208             // we can't do it again here.
9209             //colWidths[i] = (int) (double(percentageColWidths[i]) * double(tableWidth) / 100.0 + 0.5);
9210         }
9211     }
9212
9213     // (3) Process absolute or proportional widths of spanning columns,
9214     // now that we know what our fixed column widths are going to be.
9215     // Spanned cells will try to adjust columns so the span will fit.
9216     // Even existing fixed column widths can be expanded if necessary.
9217     // Actually, currently fixed columns widths aren't adjusted; instead,
9218     // the algorithm favours earlier rows and adjusts unspecified column widths
9219     // the first time only. After that, we can't know whether the column has been
9220     // specified explicitly or not. (We could make a note if necessary.)
9221     for (j = 0; j < m_rowCount; j++)
9222     {
9223         // First get the overall margins so we can calculate percentage widths based on
9224         // the available content space for all cells on the row
9225
9226         int overallRowContentMargin = 0;
9227         int visibleCellCount = 0;
9228
9229         for (i = 0; i < m_colCount; i++)
9230         {
9231             wxRichTextBox* cell = GetCell(j, i);
9232             if (cell->IsShown())
9233             {
9234                 int cellTotalLeftMargin = 0, cellTotalRightMargin = 0, cellTotalTopMargin = 0, cellTotalBottomMargin = 0;
9235                 GetTotalMargin(dc, buffer, cell->GetAttributes(), cellTotalLeftMargin, cellTotalRightMargin, cellTotalTopMargin, cellTotalBottomMargin);
9236
9237                 overallRowContentMargin += (cellTotalLeftMargin + cellTotalRightMargin);
9238                 visibleCellCount ++;
9239             }
9240         }
9241
9242         // Add in inter-cell padding
9243         overallRowContentMargin += ((visibleCellCount-1) * paddingX);
9244
9245         int rowContentWidth = internalTableWidth - overallRowContentMargin;
9246         wxSize rowTableSize(rowContentWidth, 0);
9247         wxTextAttrDimensionConverter converter(dc, scale, rowTableSize);
9248
9249         for (i = 0; i < m_colCount; i++)
9250         {
9251             wxRichTextBox* cell = GetCell(j, i);
9252             if (cell->IsShown())
9253             {
9254                 int colSpan = 1;
9255                 if (cell->GetProperties().HasProperty(wxT("colspan")))
9256                     colSpan = cell->GetProperties().GetPropertyLong(wxT("colspan"));
9257
9258                 if (colSpan > 1)
9259                 {
9260                     int spans = wxMin(colSpan, m_colCount - i);
9261                     int cellWidth = 0;
9262                     if (spans > 0)
9263                     {
9264                         if (cell->GetAttributes().GetTextBoxAttr().GetWidth().IsValid())
9265                         {
9266                             cellWidth = converter.GetPixels(cell->GetAttributes().GetTextBoxAttr().GetWidth());
9267                             // Override absolute width with minimum width if necessary
9268                             if (cell->GetMinSize().x > 0 && cellWidth !=1 && cell->GetMinSize().x > cellWidth)
9269                                 cellWidth = cell->GetMinSize().x;
9270                         }
9271                         else
9272                         {
9273                             // Do we want to do this? It's the only chance we get to
9274                             // use the cell's min/max sizes, so we need to work out
9275                             // how we're going to balance the unspecified spanning cell
9276                             // width with the possibility more-constrained constituent cell widths.
9277                             // Say there's a tiny bitmap giving it a max width of 10 pixels. We
9278                             // don't want to constraint all the spanned columns to fit into this cell.
9279                             // OK, let's say that if any of the constituent columns don't fit,
9280                             // then we simply stop constraining the columns; instead, we'll just fit the spanning
9281                             // cells to the columns later.
9282                             cellWidth = cell->GetMinSize().x;
9283                             if (cell->GetMaxSize().x > cellWidth)
9284                                 cellWidth = cell->GetMaxSize().x;
9285                         }
9286
9287                         // Subtract the padding between cells
9288                         int spanningWidth = cellWidth;
9289                         spanningWidth -= paddingX * (spans-1);
9290
9291                         if (spanningWidth > 0)
9292                         {
9293                             // Now share the spanning width between columns within that span
9294                             // TODO: take into account min widths of columns within the span
9295                             int spanningWidthLeft = spanningWidth;
9296                             int stretchColCount = 0;
9297                             for (k = i; k < (i+spans); k++)
9298                             {
9299                                 if (colWidths[k] > 0) // absolute or proportional width has been specified
9300                                     spanningWidthLeft -= colWidths[k];
9301                                 else
9302                                     stretchColCount ++;
9303                             }
9304                             // Now divide what's left between the remaining columns
9305                             int colShare = 0;
9306                             if (stretchColCount > 0)
9307                                 colShare = spanningWidthLeft / stretchColCount;
9308                             int colShareRemainder = spanningWidthLeft - (colShare * stretchColCount);
9309
9310                             // If fixed-width columns are currently too big, then we'll later
9311                             // stretch the spanned cell to fit.
9312
9313                             if (spanningWidthLeft > 0)
9314                             {
9315                                 for (k = i; k < (i+spans); k++)
9316                                 {
9317                                     if (colWidths[k] <= 0) // absolute or proportional width has not been specified
9318                                     {
9319                                         int newWidth = colShare;
9320                                         if (k == (i+spans-1))
9321                                             newWidth += colShareRemainder; // ensure all pixels are filled
9322                                         colWidths[k] = newWidth;
9323                                     }
9324                                 }
9325                             }
9326                         }
9327                     }
9328                 }
9329             }
9330         }
9331     }
9332
9333     // (4) Next, share any remaining space out between columns that have not yet been calculated.
9334     // TODO: take into account min widths of columns within the span
9335     int tableWidthMinusPadding = internalTableWidth - (m_colCount-1)*paddingX;
9336     int widthLeft = tableWidthMinusPadding;
9337     int stretchColCount = 0;
9338     for (i = 0; i < m_colCount; i++)
9339     {
9340         // TODO: we need to take into account min widths.
9341         // Subtract min width from width left, then
9342         // add the colShare to the min width
9343         if (colWidths[i] > 0) // absolute or proportional width has been specified
9344             widthLeft -= colWidths[i];
9345         else
9346         {
9347             if (minColWidths[i] > 0)
9348                 widthLeft -= minColWidths[i];
9349
9350             stretchColCount ++;
9351         }
9352     }
9353
9354     // Now divide what's left between the remaining columns
9355     int colShare = 0;
9356     if (stretchColCount > 0)
9357         colShare = widthLeft / stretchColCount;
9358     int colShareRemainder = widthLeft - (colShare * stretchColCount);
9359
9360     // Check we don't have enough space, in which case shrink all columns, overriding
9361     // any absolute/proportional widths
9362     // TODO: actually we would like to divide up the shrinkage according to size.
9363     // How do we calculate the proportions that will achieve this?
9364     // Could first choose an arbitrary value for stretching cells, and then calculate
9365     // factors to multiply each width by.
9366     // TODO: want to record this fact and pass to an iteration that tries e.g. min widths
9367     if (widthLeft < 0 || (stretchToFitTableWidth && (stretchColCount == 0)))
9368     {
9369         colShare = tableWidthMinusPadding / m_colCount;
9370         colShareRemainder = tableWidthMinusPadding - (colShare * m_colCount);
9371         for (i = 0; i < m_colCount; i++)
9372         {
9373             colWidths[i] = 0;
9374             minColWidths[i] = 0;
9375         }
9376     }
9377
9378     // We have to adjust the columns if either we need to shrink the
9379     // table to fit the parent/table width, or we explicitly set the
9380     // table width and need to stretch out the table.
9381     if (widthLeft < 0 || stretchToFitTableWidth)
9382     {
9383         for (i = 0; i < m_colCount; i++)
9384         {
9385             if (colWidths[i] <= 0) // absolute or proportional width has not been specified
9386             {
9387                 if (minColWidths[i] > 0)
9388                     colWidths[i] = minColWidths[i] + colShare;
9389                 else
9390                     colWidths[i] = colShare;
9391                 if (i == (m_colCount-1))
9392                     colWidths[i] += colShareRemainder; // ensure all pixels are filled
9393             }
9394         }
9395     }
9396
9397     // TODO: if spanned cells have no specified or max width, make them the
9398     // as big as the columns they span. Do this for all spanned cells in all
9399     // rows, of course. Size any spanned cells left over at the end - even if they
9400     // have width > 0, make sure they're limited to the appropriate column edge.
9401
9402
9403 /*
9404     Sort out confusion between content width
9405     and overall width later. For now, assume we specify overall width.
9406
9407     So, now we've laid out the table to fit into the given space
9408     and have used specified widths and minimum widths.
9409
9410     Now we need to consider how we will try to take maximum width into account.
9411
9412 */
9413
9414     // (??) TODO: take max width into account
9415
9416     // (6) Lay out all cells again with the current values
9417
9418     int maxRight = 0;
9419     int y = availableSpace.y;
9420     for (j = 0; j < m_rowCount; j++)
9421     {
9422         int x = availableSpace.x; // TODO: take into account centering etc.
9423         int maxCellHeight = 0;
9424         int maxSpecifiedCellHeight = 0;
9425
9426         wxArrayInt actualWidths;
9427         actualWidths.Add(0, m_colCount);
9428
9429         wxTextAttrDimensionConverter converter(dc, scale);
9430         for (i = 0; i < m_colCount; i++)
9431         {
9432             wxRichTextCell* cell = GetCell(j, i);
9433             if (cell->IsShown())
9434             {
9435                 // Get max specified cell height
9436                 // Don't handle percentages for height
9437                 if (cell->GetAttributes().GetTextBoxAttr().GetHeight().IsValid() && cell->GetAttributes().GetTextBoxAttr().GetHeight().GetUnits() != wxTEXT_ATTR_UNITS_PERCENTAGE)
9438                 {
9439                     int h = converter.GetPixels(cell->GetAttributes().GetTextBoxAttr().GetHeight());
9440                     if (h > maxSpecifiedCellHeight)
9441                         maxSpecifiedCellHeight = h;
9442                 }
9443
9444                 if (colWidths[i] > 0) // absolute or proportional width has been specified
9445                 {
9446                     int colSpan = 1;
9447                     if (cell->GetProperties().HasProperty(wxT("colspan")))
9448                         colSpan = cell->GetProperties().GetPropertyLong(wxT("colspan"));
9449
9450                     wxRect availableCellSpace;
9451
9452                     // TODO: take into acount spans
9453                     if (colSpan > 1)
9454                     {
9455                         // Calculate the size of this spanning cell from its constituent columns
9456                         int xx = x;
9457                         int spans = wxMin(colSpan, m_colCount - i);
9458                         for (k = i; k < spans; k++)
9459                         {
9460                             if (k != i)
9461                                 xx += paddingX;
9462                             xx += colWidths[k];
9463                         }
9464                         availableCellSpace = wxRect(x, y, xx, -1);
9465                     }
9466                     else
9467                         availableCellSpace = wxRect(x, y, colWidths[i], -1);
9468
9469                     // Store actual width so we can force cell to be the appropriate width on the final loop
9470                     actualWidths[i] = availableCellSpace.GetWidth();
9471
9472                     // Lay out cell
9473                     cell->Invalidate(wxRICHTEXT_ALL);
9474                     cell->Layout(dc, context, availableCellSpace, availableSpace, style);
9475
9476                     // TODO: use GetCachedSize().x to compute 'natural' size
9477
9478                     x += (availableCellSpace.GetWidth() + paddingX);
9479                     if (cell->GetCachedSize().y > maxCellHeight)
9480                         maxCellHeight = cell->GetCachedSize().y;
9481                 }
9482             }
9483         }
9484
9485         maxCellHeight = wxMax(maxCellHeight, maxSpecifiedCellHeight);
9486
9487         for (i = 0; i < m_colCount; i++)
9488         {
9489             wxRichTextCell* cell = GetCell(j, i);
9490             if (cell->IsShown())
9491             {
9492                 wxRect availableCellSpace = wxRect(cell->GetPosition(), wxSize(actualWidths[i], maxCellHeight));
9493                 // Lay out cell with new height
9494                 cell->Invalidate(wxRICHTEXT_ALL);
9495                 cell->Layout(dc, context, availableCellSpace, availableSpace, style);
9496
9497                 // Make sure the cell size really is the appropriate size,
9498                 // not the calculated box size
9499                 cell->SetCachedSize(wxSize(actualWidths[i], maxCellHeight));
9500
9501                 maxRight = wxMax(maxRight, cell->GetPosition().x + cell->GetCachedSize().x);
9502             }
9503         }
9504
9505         y += maxCellHeight;
9506         if (j < (m_rowCount-1))
9507             y += paddingY;
9508     }
9509
9510     // We need to add back the margins etc.
9511     {
9512         wxRect marginRect, borderRect, contentRect, paddingRect, outlineRect;
9513         contentRect = wxRect(wxPoint(0, 0), wxSize(maxRight - availableSpace.x, y - availableSpace.y));
9514         GetBoxRects(dc, GetBuffer(), attr, marginRect, borderRect, contentRect, paddingRect, outlineRect);
9515         SetCachedSize(marginRect.GetSize());
9516     }
9517
9518     // TODO: calculate max size
9519     {
9520         SetMaxSize(GetCachedSize());
9521     }
9522
9523     // TODO: calculate min size
9524     {
9525         SetMinSize(GetCachedSize());
9526     }
9527
9528     // TODO: currently we use either a fixed table width or the parent's size.
9529     // We also want to be able to calculate the table width from its content,
9530     // whether using fixed column widths or cell content min/max width.
9531     // Probably need a boolean flag to say whether we need to stretch cells
9532     // to fit the table width, or to simply use min/max cell widths. The
9533     // trouble with this is that if cell widths are not specified, they
9534     // will be tiny; we could use arbitrary defaults but this seems unsatisfactory.
9535     // Anyway, ignoring that problem, we probably need to factor layout into a function
9536     // that can can calculate the maximum unconstrained layout in case table size is
9537     // not specified. Then LayoutToBestSize() can choose to use either parent size to
9538     // constrain Layout(), or the previously-calculated max size to constraint layout.
9539
9540     return true;
9541 }
9542
9543 // Finds the absolute position and row height for the given character position
9544 bool wxRichTextTable::FindPosition(wxDC& dc, wxRichTextDrawingContext& context, long index, wxPoint& pt, int* height, bool forceLineStart)
9545 {
9546     wxRichTextCell* child = GetCell(index+1);
9547     if (child)
9548     {
9549         // Find the position at the start of the child cell, since the table doesn't
9550         // have any caret position of its own.
9551         return child->FindPosition(dc, context, -1, pt, height, forceLineStart);
9552     }
9553     else
9554         return false;
9555 }
9556
9557 // Get the cell at the given character position (in the range of the table).
9558 wxRichTextCell* wxRichTextTable::GetCell(long pos) const
9559 {
9560     int row = 0, col = 0;
9561     if (GetCellRowColumnPosition(pos, row, col))
9562     {
9563         return GetCell(row, col);
9564     }
9565     else
9566         return NULL;
9567 }
9568
9569 // Get the row/column for a given character position
9570 bool wxRichTextTable::GetCellRowColumnPosition(long pos, int& row, int& col) const
9571 {
9572     if (m_colCount == 0 || m_rowCount == 0)
9573         return false;
9574
9575     row = (int) (pos / m_colCount);
9576     col = pos - (row * m_colCount);
9577
9578     wxASSERT(row < m_rowCount && col < m_colCount);
9579
9580     if (row < m_rowCount && col < m_colCount)
9581         return true;
9582     else
9583         return false;
9584 }
9585
9586 // Calculate range, taking row/cell ordering into account instead of relying
9587 // on list ordering.
9588 void wxRichTextTable::CalculateRange(long start, long& end)
9589 {
9590     long current = start;
9591     long lastEnd = current;
9592
9593     if (IsTopLevel())
9594     {
9595         current = 0;
9596         lastEnd = 0;
9597     }
9598
9599     int i, j;
9600     for (i = 0; i < m_rowCount; i++)
9601     {
9602         for (j = 0; j < m_colCount; j++)
9603         {
9604             wxRichTextCell* child = GetCell(i, j);
9605             if (child)
9606             {
9607                 long childEnd = 0;
9608
9609                 child->CalculateRange(current, childEnd);
9610
9611                 lastEnd = childEnd;
9612                 current = childEnd + 1;
9613             }
9614         }
9615     }
9616
9617     // A top-level object always has a range of size 1,
9618     // because its children don't count at this level.
9619     end = start;
9620     m_range.SetRange(start, start);
9621
9622     // An object with no children has zero length
9623     if (m_children.GetCount() == 0)
9624         lastEnd --;
9625     m_ownRange.SetRange(0, lastEnd);
9626 }
9627
9628 // Gets the range size.
9629 bool wxRichTextTable::GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int flags, wxPoint position, wxArrayInt* partialExtents) const
9630 {
9631     return wxRichTextBox::GetRangeSize(range, size, descent, dc, context, flags, position, partialExtents);
9632 }
9633
9634 // Deletes content in the given range.
9635 bool wxRichTextTable::DeleteRange(const wxRichTextRange& WXUNUSED(range))
9636 {
9637     // TODO: implement deletion of cells
9638     return true;
9639 }
9640
9641 // Gets any text in this object for the given range.
9642 wxString wxRichTextTable::GetTextForRange(const wxRichTextRange& range) const
9643 {
9644     return wxRichTextBox::GetTextForRange(range);
9645 }
9646
9647 // Copies this object.
9648 void wxRichTextTable::Copy(const wxRichTextTable& obj)
9649 {
9650     wxRichTextBox::Copy(obj);
9651
9652     ClearTable();
9653
9654     m_rowCount = obj.m_rowCount;
9655     m_colCount = obj.m_colCount;
9656
9657     m_cells.Add(wxRichTextObjectPtrArray(), m_rowCount);
9658
9659     int i, j;
9660     for (i = 0; i < m_rowCount; i++)
9661     {
9662         wxRichTextObjectPtrArray& colArray = m_cells[i];
9663         for (j = 0; j < m_colCount; j++)
9664         {
9665             wxRichTextCell* cell = wxDynamicCast(obj.GetCell(i, j)->Clone(), wxRichTextCell);
9666             AppendChild(cell);
9667
9668             colArray.Add(cell);
9669         }
9670     }
9671 }
9672
9673 void wxRichTextTable::ClearTable()
9674 {
9675     m_cells.Clear();
9676     DeleteChildren();
9677 }
9678
9679 bool wxRichTextTable::CreateTable(int rows, int cols)
9680 {
9681     ClearTable();
9682
9683     m_rowCount = rows;
9684     m_colCount = cols;
9685
9686     m_cells.Add(wxRichTextObjectPtrArray(), rows);
9687
9688     int i, j;
9689     for (i = 0; i < rows; i++)
9690     {
9691         wxRichTextObjectPtrArray& colArray = m_cells[i];
9692         for (j = 0; j < cols; j++)
9693         {
9694             wxRichTextCell* cell = new wxRichTextCell;
9695             AppendChild(cell);
9696             cell->AddParagraph(wxEmptyString);
9697
9698             colArray.Add(cell);
9699         }
9700     }
9701
9702     return true;
9703 }
9704
9705 wxRichTextCell* wxRichTextTable::GetCell(int row, int col) const
9706 {
9707     wxASSERT(row < m_rowCount);
9708     wxASSERT(col < m_colCount);
9709
9710     if (row < m_rowCount && col < m_colCount)
9711     {
9712         wxRichTextObjectPtrArray& colArray = m_cells[row];
9713         wxRichTextObject* obj = colArray[col];
9714         return wxDynamicCast(obj, wxRichTextCell);
9715     }
9716     else
9717         return NULL;
9718 }
9719
9720 // Returns a selection object specifying the selections between start and end character positions.
9721 // For example, a table would deduce what cells (of range length 1) are selected when dragging across the table.
9722 wxRichTextSelection wxRichTextTable::GetSelection(long start, long end) const
9723 {
9724     wxRichTextSelection selection;
9725     selection.SetContainer((wxRichTextTable*) this);
9726
9727     if (start > end)
9728     {
9729         long tmp = end;
9730         end = start;
9731         start = tmp;
9732     }
9733
9734     wxASSERT( start >= 0 && end < (m_colCount * m_rowCount));
9735
9736     if (end >= (m_colCount * m_rowCount))
9737         return selection;
9738
9739     // We need to find the rectangle of cells that is described by the rectangle
9740     // with start, end as the diagonal. Make sure we don't add cells that are
9741     // not currenty visible because they are overlapped by spanning cells.
9742 /*
9743     --------------------------
9744     | 0  | 1  | 2  | 3  | 4  |
9745     --------------------------
9746     | 5  | 6  | 7  | 8  | 9  |
9747     --------------------------
9748     | 10 | 11 | 12 | 13 | 14 |
9749     --------------------------
9750     | 15 | 16 | 17 | 18 | 19 |
9751     --------------------------
9752
9753     Let's say we select 6 -> 18.
9754
9755     Left and right edge cols of rectangle are 1 and 3 inclusive. Find least/greatest to find
9756     which is left and which is right.
9757
9758     Top and bottom edge rows are 1 and 3 inclusive. Again, find least/greatest to find top and bottom.
9759
9760     Now go through rows from 1 to 3 and only add cells that are (a) within above column range
9761     and (b) shown.
9762
9763
9764 */
9765
9766     int leftCol = start - m_colCount * int(start/m_colCount);
9767     int rightCol = end - m_colCount * int(end/m_colCount);
9768
9769     int topRow = int(start/m_colCount);
9770     int bottomRow = int(end/m_colCount);
9771
9772     if (leftCol > rightCol)
9773     {
9774         int tmp = rightCol;
9775         rightCol = leftCol;
9776         leftCol = tmp;
9777     }
9778
9779     if (topRow > bottomRow)
9780     {
9781         int tmp = bottomRow;
9782         bottomRow = topRow;
9783         topRow = tmp;
9784     }
9785
9786     int i, j;
9787     for (i = topRow; i <= bottomRow; i++)
9788     {
9789         for (j = leftCol; j <= rightCol; j++)
9790         {
9791             wxRichTextCell* cell = GetCell(i, j);
9792             if (cell && cell->IsShown())
9793                 selection.Add(cell->GetRange());
9794         }
9795     }
9796
9797     return selection;
9798 }
9799
9800 // Sets the attributes for the cells specified by the selection.
9801 bool wxRichTextTable::SetCellStyle(const wxRichTextSelection& selection, const wxRichTextAttr& style, int flags)
9802 {
9803     if (selection.GetContainer() != this)
9804         return false;
9805
9806     wxRichTextBuffer* buffer = GetBuffer();
9807     bool haveControl = (buffer && buffer->GetRichTextCtrl() != NULL);
9808     bool withUndo = haveControl && ((flags & wxRICHTEXT_SETSTYLE_WITH_UNDO) != 0);
9809
9810     if (withUndo)
9811         buffer->BeginBatchUndo(_("Set Cell Style"));
9812
9813     wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
9814     while (node)
9815     {
9816         wxRichTextCell* cell = wxDynamicCast(node->GetData(), wxRichTextCell);
9817         if (cell && selection.WithinSelection(cell->GetRange().GetStart()))
9818             SetStyle(cell, style, flags);
9819         node = node->GetNext();
9820     }
9821
9822     // Do action, or delay it until end of batch.
9823     if (withUndo)
9824         buffer->EndBatchUndo();
9825
9826     return true;
9827 }
9828
9829 bool wxRichTextTable::DeleteRows(int startRow, int noRows)
9830 {
9831     wxASSERT((startRow + noRows) < m_rowCount);
9832     if ((startRow + noRows) >= m_rowCount)
9833         return false;
9834
9835     int i, j;
9836     for (i = startRow; i < (startRow+noRows); i++)
9837     {
9838         wxRichTextObjectPtrArray& colArray = m_cells[startRow];
9839         for (j = 0; j < (int) colArray.GetCount(); j++)
9840         {
9841             wxRichTextObject* cell = colArray[j];
9842             RemoveChild(cell, true);
9843         }
9844
9845         // Keep deleting at the same position, since we move all
9846         // the others up
9847         m_cells.RemoveAt(startRow);
9848     }
9849
9850     m_rowCount = m_rowCount - noRows;
9851
9852     return true;
9853 }
9854
9855 bool wxRichTextTable::DeleteColumns(int startCol, int noCols)
9856 {
9857     wxASSERT((startCol + noCols) < m_colCount);
9858     if ((startCol + noCols) >= m_colCount)
9859         return false;
9860
9861     bool deleteRows = (noCols == m_colCount);
9862
9863     int i, j;
9864     for (i = 0; i < m_rowCount; i++)
9865     {
9866         wxRichTextObjectPtrArray& colArray = m_cells[deleteRows ? 0 : i];
9867         for (j = startCol; j < (startCol+noCols); j++)
9868         {
9869             wxRichTextObject* cell = colArray[j];
9870             RemoveChild(cell, true);
9871         }
9872
9873         if (deleteRows)
9874             m_cells.RemoveAt(0);
9875     }
9876
9877     if (deleteRows)
9878         m_rowCount = 0;
9879     m_colCount = m_colCount - noCols;
9880
9881     return true;
9882 }
9883
9884 bool wxRichTextTable::AddRows(int startRow, int noRows, const wxRichTextAttr& attr)
9885 {
9886     wxASSERT(startRow <= m_rowCount);
9887     if (startRow > m_rowCount)
9888         return false;
9889
9890     int i, j;
9891     for (i = 0; i < noRows; i++)
9892     {
9893         int idx;
9894         if (startRow == m_rowCount)
9895         {
9896             m_cells.Add(wxRichTextObjectPtrArray());
9897             idx = m_cells.GetCount() - 1;
9898         }
9899         else
9900         {
9901             m_cells.Insert(wxRichTextObjectPtrArray(), startRow+i);
9902             idx = startRow+i;
9903         }
9904
9905         wxRichTextObjectPtrArray& colArray = m_cells[idx];
9906         for (j = 0; j < m_colCount; j++)
9907         {
9908             wxRichTextCell* cell = new wxRichTextCell;
9909             cell->GetAttributes() = attr;
9910
9911             AppendChild(cell);
9912             colArray.Add(cell);
9913         }
9914     }
9915
9916     m_rowCount = m_rowCount + noRows;
9917     return true;
9918 }
9919
9920 bool wxRichTextTable::AddColumns(int startCol, int noCols, const wxRichTextAttr& attr)
9921 {
9922     wxASSERT(startCol <= m_colCount);
9923     if (startCol > m_colCount)
9924         return false;
9925
9926     int i, j;
9927     for (i = 0; i < m_rowCount; i++)
9928     {
9929         wxRichTextObjectPtrArray& colArray = m_cells[i];
9930         for (j = 0; j < noCols; j++)
9931         {
9932             wxRichTextCell* cell = new wxRichTextCell;
9933             cell->GetAttributes() = attr;
9934
9935             AppendChild(cell);
9936
9937             if (startCol == m_colCount)
9938                 colArray.Add(cell);
9939             else
9940                 colArray.Insert(cell, startCol+j);
9941         }
9942     }
9943
9944     m_colCount = m_colCount + noCols;
9945
9946     return true;
9947 }
9948
9949 // Edit properties via a GUI
9950 bool wxRichTextTable::EditProperties(wxWindow* parent, wxRichTextBuffer* buffer)
9951 {
9952     wxRichTextObjectPropertiesDialog boxDlg(this, wxGetTopLevelParent(parent), wxID_ANY, _("Table Properties"));
9953     boxDlg.SetAttributes(GetAttributes());
9954
9955     if (boxDlg.ShowModal() == wxID_OK)
9956     {
9957         boxDlg.ApplyStyle(buffer->GetRichTextCtrl(), wxRICHTEXT_SETSTYLE_WITH_UNDO|wxRICHTEXT_SETSTYLE_RESET);
9958         return true;
9959     }
9960     else
9961         return false;
9962 }
9963
9964 /*
9965  * Module to initialise and clean up handlers
9966  */
9967
9968 class wxRichTextModule: public wxModule
9969 {
9970 DECLARE_DYNAMIC_CLASS(wxRichTextModule)
9971 public:
9972     wxRichTextModule() {}
9973     bool OnInit()
9974     {
9975         wxRichTextBuffer::SetRenderer(new wxRichTextStdRenderer);
9976         wxRichTextBuffer::InitStandardHandlers();
9977         wxRichTextParagraph::InitDefaultTabs();
9978
9979         wxRichTextXMLHandler::RegisterNodeName(wxT("text"), wxT("wxRichTextPlainText"));
9980         wxRichTextXMLHandler::RegisterNodeName(wxT("symbol"), wxT("wxRichTextPlainText"));
9981         wxRichTextXMLHandler::RegisterNodeName(wxT("image"), wxT("wxRichTextImage"));
9982         wxRichTextXMLHandler::RegisterNodeName(wxT("paragraph"), wxT("wxRichTextParagraph"));
9983         wxRichTextXMLHandler::RegisterNodeName(wxT("paragraphlayout"), wxT("wxRichTextParagraphLayoutBox"));
9984         wxRichTextXMLHandler::RegisterNodeName(wxT("textbox"), wxT("wxRichTextBox"));
9985         wxRichTextXMLHandler::RegisterNodeName(wxT("cell"), wxT("wxRichTextCell"));
9986         wxRichTextXMLHandler::RegisterNodeName(wxT("table"), wxT("wxRichTextTable"));
9987         wxRichTextXMLHandler::RegisterNodeName(wxT("field"), wxT("wxRichTextField"));
9988
9989         return true;
9990     }
9991     void OnExit()
9992     {
9993         wxRichTextBuffer::CleanUpHandlers();
9994         wxRichTextBuffer::CleanUpDrawingHandlers();
9995         wxRichTextBuffer::CleanUpFieldTypes();
9996         wxRichTextXMLHandler::ClearNodeToClassMap();
9997         wxRichTextDecimalToRoman(-1);
9998         wxRichTextParagraph::ClearDefaultTabs();
9999         wxRichTextCtrl::ClearAvailableFontNames();
10000         wxRichTextBuffer::SetRenderer(NULL);
10001     }
10002 };
10003
10004 IMPLEMENT_DYNAMIC_CLASS(wxRichTextModule, wxModule)
10005
10006
10007 // If the richtext lib is dynamically loaded after the app has already started
10008 // (such as from wxPython) then the built-in module system will not init this
10009 // module.  Provide this function to do it manually.
10010 void wxRichTextModuleInit()
10011 {
10012     wxModule* module = new wxRichTextModule;
10013     module->Init();
10014     wxModule::RegisterModule(module);
10015 }
10016
10017
10018 /*!
10019  * Commands for undo/redo
10020  *
10021  */
10022
10023 wxRichTextCommand::wxRichTextCommand(const wxString& name, wxRichTextCommandId id, wxRichTextBuffer* buffer,
10024                                      wxRichTextParagraphLayoutBox* container, wxRichTextCtrl* ctrl, bool ignoreFirstTime): wxCommand(true, name)
10025 {
10026     /* wxRichTextAction* action = */ new wxRichTextAction(this, name, id, buffer, container, ctrl, ignoreFirstTime);
10027 }
10028
10029 wxRichTextCommand::wxRichTextCommand(const wxString& name): wxCommand(true, name)
10030 {
10031 }
10032
10033 wxRichTextCommand::~wxRichTextCommand()
10034 {
10035     ClearActions();
10036 }
10037
10038 void wxRichTextCommand::AddAction(wxRichTextAction* action)
10039 {
10040     if (!m_actions.Member(action))
10041         m_actions.Append(action);
10042 }
10043
10044 bool wxRichTextCommand::Do()
10045 {
10046     for (wxList::compatibility_iterator node = m_actions.GetFirst(); node; node = node->GetNext())
10047     {
10048         wxRichTextAction* action = (wxRichTextAction*) node->GetData();
10049         action->Do();
10050     }
10051
10052     return true;
10053 }
10054
10055 bool wxRichTextCommand::Undo()
10056 {
10057     for (wxList::compatibility_iterator node = m_actions.GetLast(); node; node = node->GetPrevious())
10058     {
10059         wxRichTextAction* action = (wxRichTextAction*) node->GetData();
10060         action->Undo();
10061     }
10062
10063     return true;
10064 }
10065
10066 void wxRichTextCommand::ClearActions()
10067 {
10068     WX_CLEAR_LIST(wxList, m_actions);
10069 }
10070
10071 /*!
10072  * Individual action
10073  *
10074  */
10075
10076 wxRichTextAction::wxRichTextAction(wxRichTextCommand* cmd, const wxString& name, wxRichTextCommandId id,
10077                                    wxRichTextBuffer* buffer, wxRichTextParagraphLayoutBox* container,
10078                                    wxRichTextCtrl* ctrl, bool ignoreFirstTime)
10079 {
10080     m_buffer = buffer;
10081     m_object = NULL;
10082     m_containerAddress.Create(buffer, container);
10083     m_ignoreThis = ignoreFirstTime;
10084     m_cmdId = id;
10085     m_position = -1;
10086     m_ctrl = ctrl;
10087     m_name = name;
10088     m_newParagraphs.SetDefaultStyle(buffer->GetDefaultStyle());
10089     m_newParagraphs.SetBasicStyle(buffer->GetBasicStyle());
10090     if (cmd)
10091         cmd->AddAction(this);
10092 }
10093
10094 wxRichTextAction::~wxRichTextAction()
10095 {
10096     if (m_object)
10097         delete m_object;
10098 }
10099
10100 // Returns the container that this action refers to, using the container address and top-level buffer.
10101 wxRichTextParagraphLayoutBox* wxRichTextAction::GetContainer() const
10102 {
10103     wxRichTextParagraphLayoutBox* container = wxDynamicCast(GetContainerAddress().GetObject(m_buffer), wxRichTextParagraphLayoutBox);
10104     return container;
10105 }
10106
10107
10108 void wxRichTextAction::CalculateRefreshOptimizations(wxArrayInt& optimizationLineCharPositions, wxArrayInt& optimizationLineYPositions)
10109 {
10110     // Store a list of line start character and y positions so we can figure out which area
10111     // we need to refresh
10112
10113 #if wxRICHTEXT_USE_OPTIMIZED_DRAWING
10114     wxRichTextParagraphLayoutBox* container = GetContainer();
10115     wxASSERT(container != NULL);
10116     if (!container)
10117         return;
10118
10119     // NOTE: we're assuming that the buffer is laid out correctly at this point.
10120     // If we had several actions, which only invalidate and leave layout until the
10121     // paint handler is called, then this might not be true. So we may need to switch
10122     // optimisation on only when we're simply adding text and not simultaneously
10123     // deleting a selection, for example. Or, we make sure the buffer is laid out correctly
10124     // first, but of course this means we'll be doing it twice.
10125     if (!m_buffer->IsDirty() && m_ctrl) // can only do optimisation if the buffer is already laid out correctly
10126     {
10127         wxSize clientSize = m_ctrl->GetUnscaledSize(m_ctrl->GetClientSize());
10128         wxPoint firstVisiblePt = m_ctrl->GetUnscaledPoint(m_ctrl->GetFirstVisiblePoint());
10129         int lastY = firstVisiblePt.y + clientSize.y;
10130
10131         wxRichTextParagraph* para = container->GetParagraphAtPosition(GetRange().GetStart());
10132         wxRichTextObjectList::compatibility_iterator node = container->GetChildren().Find(para);
10133         while (node)
10134         {
10135             wxRichTextParagraph* child = (wxRichTextParagraph*) node->GetData();
10136             wxRichTextLineList::compatibility_iterator node2 = child->GetLines().GetFirst();
10137             while (node2)
10138             {
10139                 wxRichTextLine* line = node2->GetData();
10140                 wxPoint pt = line->GetAbsolutePosition();
10141                 wxRichTextRange range = line->GetAbsoluteRange();
10142
10143                 if (pt.y > lastY)
10144                 {
10145                     node2 = wxRichTextLineList::compatibility_iterator();
10146                     node = wxRichTextObjectList::compatibility_iterator();
10147                 }
10148                 else if (range.GetStart() > GetPosition() && pt.y >= firstVisiblePt.y)
10149                 {
10150                     optimizationLineCharPositions.Add(range.GetStart());
10151                     optimizationLineYPositions.Add(pt.y);
10152                 }
10153
10154                 if (node2)
10155                     node2 = node2->GetNext();
10156             }
10157
10158             if (node)
10159                 node = node->GetNext();
10160         }
10161     }
10162 #endif
10163 }
10164
10165 bool wxRichTextAction::Do()
10166 {
10167     m_buffer->Modify(true);
10168
10169     wxRichTextParagraphLayoutBox* container = GetContainer();
10170     wxASSERT(container != NULL);
10171     if (!container)
10172         return false;
10173
10174     switch (m_cmdId)
10175     {
10176     case wxRICHTEXT_INSERT:
10177         {
10178             // Store a list of line start character and y positions so we can figure out which area
10179             // we need to refresh
10180             wxArrayInt optimizationLineCharPositions;
10181             wxArrayInt optimizationLineYPositions;
10182
10183 #if wxRICHTEXT_USE_OPTIMIZED_DRAWING
10184             CalculateRefreshOptimizations(optimizationLineCharPositions, optimizationLineYPositions);
10185 #endif
10186
10187             container->InsertFragment(GetRange().GetStart(), m_newParagraphs);
10188             container->UpdateRanges();
10189
10190             // InvalidateHierarchy goes up the hierarchy as well as down, otherwise with a nested object,
10191             // Layout() would stop prematurely at the top level.
10192             container->InvalidateHierarchy(wxRichTextRange(wxMax(0, GetRange().GetStart()-1), GetRange().GetEnd()));
10193
10194             long newCaretPosition = GetPosition() + m_newParagraphs.GetOwnRange().GetLength();
10195
10196             // Character position to caret position
10197             newCaretPosition --;
10198
10199             // Don't take into account the last newline
10200             if (m_newParagraphs.GetPartialParagraph())
10201                 newCaretPosition --;
10202             else
10203                 if (m_newParagraphs.GetChildren().GetCount() > 1)
10204                 {
10205                     wxRichTextObject* p = (wxRichTextObject*) m_newParagraphs.GetChildren().GetLast()->GetData();
10206                     if (p->GetRange().GetLength() == 1)
10207                         newCaretPosition --;
10208                 }
10209
10210             newCaretPosition = wxMin(newCaretPosition, (container->GetOwnRange().GetEnd()-1));
10211
10212             UpdateAppearance(newCaretPosition, true /* send update event */, & optimizationLineCharPositions, & optimizationLineYPositions, true /* do */);
10213
10214             wxRichTextEvent cmdEvent(
10215                 wxEVT_COMMAND_RICHTEXT_CONTENT_INSERTED,
10216                 m_ctrl ? m_ctrl->GetId() : -1);
10217             cmdEvent.SetEventObject(m_ctrl ? (wxObject*) m_ctrl : (wxObject*) m_buffer);
10218             cmdEvent.SetRange(GetRange());
10219             cmdEvent.SetPosition(GetRange().GetStart());
10220             cmdEvent.SetContainer(container);
10221
10222             m_buffer->SendEvent(cmdEvent);
10223
10224             break;
10225         }
10226     case wxRICHTEXT_DELETE:
10227         {
10228             wxArrayInt optimizationLineCharPositions;
10229             wxArrayInt optimizationLineYPositions;
10230
10231 #if wxRICHTEXT_USE_OPTIMIZED_DRAWING
10232             CalculateRefreshOptimizations(optimizationLineCharPositions, optimizationLineYPositions);
10233 #endif
10234
10235             container->DeleteRange(GetRange());
10236             container->UpdateRanges();
10237             // InvalidateHierarchy goes up the hierarchy as well as down, otherwise with a nested object,
10238             // Layout() would stop prematurely at the top level.
10239             container->InvalidateHierarchy(wxRichTextRange(GetRange().GetStart(), GetRange().GetStart()));
10240
10241             long caretPos = GetRange().GetStart()-1;
10242             if (caretPos >= container->GetOwnRange().GetEnd())
10243                 caretPos --;
10244
10245             UpdateAppearance(caretPos, true /* send update event */, & optimizationLineCharPositions, & optimizationLineYPositions, true /* do */);
10246
10247             wxRichTextEvent cmdEvent(
10248                 wxEVT_COMMAND_RICHTEXT_CONTENT_DELETED,
10249                 m_ctrl ? m_ctrl->GetId() : -1);
10250             cmdEvent.SetEventObject(m_ctrl ? (wxObject*) m_ctrl : (wxObject*) m_buffer);
10251             cmdEvent.SetRange(GetRange());
10252             cmdEvent.SetPosition(GetRange().GetStart());
10253             cmdEvent.SetContainer(container);
10254
10255             m_buffer->SendEvent(cmdEvent);
10256
10257             break;
10258         }
10259     case wxRICHTEXT_CHANGE_STYLE:
10260     case wxRICHTEXT_CHANGE_PROPERTIES:
10261         {
10262             ApplyParagraphs(GetNewParagraphs());
10263
10264             // InvalidateHierarchy goes up the hierarchy as well as down, otherwise with a nested object,
10265             // Layout() would stop prematurely at the top level.
10266             container->InvalidateHierarchy(GetRange());
10267
10268             UpdateAppearance(GetPosition());
10269
10270             wxRichTextEvent cmdEvent(
10271                 m_cmdId == wxRICHTEXT_CHANGE_STYLE ? wxEVT_COMMAND_RICHTEXT_STYLE_CHANGED : wxEVT_COMMAND_RICHTEXT_PROPERTIES_CHANGED,
10272                 m_ctrl ? m_ctrl->GetId() : -1);
10273             cmdEvent.SetEventObject(m_ctrl ? (wxObject*) m_ctrl : (wxObject*) m_buffer);
10274             cmdEvent.SetRange(GetRange());
10275             cmdEvent.SetPosition(GetRange().GetStart());
10276             cmdEvent.SetContainer(container);
10277
10278             m_buffer->SendEvent(cmdEvent);
10279
10280             break;
10281         }
10282     case wxRICHTEXT_CHANGE_ATTRIBUTES:
10283         {
10284             wxRichTextObject* obj = m_objectAddress.GetObject(m_buffer); // container->GetChildAtPosition(GetRange().GetStart());
10285             if (obj)
10286             {
10287                 wxRichTextAttr oldAttr = obj->GetAttributes();
10288                 obj->GetAttributes() = m_attributes;
10289                 m_attributes = oldAttr;
10290             }
10291
10292             // InvalidateHierarchy goes up the hierarchy as well as down, otherwise with a nested object,
10293             // Layout() would stop prematurely at the top level.
10294             container->InvalidateHierarchy(GetRange());
10295
10296             UpdateAppearance(GetPosition());
10297
10298             wxRichTextEvent cmdEvent(
10299                 wxEVT_COMMAND_RICHTEXT_STYLE_CHANGED,
10300                 m_ctrl ? m_ctrl->GetId() : -1);
10301             cmdEvent.SetEventObject(m_ctrl ? (wxObject*) m_ctrl : (wxObject*) m_buffer);
10302             cmdEvent.SetRange(GetRange());
10303             cmdEvent.SetPosition(GetRange().GetStart());
10304             cmdEvent.SetContainer(container);
10305
10306             m_buffer->SendEvent(cmdEvent);
10307
10308             break;
10309         }
10310     case wxRICHTEXT_CHANGE_OBJECT:
10311         {
10312             wxRichTextObject* obj = m_objectAddress.GetObject(m_buffer);
10313             // wxRichTextObject* obj = container->GetChildAtPosition(GetRange().GetStart());
10314             if (obj && m_object)
10315             {
10316                 wxRichTextObjectList::compatibility_iterator node = container->GetChildren().Find(obj);
10317                 if (node)
10318                 {
10319                     wxRichTextObject* obj = node->GetData();
10320                     node->SetData(m_object);
10321                     m_object = obj;
10322                 }
10323             }
10324
10325             // InvalidateHierarchy goes up the hierarchy as well as down, otherwise with a nested object,
10326             // Layout() would stop prematurely at the top level.
10327             container->InvalidateHierarchy(GetRange());
10328
10329             UpdateAppearance(GetPosition());
10330
10331             // TODO: send new kind of modification event
10332
10333             break;
10334         }
10335     default:
10336         break;
10337     }
10338
10339     return true;
10340 }
10341
10342 bool wxRichTextAction::Undo()
10343 {
10344     m_buffer->Modify(true);
10345
10346     wxRichTextParagraphLayoutBox* container = GetContainer();
10347     wxASSERT(container != NULL);
10348     if (!container)
10349         return false;
10350
10351     switch (m_cmdId)
10352     {
10353     case wxRICHTEXT_INSERT:
10354         {
10355             wxArrayInt optimizationLineCharPositions;
10356             wxArrayInt optimizationLineYPositions;
10357
10358 #if wxRICHTEXT_USE_OPTIMIZED_DRAWING
10359             CalculateRefreshOptimizations(optimizationLineCharPositions, optimizationLineYPositions);
10360 #endif
10361
10362             container->DeleteRange(GetRange());
10363             container->UpdateRanges();
10364
10365             // InvalidateHierarchy goes up the hierarchy as well as down, otherwise with a nested object,
10366             // Layout() would stop prematurely at the top level.
10367             container->InvalidateHierarchy(wxRichTextRange(GetRange().GetStart(), GetRange().GetStart()));
10368
10369             long newCaretPosition = GetPosition() - 1;
10370
10371             UpdateAppearance(newCaretPosition, true, /* send update event */ & optimizationLineCharPositions, & optimizationLineYPositions, false /* undo */);
10372
10373             wxRichTextEvent cmdEvent(
10374                 wxEVT_COMMAND_RICHTEXT_CONTENT_DELETED,
10375                 m_ctrl ? m_ctrl->GetId() : -1);
10376             cmdEvent.SetEventObject(m_ctrl ? (wxObject*) m_ctrl : (wxObject*) m_buffer);
10377             cmdEvent.SetRange(GetRange());
10378             cmdEvent.SetPosition(GetRange().GetStart());
10379             cmdEvent.SetContainer(container);
10380
10381             m_buffer->SendEvent(cmdEvent);
10382
10383             break;
10384         }
10385     case wxRICHTEXT_DELETE:
10386         {
10387             wxArrayInt optimizationLineCharPositions;
10388             wxArrayInt optimizationLineYPositions;
10389
10390 #if wxRICHTEXT_USE_OPTIMIZED_DRAWING
10391             CalculateRefreshOptimizations(optimizationLineCharPositions, optimizationLineYPositions);
10392 #endif
10393
10394             container->InsertFragment(GetRange().GetStart(), m_oldParagraphs);
10395             container->UpdateRanges();
10396
10397             // InvalidateHierarchy goes up the hierarchy as well as down, otherwise with a nested object,
10398             // Layout() would stop prematurely at the top level.
10399             container->InvalidateHierarchy(GetRange());
10400
10401             UpdateAppearance(GetPosition(), true, /* send update event */ & optimizationLineCharPositions, & optimizationLineYPositions, false /* undo */);
10402
10403             wxRichTextEvent cmdEvent(
10404                 wxEVT_COMMAND_RICHTEXT_CONTENT_INSERTED,
10405                 m_ctrl ? m_ctrl->GetId() : -1);
10406             cmdEvent.SetEventObject(m_ctrl ? (wxObject*) m_ctrl : (wxObject*) m_buffer);
10407             cmdEvent.SetRange(GetRange());
10408             cmdEvent.SetPosition(GetRange().GetStart());
10409             cmdEvent.SetContainer(container);
10410
10411             m_buffer->SendEvent(cmdEvent);
10412
10413             break;
10414         }
10415     case wxRICHTEXT_CHANGE_STYLE:
10416     case wxRICHTEXT_CHANGE_PROPERTIES:
10417         {
10418             ApplyParagraphs(GetOldParagraphs());
10419             // InvalidateHierarchy goes up the hierarchy as well as down, otherwise with a nested object,
10420             // Layout() would stop prematurely at the top level.
10421             container->InvalidateHierarchy(GetRange());
10422
10423             UpdateAppearance(GetPosition());
10424
10425             wxRichTextEvent cmdEvent(
10426                 m_cmdId == wxRICHTEXT_CHANGE_STYLE ? wxEVT_COMMAND_RICHTEXT_STYLE_CHANGED : wxEVT_COMMAND_RICHTEXT_PROPERTIES_CHANGED,
10427                 m_ctrl ? m_ctrl->GetId() : -1);
10428             cmdEvent.SetEventObject(m_ctrl ? (wxObject*) m_ctrl : (wxObject*) m_buffer);
10429             cmdEvent.SetRange(GetRange());
10430             cmdEvent.SetPosition(GetRange().GetStart());
10431             cmdEvent.SetContainer(container);
10432
10433             m_buffer->SendEvent(cmdEvent);
10434
10435             break;
10436         }
10437     case wxRICHTEXT_CHANGE_ATTRIBUTES:
10438     case wxRICHTEXT_CHANGE_OBJECT:
10439         {
10440             return Do();
10441         }
10442     default:
10443         break;
10444     }
10445
10446     return true;
10447 }
10448
10449 /// Update the control appearance
10450 void wxRichTextAction::UpdateAppearance(long caretPosition, bool sendUpdateEvent, wxArrayInt* optimizationLineCharPositions, wxArrayInt* optimizationLineYPositions, bool isDoCmd)
10451 {
10452     wxRichTextParagraphLayoutBox* container = GetContainer();
10453     wxASSERT(container != NULL);
10454     if (!container)
10455         return;
10456
10457     if (m_ctrl)
10458     {
10459         m_ctrl->SetFocusObject(container);
10460         m_ctrl->SetCaretPosition(caretPosition);
10461
10462         if (!m_ctrl->IsFrozen())
10463         {
10464             wxRect containerRect = container->GetRect();
10465
10466             m_ctrl->LayoutContent();
10467
10468             // Refresh everything if there were floating objects or the container changed size
10469             // (we can't yet optimize in these cases, since more complex interaction with other content occurs)
10470             if (container->GetFloatingObjectCount() > 0 || (container->GetParent() && containerRect != container->GetRect()))
10471             {
10472                 m_ctrl->Refresh(false);
10473             }
10474             else
10475
10476 #if wxRICHTEXT_USE_OPTIMIZED_DRAWING
10477             // Find refresh rectangle if we are in a position to optimise refresh
10478             if ((m_cmdId == wxRICHTEXT_INSERT || m_cmdId == wxRICHTEXT_DELETE) && optimizationLineCharPositions)
10479             {
10480                 size_t i;
10481
10482                 wxSize clientSize = m_ctrl->GetUnscaledSize(m_ctrl->GetClientSize());
10483                 wxPoint firstVisiblePt = m_ctrl->GetUnscaledPoint(m_ctrl->GetFirstVisiblePoint());
10484
10485                 // Start/end positions
10486                 int firstY = 0;
10487                 int lastY = firstVisiblePt.y + clientSize.y;
10488
10489                 bool foundEnd = false;
10490
10491                 // position offset - how many characters were inserted
10492                 int positionOffset = GetRange().GetLength();
10493
10494                 // Determine whether this is Do or Undo, and adjust positionOffset accordingly
10495                 if ((m_cmdId == wxRICHTEXT_DELETE && isDoCmd) || (m_cmdId == wxRICHTEXT_INSERT && !isDoCmd))
10496                     positionOffset = - positionOffset;
10497
10498                 // find the first line which is being drawn at the same position as it was
10499                 // before. Since we're talking about a simple insertion, we can assume
10500                 // that the rest of the window does not need to be redrawn.
10501
10502                 wxRichTextParagraph* para = container->GetParagraphAtPosition(GetPosition());
10503                 // Since we support floating layout, we should redraw the whole para instead of just
10504                 // the first line touching the invalid range.
10505                 if (para)
10506                 {
10507                     firstY = para->GetPosition().y;
10508                 }
10509
10510                 wxRichTextObjectList::compatibility_iterator node = container->GetChildren().Find(para);
10511                 while (node)
10512                 {
10513                     wxRichTextParagraph* child = (wxRichTextParagraph*) node->GetData();
10514                     wxRichTextLineList::compatibility_iterator node2 = child->GetLines().GetFirst();
10515                     while (node2)
10516                     {
10517                         wxRichTextLine* line = node2->GetData();
10518                         wxPoint pt = line->GetAbsolutePosition();
10519                         wxRichTextRange range = line->GetAbsoluteRange();
10520
10521                         // we want to find the first line that is in the same position
10522                         // as before. This will mean we're at the end of the changed text.
10523
10524                         if (pt.y > lastY) // going past the end of the window, no more info
10525                         {
10526                             node2 = wxRichTextLineList::compatibility_iterator();
10527                             node = wxRichTextObjectList::compatibility_iterator();
10528                         }
10529                         // Detect last line in the buffer
10530                         else if (!node2->GetNext() && para->GetRange().Contains(container->GetOwnRange().GetEnd()))
10531                         {
10532                             // If deleting text, make sure we refresh below as well as above
10533                             if (positionOffset >= 0)
10534                             {
10535                                 foundEnd = true;
10536                                 lastY = pt.y + line->GetSize().y;
10537                             }
10538
10539                             node2 = wxRichTextLineList::compatibility_iterator();
10540                             node = wxRichTextObjectList::compatibility_iterator();
10541
10542                             break;
10543                         }
10544                         else
10545                         {
10546                             // search for this line being at the same position as before
10547                             for (i = 0; i < optimizationLineCharPositions->GetCount(); i++)
10548                             {
10549                                 if (((*optimizationLineCharPositions)[i] + positionOffset == range.GetStart()) &&
10550                                     ((*optimizationLineYPositions)[i] == pt.y))
10551                                 {
10552                                     // Stop, we're now the same as we were
10553                                     foundEnd = true;
10554
10555                                     lastY = pt.y;
10556
10557                                     node2 = wxRichTextLineList::compatibility_iterator();
10558                                     node = wxRichTextObjectList::compatibility_iterator();
10559
10560                                     break;
10561                                 }
10562                             }
10563                         }
10564
10565                         if (node2)
10566                             node2 = node2->GetNext();
10567                     }
10568
10569                     if (node)
10570                         node = node->GetNext();
10571                 }
10572
10573                 firstY = wxMax(firstVisiblePt.y, firstY);
10574                 if (!foundEnd)
10575                     lastY = firstVisiblePt.y + clientSize.y;
10576
10577                 // Convert to device coordinates
10578                 wxRect rect(m_ctrl->GetPhysicalPoint(m_ctrl->GetScaledPoint(wxPoint(firstVisiblePt.x, firstY))), m_ctrl->GetScaledSize(wxSize(clientSize.x, lastY - firstY)));
10579                 m_ctrl->RefreshRect(rect);
10580             }
10581             else
10582 #endif
10583                 m_ctrl->Refresh(false);
10584
10585             m_ctrl->PositionCaret();
10586
10587             // This causes styles to persist when doing programmatic
10588             // content creation except when Freeze/Thaw is used, so
10589             // disable this and check for the consequences.
10590             // m_ctrl->SetDefaultStyleToCursorStyle();
10591
10592             if (sendUpdateEvent)
10593                 wxTextCtrl::SendTextUpdatedEvent(m_ctrl);
10594         }
10595     }
10596 }
10597
10598 /// Replace the buffer paragraphs with the new ones.
10599 void wxRichTextAction::ApplyParagraphs(const wxRichTextParagraphLayoutBox& fragment)
10600 {
10601     wxRichTextParagraphLayoutBox* container = GetContainer();
10602     wxASSERT(container != NULL);
10603     if (!container)
10604         return;
10605
10606     wxRichTextObjectList::compatibility_iterator node = fragment.GetChildren().GetFirst();
10607     while (node)
10608     {
10609         wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
10610         wxASSERT (para != NULL);
10611
10612         // We'll replace the existing paragraph by finding the paragraph at this position,
10613         // delete its node data, and setting a copy as the new node data.
10614         // TODO: make more efficient by simply swapping old and new paragraph objects.
10615
10616         wxRichTextParagraph* existingPara = container->GetParagraphAtPosition(para->GetRange().GetStart());
10617         if (existingPara)
10618         {
10619             wxRichTextObjectList::compatibility_iterator bufferParaNode = container->GetChildren().Find(existingPara);
10620             if (bufferParaNode)
10621             {
10622                 wxRichTextParagraph* newPara = new wxRichTextParagraph(*para);
10623                 newPara->SetParent(container);
10624
10625                 bufferParaNode->SetData(newPara);
10626
10627                 delete existingPara;
10628             }
10629         }
10630
10631         node = node->GetNext();
10632     }
10633 }
10634
10635
10636 /*!
10637  * wxRichTextRange
10638  * This stores beginning and end positions for a range of data.
10639  */
10640
10641 WX_DEFINE_OBJARRAY(wxRichTextRangeArray);
10642
10643 /// Limit this range to be within 'range'
10644 bool wxRichTextRange::LimitTo(const wxRichTextRange& range)
10645 {
10646     if (m_start < range.m_start)
10647         m_start = range.m_start;
10648
10649     if (m_end > range.m_end)
10650         m_end = range.m_end;
10651
10652     return true;
10653 }
10654
10655 /*!
10656  * wxRichTextImage implementation
10657  * This object represents an image.
10658  */
10659
10660 IMPLEMENT_DYNAMIC_CLASS(wxRichTextImage, wxRichTextObject)
10661
10662 wxRichTextImage::wxRichTextImage(const wxImage& image, wxRichTextObject* parent, wxRichTextAttr* charStyle):
10663     wxRichTextObject(parent)
10664 {
10665     Init();
10666     m_imageBlock.MakeImageBlockDefaultQuality(image, wxBITMAP_TYPE_PNG);
10667     if (charStyle)
10668         SetAttributes(*charStyle);
10669 }
10670
10671 wxRichTextImage::wxRichTextImage(const wxRichTextImageBlock& imageBlock, wxRichTextObject* parent, wxRichTextAttr* charStyle):
10672     wxRichTextObject(parent)
10673 {
10674     Init();
10675     m_imageBlock = imageBlock;
10676     if (charStyle)
10677         SetAttributes(*charStyle);
10678 }
10679
10680 void wxRichTextImage::Init()
10681 {
10682     m_originalImageSize = wxSize(-1, -1);
10683 }
10684
10685 /// Create a cached image at the required size
10686 bool wxRichTextImage::LoadImageCache(wxDC& dc, bool resetCache)
10687 {
10688     if (!m_imageBlock.IsOk())
10689         return false;
10690
10691     // If we have an original image size, use that to compute the cached bitmap size
10692     // instead of loading the image each time. This way we can avoid loading
10693     // the image so long as the new cached bitmap size hasn't changed.
10694
10695     wxImage image;
10696     if (resetCache || m_originalImageSize == wxSize(-1, -1))
10697     {
10698         m_imageCache = wxNullBitmap;
10699
10700         m_imageBlock.Load(image);
10701         if (!image.IsOk())
10702             return false;
10703
10704         m_originalImageSize = wxSize(image.GetWidth(), image.GetHeight());
10705     }
10706
10707     int width = m_originalImageSize.GetWidth();
10708     int height = m_originalImageSize.GetHeight();
10709
10710     int parentWidth = 0;
10711     int parentHeight = 0;
10712
10713     int maxWidth = -1;
10714     int maxHeight = -1;
10715
10716     wxRichTextBuffer* buffer = GetBuffer();
10717     if (buffer)
10718     {
10719         wxSize sz;
10720         if (buffer->GetRichTextCtrl())
10721         {
10722             // Subtract borders
10723             sz = buffer->GetRichTextCtrl()->GetClientSize();
10724
10725             wxRect marginRect, borderRect, contentRect, paddingRect, outlineRect;
10726             marginRect = wxRect(0, 0, sz.x, sz.y);
10727             buffer->GetBoxRects(dc, buffer, buffer->GetAttributes(), marginRect, borderRect, contentRect, paddingRect, outlineRect);
10728
10729             sz = contentRect.GetSize();
10730
10731             // Start with a maximum width of the control size, even if not specified by the content,
10732             // to minimize the amount of picture overlapping the right-hand side
10733             maxWidth = sz.x;
10734         }
10735         else
10736             sz = buffer->GetCachedSize();
10737         parentWidth = sz.GetWidth();
10738         parentHeight = sz.GetHeight();
10739     }
10740
10741     if (GetAttributes().GetTextBoxAttr().GetWidth().IsValid() && GetAttributes().GetTextBoxAttr().GetWidth().GetValue() > 0)
10742     {
10743         if (parentWidth > 0 && GetAttributes().GetTextBoxAttr().GetWidth().GetUnits() == wxTEXT_ATTR_UNITS_PERCENTAGE)
10744             width = (int) ((GetAttributes().GetTextBoxAttr().GetWidth().GetValue() * parentWidth)/100.0);
10745         else if (GetAttributes().GetTextBoxAttr().GetWidth().GetUnits() == wxTEXT_ATTR_UNITS_TENTHS_MM)
10746             width = ConvertTenthsMMToPixels(dc, GetAttributes().GetTextBoxAttr().GetWidth().GetValue());
10747         else if (GetAttributes().GetTextBoxAttr().GetWidth().GetUnits() == wxTEXT_ATTR_UNITS_PIXELS)
10748             width = GetAttributes().GetTextBoxAttr().GetWidth().GetValue();
10749     }
10750
10751     // Limit to max width
10752
10753     if (GetAttributes().GetTextBoxAttr().GetMaxSize().GetWidth().IsValid() && GetAttributes().GetTextBoxAttr().GetMaxSize().GetWidth().GetValue() > 0)
10754     {
10755         int mw = -1;
10756
10757         if (parentWidth > 0 && GetAttributes().GetTextBoxAttr().GetMaxSize().GetWidth().GetUnits() == wxTEXT_ATTR_UNITS_PERCENTAGE)
10758             mw = (int) ((GetAttributes().GetTextBoxAttr().GetMaxSize().GetWidth().GetValue() * parentWidth)/100.0);
10759         else if (GetAttributes().GetTextBoxAttr().GetMaxSize().GetWidth().GetUnits() == wxTEXT_ATTR_UNITS_TENTHS_MM)
10760             mw = ConvertTenthsMMToPixels(dc, GetAttributes().GetTextBoxAttr().GetMaxSize().GetWidth().GetValue());
10761         else if (GetAttributes().GetTextBoxAttr().GetMaxSize().GetWidth().GetUnits() == wxTEXT_ATTR_UNITS_PIXELS)
10762             mw = GetAttributes().GetTextBoxAttr().GetMaxSize().GetWidth().GetValue();
10763
10764         // If we already have a smaller max width due to the constraints of the control size,
10765         // don't use the larger max width.
10766         if (mw != -1 && ((maxWidth == -1) || (mw < maxWidth)))
10767             maxWidth = mw;
10768     }
10769
10770     if (maxWidth > 0 && width > maxWidth)
10771         width = maxWidth;
10772
10773     // Preserve the aspect ratio
10774     if (width != m_originalImageSize.GetWidth())
10775         height = (int) (float(m_originalImageSize.GetHeight()) * (float(width)/float(m_originalImageSize.GetWidth())));
10776
10777     if (GetAttributes().GetTextBoxAttr().GetHeight().IsValid() && GetAttributes().GetTextBoxAttr().GetHeight().GetValue() > 0)
10778     {
10779         if (parentHeight > 0 && GetAttributes().GetTextBoxAttr().GetHeight().GetUnits() == wxTEXT_ATTR_UNITS_PERCENTAGE)
10780             height = (int) ((GetAttributes().GetTextBoxAttr().GetHeight().GetValue() * parentHeight)/100.0);
10781         else if (GetAttributes().GetTextBoxAttr().GetHeight().GetUnits() == wxTEXT_ATTR_UNITS_TENTHS_MM)
10782             height = ConvertTenthsMMToPixels(dc, GetAttributes().GetTextBoxAttr().GetHeight().GetValue());
10783         else if (GetAttributes().GetTextBoxAttr().GetHeight().GetUnits() == wxTEXT_ATTR_UNITS_PIXELS)
10784             height = GetAttributes().GetTextBoxAttr().GetHeight().GetValue();
10785
10786         // Preserve the aspect ratio
10787         if (height != m_originalImageSize.GetHeight())
10788             width = (int) (float(m_originalImageSize.GetWidth()) * (float(height)/float(m_originalImageSize.GetHeight())));
10789     }
10790
10791     // Limit to max height
10792
10793     if (GetAttributes().GetTextBoxAttr().GetMaxSize().GetHeight().IsValid() && GetAttributes().GetTextBoxAttr().GetMaxSize().GetHeight().GetValue() > 0)
10794     {
10795         if (parentHeight > 0 && GetAttributes().GetTextBoxAttr().GetMaxSize().GetHeight().GetUnits() == wxTEXT_ATTR_UNITS_PERCENTAGE)
10796             maxHeight = (int) ((GetAttributes().GetTextBoxAttr().GetMaxSize().GetHeight().GetValue() * parentHeight)/100.0);
10797         else if (GetAttributes().GetTextBoxAttr().GetMaxSize().GetHeight().GetUnits() == wxTEXT_ATTR_UNITS_TENTHS_MM)
10798             maxHeight = ConvertTenthsMMToPixels(dc, GetAttributes().GetTextBoxAttr().GetMaxSize().GetHeight().GetValue());
10799         else if (GetAttributes().GetTextBoxAttr().GetMaxSize().GetHeight().GetUnits() == wxTEXT_ATTR_UNITS_PIXELS)
10800             maxHeight = GetAttributes().GetTextBoxAttr().GetMaxSize().GetHeight().GetValue();
10801     }
10802
10803     if (maxHeight > 0 && height > maxHeight)
10804     {
10805         height = maxHeight;
10806
10807         // Preserve the aspect ratio
10808         if (height != m_originalImageSize.GetHeight())
10809             width = (int) (float(m_originalImageSize.GetWidth()) * (float(height)/float(m_originalImageSize.GetHeight())));
10810     }
10811
10812     if (m_imageCache.IsOk() && m_imageCache.GetWidth() == width && m_imageCache.GetHeight() == height)
10813     {
10814         // Do nothing, we didn't need to change the image cache
10815     }
10816     else
10817     {
10818         if (!image.IsOk())
10819         {
10820             m_imageBlock.Load(image);
10821             if (!image.IsOk())
10822                 return false;
10823         }
10824
10825         if (image.GetWidth() == width && image.GetHeight() == height)
10826             m_imageCache = wxBitmap(image);
10827         else
10828         {
10829             // If the original width and height is small, e.g. 400 or below,
10830             // scale up and then down to improve image quality. This can make
10831             // a big difference, with not much performance hit.
10832             int upscaleThreshold = 400;
10833             wxImage img;
10834             if (image.GetWidth() <= upscaleThreshold || image.GetHeight() <= upscaleThreshold)
10835             {
10836                 img = image.Scale(image.GetWidth()*2, image.GetHeight()*2);
10837                 img.Rescale(width, height, wxIMAGE_QUALITY_HIGH);
10838             }
10839             else
10840                 img = image.Scale(width, height, wxIMAGE_QUALITY_HIGH);
10841             m_imageCache = wxBitmap(img);
10842         }
10843     }
10844
10845     return m_imageCache.IsOk();
10846 }
10847
10848 /// Draw the item
10849 bool wxRichTextImage::Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& WXUNUSED(range), const wxRichTextSelection& selection, const wxRect& rect, int WXUNUSED(descent), int WXUNUSED(style))
10850 {
10851     if (!IsShown())
10852         return true;
10853
10854     // Don't need cached size AFAIK
10855     // wxSize size = GetCachedSize();
10856     if (!LoadImageCache(dc))
10857         return false;
10858
10859     wxRichTextAttr attr(GetAttributes());
10860     context.ApplyVirtualAttributes(attr, this);
10861
10862     DrawBoxAttributes(dc, GetBuffer(), attr, wxRect(rect.GetPosition(), GetCachedSize()));
10863
10864     wxSize imageSize(m_imageCache.GetWidth(), m_imageCache.GetHeight());
10865     wxRect marginRect, borderRect, contentRect, paddingRect, outlineRect;
10866     marginRect = rect; // outer rectangle, will calculate contentRect
10867     GetBoxRects(dc, GetBuffer(), attr, marginRect, borderRect, contentRect, paddingRect, outlineRect);
10868
10869     dc.DrawBitmap(m_imageCache, contentRect.x, contentRect.y, true);
10870
10871     if (selection.WithinSelection(GetRange().GetStart(), this))
10872     {
10873         wxCheckSetBrush(dc, *wxBLACK_BRUSH);
10874         wxCheckSetPen(dc, *wxBLACK_PEN);
10875         dc.SetLogicalFunction(wxINVERT);
10876         dc.DrawRectangle(contentRect);
10877         dc.SetLogicalFunction(wxCOPY);
10878     }
10879
10880     return true;
10881 }
10882
10883 /// Lay the item out
10884 bool wxRichTextImage::Layout(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, const wxRect& WXUNUSED(parentRect), int WXUNUSED(style))
10885 {
10886     if (!LoadImageCache(dc))
10887         return false;
10888
10889     wxSize imageSize(m_imageCache.GetWidth(), m_imageCache.GetHeight());
10890     wxRect marginRect, borderRect, contentRect, paddingRect, outlineRect;
10891     contentRect = wxRect(wxPoint(0,0), imageSize);
10892
10893     wxRichTextAttr attr(GetAttributes());
10894     context.ApplyVirtualAttributes(attr, this);
10895
10896     GetBoxRects(dc, GetBuffer(), attr, marginRect, borderRect, contentRect, paddingRect, outlineRect);
10897
10898     wxSize overallSize = marginRect.GetSize();
10899
10900     SetCachedSize(overallSize);
10901     SetMaxSize(overallSize);
10902     SetMinSize(overallSize);
10903     SetPosition(rect.GetPosition());
10904
10905     return true;
10906 }
10907
10908 /// Get/set the object size for the given range. Returns false if the range
10909 /// is invalid for this object.
10910 bool wxRichTextImage::GetRangeSize(const wxRichTextRange& range, wxSize& size, int& WXUNUSED(descent), wxDC& dc, wxRichTextDrawingContext& context, int WXUNUSED(flags), wxPoint WXUNUSED(position), wxArrayInt* partialExtents) const
10911 {
10912     if (!range.IsWithin(GetRange()))
10913         return false;
10914
10915     if (!((wxRichTextImage*)this)->LoadImageCache(dc))
10916     {
10917         size.x = 0; size.y = 0;
10918         if (partialExtents)
10919             partialExtents->Add(0);
10920         return false;
10921     }
10922
10923     wxRichTextAttr attr(GetAttributes());
10924     context.ApplyVirtualAttributes(attr, (wxRichTextObject*) this);
10925
10926     wxSize imageSize(m_imageCache.GetWidth(), m_imageCache.GetHeight());
10927     wxRect marginRect, borderRect, contentRect, paddingRect, outlineRect;
10928     contentRect = wxRect(wxPoint(0,0), imageSize);
10929     GetBoxRects(dc, GetBuffer(), attr, marginRect, borderRect, contentRect, paddingRect, outlineRect);
10930
10931     wxSize overallSize = marginRect.GetSize();
10932
10933     if (partialExtents)
10934         partialExtents->Add(overallSize.x);
10935
10936     size = overallSize;
10937
10938     return true;
10939 }
10940
10941 // Get the 'natural' size for an object. For an image, it would be the
10942 // image size.
10943 wxTextAttrSize wxRichTextImage::GetNaturalSize() const
10944 {
10945     wxTextAttrSize size;
10946     if (GetImageCache().IsOk())
10947     {
10948         size.SetWidth(GetImageCache().GetWidth(), wxTEXT_ATTR_UNITS_PIXELS);
10949         size.SetHeight(GetImageCache().GetHeight(), wxTEXT_ATTR_UNITS_PIXELS);
10950     }
10951     return size;
10952 }
10953
10954
10955 /// Copy
10956 void wxRichTextImage::Copy(const wxRichTextImage& obj)
10957 {
10958     wxRichTextObject::Copy(obj);
10959
10960     m_imageBlock = obj.m_imageBlock;
10961     m_originalImageSize = obj.m_originalImageSize;
10962 }
10963
10964 /// Edit properties via a GUI
10965 bool wxRichTextImage::EditProperties(wxWindow* parent, wxRichTextBuffer* buffer)
10966 {
10967     wxRichTextObjectPropertiesDialog imageDlg(this, wxGetTopLevelParent(parent), wxID_ANY, _("Picture Properties"));
10968     imageDlg.SetAttributes(GetAttributes());
10969
10970     if (imageDlg.ShowModal() == wxID_OK)
10971     {
10972         // By passing wxRICHTEXT_SETSTYLE_RESET, indeterminate attributes set by the user will be set as
10973         // indeterminate in the object.
10974         imageDlg.ApplyStyle(buffer->GetRichTextCtrl(), wxRICHTEXT_SETSTYLE_WITH_UNDO|wxRICHTEXT_SETSTYLE_RESET);
10975         return true;
10976     }
10977     else
10978         return false;
10979 }
10980
10981 /*!
10982  * Utilities
10983  *
10984  */
10985
10986 /// Compare two attribute objects
10987 bool wxTextAttrEq(const wxRichTextAttr& attr1, const wxRichTextAttr& attr2)
10988 {
10989     return (attr1 == attr2);
10990 }
10991
10992 /// Compare tabs
10993 bool wxRichTextTabsEq(const wxArrayInt& tabs1, const wxArrayInt& tabs2)
10994 {
10995     if (tabs1.GetCount() != tabs2.GetCount())
10996         return false;
10997
10998     size_t i;
10999     for (i = 0; i < tabs1.GetCount(); i++)
11000     {
11001         if (tabs1[i] != tabs2[i])
11002             return false;
11003     }
11004     return true;
11005 }
11006
11007 bool wxRichTextApplyStyle(wxRichTextAttr& destStyle, const wxRichTextAttr& style, wxRichTextAttr* compareWith)
11008 {
11009     return destStyle.Apply(style, compareWith);
11010 }
11011
11012 // Remove attributes
11013 bool wxRichTextRemoveStyle(wxRichTextAttr& destStyle, const wxRichTextAttr& style)
11014 {
11015     return destStyle.RemoveStyle(style);
11016 }
11017
11018 /// Combine two bitlists, specifying the bits of interest with separate flags.
11019 bool wxRichTextCombineBitlists(int& valueA, int valueB, int& flagsA, int flagsB)
11020 {
11021     return wxRichTextAttr::CombineBitlists(valueA, valueB, flagsA, flagsB);
11022 }
11023
11024 /// Compare two bitlists
11025 bool wxRichTextBitlistsEqPartial(int valueA, int valueB, int flags)
11026 {
11027     return wxRichTextAttr::BitlistsEqPartial(valueA, valueB, flags);
11028 }
11029
11030 /// Split into paragraph and character styles
11031 bool wxRichTextSplitParaCharStyles(const wxRichTextAttr& style, wxRichTextAttr& parStyle, wxRichTextAttr& charStyle)
11032 {
11033     return wxRichTextAttr::SplitParaCharStyles(style, parStyle, charStyle);
11034 }
11035
11036 /// Convert a decimal to Roman numerals
11037 wxString wxRichTextDecimalToRoman(long n)
11038 {
11039     static wxArrayInt decimalNumbers;
11040     static wxArrayString romanNumbers;
11041
11042     // Clean up arrays
11043     if (n == -1)
11044     {
11045         decimalNumbers.Clear();
11046         romanNumbers.Clear();
11047         return wxEmptyString;
11048     }
11049
11050     if (decimalNumbers.GetCount() == 0)
11051     {
11052         #define wxRichTextAddDecRom(n, r) decimalNumbers.Add(n); romanNumbers.Add(r);
11053
11054         wxRichTextAddDecRom(1000, wxT("M"));
11055         wxRichTextAddDecRom(900, wxT("CM"));
11056         wxRichTextAddDecRom(500, wxT("D"));
11057         wxRichTextAddDecRom(400, wxT("CD"));
11058         wxRichTextAddDecRom(100, wxT("C"));
11059         wxRichTextAddDecRom(90, wxT("XC"));
11060         wxRichTextAddDecRom(50, wxT("L"));
11061         wxRichTextAddDecRom(40, wxT("XL"));
11062         wxRichTextAddDecRom(10, wxT("X"));
11063         wxRichTextAddDecRom(9, wxT("IX"));
11064         wxRichTextAddDecRom(5, wxT("V"));
11065         wxRichTextAddDecRom(4, wxT("IV"));
11066         wxRichTextAddDecRom(1, wxT("I"));
11067     }
11068
11069     int i = 0;
11070     wxString roman;
11071
11072     while (n > 0 && i < 13)
11073     {
11074         if (n >= decimalNumbers[i])
11075         {
11076             n -= decimalNumbers[i];
11077             roman += romanNumbers[i];
11078         }
11079         else
11080         {
11081             i ++;
11082         }
11083     }
11084     if (roman.IsEmpty())
11085         roman = wxT("0");
11086     return roman;
11087 }
11088
11089 /*!
11090  * wxRichTextFileHandler
11091  * Base class for file handlers
11092  */
11093
11094 IMPLEMENT_CLASS(wxRichTextFileHandler, wxObject)
11095
11096 #if wxUSE_FFILE && wxUSE_STREAMS
11097 bool wxRichTextFileHandler::LoadFile(wxRichTextBuffer *buffer, const wxString& filename)
11098 {
11099     wxFFileInputStream stream(filename);
11100     if (stream.IsOk())
11101         return LoadFile(buffer, stream);
11102
11103     return false;
11104 }
11105
11106 bool wxRichTextFileHandler::SaveFile(wxRichTextBuffer *buffer, const wxString& filename)
11107 {
11108     wxFFileOutputStream stream(filename);
11109     if (stream.IsOk())
11110         return SaveFile(buffer, stream);
11111
11112     return false;
11113 }
11114 #endif // wxUSE_FFILE && wxUSE_STREAMS
11115
11116 /// Can we handle this filename (if using files)? By default, checks the extension.
11117 bool wxRichTextFileHandler::CanHandle(const wxString& filename) const
11118 {
11119     wxString path, file, ext;
11120     wxFileName::SplitPath(filename, & path, & file, & ext);
11121
11122     return (ext.Lower() == GetExtension());
11123 }
11124
11125 /*!
11126  * wxRichTextTextHandler
11127  * Plain text handler
11128  */
11129
11130 IMPLEMENT_CLASS(wxRichTextPlainTextHandler, wxRichTextFileHandler)
11131
11132 #if wxUSE_STREAMS
11133 bool wxRichTextPlainTextHandler::DoLoadFile(wxRichTextBuffer *buffer, wxInputStream& stream)
11134 {
11135     if (!stream.IsOk())
11136         return false;
11137
11138     wxString str;
11139     int lastCh = 0;
11140
11141     while (!stream.Eof())
11142     {
11143         int ch = stream.GetC();
11144
11145         if (!stream.Eof())
11146         {
11147             if (ch == 10 && lastCh != 13)
11148                 str += wxT('\n');
11149
11150             if (ch > 0 && ch != 10)
11151                 str += wxChar(ch);
11152
11153             lastCh = ch;
11154         }
11155     }
11156
11157     buffer->ResetAndClearCommands();
11158     buffer->Clear();
11159     buffer->AddParagraphs(str);
11160     buffer->UpdateRanges();
11161
11162     return true;
11163 }
11164
11165 bool wxRichTextPlainTextHandler::DoSaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream)
11166 {
11167     if (!stream.IsOk())
11168         return false;
11169
11170     wxString text = buffer->GetText();
11171
11172     wxString newLine = wxRichTextLineBreakChar;
11173     text.Replace(newLine, wxT("\n"));
11174
11175     wxCharBuffer buf = text.ToAscii();
11176
11177     stream.Write((const char*) buf, text.length());
11178     return true;
11179 }
11180 #endif // wxUSE_STREAMS
11181
11182 /*
11183  * Stores information about an image, in binary in-memory form
11184  */
11185
11186 wxRichTextImageBlock::wxRichTextImageBlock()
11187 {
11188     Init();
11189 }
11190
11191 wxRichTextImageBlock::wxRichTextImageBlock(const wxRichTextImageBlock& block):wxObject()
11192 {
11193     Init();
11194     Copy(block);
11195 }
11196
11197 wxRichTextImageBlock::~wxRichTextImageBlock()
11198 {
11199     wxDELETEA(m_data);
11200 }
11201
11202 void wxRichTextImageBlock::Init()
11203 {
11204     m_data = NULL;
11205     m_dataSize = 0;
11206     m_imageType = wxBITMAP_TYPE_INVALID;
11207 }
11208
11209 void wxRichTextImageBlock::Clear()
11210 {
11211     wxDELETEA(m_data);
11212     m_dataSize = 0;
11213     m_imageType = wxBITMAP_TYPE_INVALID;
11214 }
11215
11216
11217 // Load the original image into a memory block.
11218 // If the image is not a JPEG, we must convert it into a JPEG
11219 // to conserve space.
11220 // If it's not a JPEG we can make use of 'image', already scaled, so we don't have to
11221 // load the image a 2nd time.
11222
11223 bool wxRichTextImageBlock::MakeImageBlock(const wxString& filename, wxBitmapType imageType,
11224                                           wxImage& image, bool convertToJPEG)
11225 {
11226     m_imageType = imageType;
11227
11228     wxString filenameToRead(filename);
11229     bool removeFile = false;
11230
11231     if (imageType == wxBITMAP_TYPE_INVALID)
11232         return false; // Could not determine image type
11233
11234     if ((imageType != wxBITMAP_TYPE_JPEG) && convertToJPEG)
11235     {
11236         wxString tempFile =
11237             wxFileName::CreateTempFileName(_("image"));
11238
11239         wxASSERT(!tempFile.IsEmpty());
11240
11241         image.SaveFile(tempFile, wxBITMAP_TYPE_JPEG);
11242         filenameToRead = tempFile;
11243         removeFile = true;
11244
11245         m_imageType = wxBITMAP_TYPE_JPEG;
11246     }
11247     wxFile file;
11248     if (!file.Open(filenameToRead))
11249         return false;
11250
11251     m_dataSize = (size_t) file.Length();
11252     file.Close();
11253
11254     if (m_data)
11255         delete[] m_data;
11256     m_data = ReadBlock(filenameToRead, m_dataSize);
11257
11258     if (removeFile)
11259         wxRemoveFile(filenameToRead);
11260
11261     return (m_data != NULL);
11262 }
11263
11264 // Make an image block from the wxImage in the given
11265 // format.
11266 bool wxRichTextImageBlock::MakeImageBlock(wxImage& image, wxBitmapType imageType, int quality)
11267 {
11268     image.SetOption(wxT("quality"), quality);
11269
11270     if (imageType == wxBITMAP_TYPE_INVALID)
11271         return false; // Could not determine image type
11272
11273     return DoMakeImageBlock(image, imageType);
11274 }
11275
11276 // Uses a const wxImage for efficiency, but can't set quality (only relevant for JPEG)
11277 bool wxRichTextImageBlock::MakeImageBlockDefaultQuality(const wxImage& image, wxBitmapType imageType)
11278 {
11279     if (imageType == wxBITMAP_TYPE_INVALID)
11280         return false; // Could not determine image type
11281
11282     return DoMakeImageBlock(image, imageType);
11283 }
11284
11285 // Makes the image block
11286 bool wxRichTextImageBlock::DoMakeImageBlock(const wxImage& image, wxBitmapType imageType)
11287 {
11288     wxMemoryOutputStream memStream;
11289     if (!image.SaveFile(memStream, imageType))
11290     {
11291         return false;
11292     }
11293
11294     unsigned char* block = new unsigned char[memStream.GetSize()];
11295     if (!block)
11296         return false;
11297
11298     if (m_data)
11299         delete[] m_data;
11300     m_data = block;
11301
11302     m_imageType = imageType;
11303     m_dataSize = memStream.GetSize();
11304
11305     memStream.CopyTo(m_data, m_dataSize);
11306
11307     return (m_data != NULL);
11308 }
11309
11310 // Write to a file
11311 bool wxRichTextImageBlock::Write(const wxString& filename)
11312 {
11313     return WriteBlock(filename, m_data, m_dataSize);
11314 }
11315
11316 void wxRichTextImageBlock::Copy(const wxRichTextImageBlock& block)
11317 {
11318     m_imageType = block.m_imageType;
11319     wxDELETEA(m_data);
11320     m_dataSize = block.m_dataSize;
11321     if (m_dataSize == 0)
11322         return;
11323
11324     m_data = new unsigned char[m_dataSize];
11325     unsigned int i;
11326     for (i = 0; i < m_dataSize; i++)
11327         m_data[i] = block.m_data[i];
11328 }
11329
11330 //// Operators
11331 void wxRichTextImageBlock::operator=(const wxRichTextImageBlock& block)
11332 {
11333     Copy(block);
11334 }
11335
11336 // Load a wxImage from the block
11337 bool wxRichTextImageBlock::Load(wxImage& image)
11338 {
11339     if (!m_data)
11340         return false;
11341
11342     // Read in the image.
11343 #if wxUSE_STREAMS
11344     wxMemoryInputStream mstream(m_data, m_dataSize);
11345     bool success = image.LoadFile(mstream, GetImageType());
11346 #else
11347     wxString tempFile = wxFileName::CreateTempFileName(_("image"));
11348     wxASSERT(!tempFile.IsEmpty());
11349
11350     if (!WriteBlock(tempFile, m_data, m_dataSize))
11351     {
11352         return false;
11353     }
11354     success = image.LoadFile(tempFile, GetImageType());
11355     wxRemoveFile(tempFile);
11356 #endif
11357
11358     return success;
11359 }
11360
11361 // Write data in hex to a stream
11362 bool wxRichTextImageBlock::WriteHex(wxOutputStream& stream)
11363 {
11364     if (m_dataSize == 0)
11365         return true;
11366
11367     int bufSize = 100000;
11368     if (int(2*m_dataSize) < bufSize)
11369         bufSize = 2*m_dataSize;
11370     char* buf = new char[bufSize+1];
11371
11372     int left = m_dataSize;
11373     int n, i, j;
11374     j = 0;
11375     while (left > 0)
11376     {
11377         if (left*2 > bufSize)
11378         {
11379             n = bufSize; left -= (bufSize/2);
11380         }
11381         else
11382         {
11383             n = left*2; left = 0;
11384         }
11385
11386         char* b = buf;
11387         for (i = 0; i < (n/2); i++)
11388         {
11389             wxDecToHex(m_data[j], b, b+1);
11390             b += 2; j ++;
11391         }
11392
11393         buf[n] = 0;
11394         stream.Write((const char*) buf, n);
11395     }
11396     delete[] buf;
11397     return true;
11398 }
11399
11400 // Read data in hex from a stream
11401 bool wxRichTextImageBlock::ReadHex(wxInputStream& stream, int length, wxBitmapType imageType)
11402 {
11403     int dataSize = length/2;
11404
11405     if (m_data)
11406         delete[] m_data;
11407
11408     // create a null terminated temporary string:
11409     char str[3];
11410     str[2] = '\0';
11411
11412     m_data = new unsigned char[dataSize];
11413     int i;
11414     for (i = 0; i < dataSize; i ++)
11415     {
11416         str[0] = (char)stream.GetC();
11417         str[1] = (char)stream.GetC();
11418
11419         m_data[i] = (unsigned char)wxHexToDec(str);
11420     }
11421
11422     m_dataSize = dataSize;
11423     m_imageType = imageType;
11424
11425     return true;
11426 }
11427
11428 // Allocate and read from stream as a block of memory
11429 unsigned char* wxRichTextImageBlock::ReadBlock(wxInputStream& stream, size_t size)
11430 {
11431     unsigned char* block = new unsigned char[size];
11432     if (!block)
11433         return NULL;
11434
11435     stream.Read(block, size);
11436
11437     return block;
11438 }
11439
11440 unsigned char* wxRichTextImageBlock::ReadBlock(const wxString& filename, size_t size)
11441 {
11442     wxFileInputStream stream(filename);
11443     if (!stream.IsOk())
11444         return NULL;
11445
11446     return ReadBlock(stream, size);
11447 }
11448
11449 // Write memory block to stream
11450 bool wxRichTextImageBlock::WriteBlock(wxOutputStream& stream, unsigned char* block, size_t size)
11451 {
11452     stream.Write((void*) block, size);
11453     return stream.IsOk();
11454
11455 }
11456
11457 // Write memory block to file
11458 bool wxRichTextImageBlock::WriteBlock(const wxString& filename, unsigned char* block, size_t size)
11459 {
11460     wxFileOutputStream outStream(filename);
11461     if (!outStream.IsOk())
11462         return false;
11463
11464     return WriteBlock(outStream, block, size);
11465 }
11466
11467 // Gets the extension for the block's type
11468 wxString wxRichTextImageBlock::GetExtension() const
11469 {
11470     wxImageHandler* handler = wxImage::FindHandler(GetImageType());
11471     if (handler)
11472         return handler->GetExtension();
11473     else
11474         return wxEmptyString;
11475 }
11476
11477 #if wxUSE_DATAOBJ
11478
11479 /*!
11480  * The data object for a wxRichTextBuffer
11481  */
11482
11483 const wxChar *wxRichTextBufferDataObject::ms_richTextBufferFormatId = wxT("wxShape");
11484
11485 wxRichTextBufferDataObject::wxRichTextBufferDataObject(wxRichTextBuffer* richTextBuffer)
11486 {
11487     m_richTextBuffer = richTextBuffer;
11488
11489     // this string should uniquely identify our format, but is otherwise
11490     // arbitrary
11491     m_formatRichTextBuffer.SetId(GetRichTextBufferFormatId());
11492
11493     SetFormat(m_formatRichTextBuffer);
11494 }
11495
11496 wxRichTextBufferDataObject::~wxRichTextBufferDataObject()
11497 {
11498     delete m_richTextBuffer;
11499 }
11500
11501 // after a call to this function, the richTextBuffer is owned by the caller and it
11502 // is responsible for deleting it!
11503 wxRichTextBuffer* wxRichTextBufferDataObject::GetRichTextBuffer()
11504 {
11505     wxRichTextBuffer* richTextBuffer = m_richTextBuffer;
11506     m_richTextBuffer = NULL;
11507
11508     return richTextBuffer;
11509 }
11510
11511 wxDataFormat wxRichTextBufferDataObject::GetPreferredFormat(Direction WXUNUSED(dir)) const
11512 {
11513     return m_formatRichTextBuffer;
11514 }
11515
11516 size_t wxRichTextBufferDataObject::GetDataSize() const
11517 {
11518     if (!m_richTextBuffer)
11519         return 0;
11520
11521     wxString bufXML;
11522
11523     {
11524         wxStringOutputStream stream(& bufXML);
11525         if (!m_richTextBuffer->SaveFile(stream, wxRICHTEXT_TYPE_XML))
11526         {
11527             wxLogError(wxT("Could not write the buffer to an XML stream.\nYou may have forgotten to add the XML file handler."));
11528             return 0;
11529         }
11530     }
11531
11532 #if wxUSE_UNICODE
11533     wxCharBuffer buffer = bufXML.mb_str(wxConvUTF8);
11534     return strlen(buffer) + 1;
11535 #else
11536     return bufXML.Length()+1;
11537 #endif
11538 }
11539
11540 bool wxRichTextBufferDataObject::GetDataHere(void *pBuf) const
11541 {
11542     if (!pBuf || !m_richTextBuffer)
11543         return false;
11544
11545     wxString bufXML;
11546
11547     {
11548         wxStringOutputStream stream(& bufXML);
11549         if (!m_richTextBuffer->SaveFile(stream, wxRICHTEXT_TYPE_XML))
11550         {
11551             wxLogError(wxT("Could not write the buffer to an XML stream.\nYou may have forgotten to add the XML file handler."));
11552             return 0;
11553         }
11554     }
11555
11556 #if wxUSE_UNICODE
11557     wxCharBuffer buffer = bufXML.mb_str(wxConvUTF8);
11558     size_t len = strlen(buffer);
11559     memcpy((char*) pBuf, (const char*) buffer, len);
11560     ((char*) pBuf)[len] = 0;
11561 #else
11562     size_t len = bufXML.Length();
11563     memcpy((char*) pBuf, (const char*) bufXML.c_str(), len);
11564     ((char*) pBuf)[len] = 0;
11565 #endif
11566
11567     return true;
11568 }
11569
11570 bool wxRichTextBufferDataObject::SetData(size_t WXUNUSED(len), const void *buf)
11571 {
11572     wxDELETE(m_richTextBuffer);
11573
11574     wxString bufXML((const char*) buf, wxConvUTF8);
11575
11576     m_richTextBuffer = new wxRichTextBuffer;
11577
11578     wxStringInputStream stream(bufXML);
11579     if (!m_richTextBuffer->LoadFile(stream, wxRICHTEXT_TYPE_XML))
11580     {
11581         wxLogError(wxT("Could not read the buffer from an XML stream.\nYou may have forgotten to add the XML file handler."));
11582
11583         wxDELETE(m_richTextBuffer);
11584
11585         return false;
11586     }
11587     return true;
11588 }
11589
11590 #endif
11591     // wxUSE_DATAOBJ
11592
11593
11594 /*
11595  * wxRichTextFontTable
11596  * Manages quick access to a pool of fonts for rendering rich text
11597  */
11598
11599 WX_DECLARE_STRING_HASH_MAP_WITH_DECL(wxFont, wxRichTextFontTableHashMap, class WXDLLIMPEXP_RICHTEXT);
11600
11601 class wxRichTextFontTableData: public wxObjectRefData
11602 {
11603 public:
11604     wxRichTextFontTableData() {}
11605
11606     wxFont FindFont(const wxRichTextAttr& fontSpec, double fontScale);
11607
11608     wxRichTextFontTableHashMap  m_hashMap;
11609 };
11610
11611 wxFont wxRichTextFontTableData::FindFont(const wxRichTextAttr& fontSpec, double fontScale)
11612 {
11613     wxString facename(fontSpec.GetFontFaceName());
11614
11615     int fontSize = fontSpec.GetFontSize();
11616     if (fontScale != 1.0)
11617         fontSize = (int) ((double(fontSize) * fontScale) + 0.5);
11618
11619     wxString units;
11620     if (fontSpec.HasFontPixelSize() && !fontSpec.HasFontPointSize())
11621         units = wxT("px");
11622     else
11623         units = wxT("pt");
11624     wxString spec = wxString::Format(wxT("%d-%s-%d-%d-%d-%d-%s-%d"),
11625         fontSize, units.c_str(), fontSpec.GetFontStyle(), fontSpec.GetFontWeight(), (int) fontSpec.GetFontUnderlined(), (int) fontSpec.GetFontStrikethrough(),
11626         facename.c_str(), (int) fontSpec.GetFontEncoding());
11627
11628     wxRichTextFontTableHashMap::iterator entry = m_hashMap.find(spec);
11629     if ( entry == m_hashMap.end() )
11630     {
11631         if (fontSpec.HasFontPixelSize() && !fontSpec.HasFontPointSize())
11632         {
11633             wxFont font(wxSize(0, fontSize), wxFONTFAMILY_DEFAULT, fontSpec.GetFontStyle(), fontSpec.GetFontWeight(), fontSpec.GetFontUnderlined(), facename);
11634             if (fontSpec.HasFontStrikethrough() && fontSpec.GetFontStrikethrough())
11635                 font.SetStrikethrough(true);
11636             m_hashMap[spec] = font;
11637             return font;
11638         }
11639         else
11640         {
11641             wxFont font(fontSize, wxFONTFAMILY_DEFAULT, fontSpec.GetFontStyle(), fontSpec.GetFontWeight(), fontSpec.GetFontUnderlined(), facename.c_str());
11642             if (fontSpec.HasFontStrikethrough() && fontSpec.GetFontStrikethrough())
11643                 font.SetStrikethrough(true);
11644
11645             m_hashMap[spec] = font;
11646             return font;
11647         }
11648     }
11649     else
11650     {
11651         return entry->second;
11652     }
11653 }
11654
11655 IMPLEMENT_DYNAMIC_CLASS(wxRichTextFontTable, wxObject)
11656
11657 wxRichTextFontTable::wxRichTextFontTable()
11658 {
11659     m_refData = new wxRichTextFontTableData;
11660     m_fontScale = 1.0;
11661 }
11662
11663 wxRichTextFontTable::wxRichTextFontTable(const wxRichTextFontTable& table)
11664     : wxObject()
11665 {
11666     (*this) = table;
11667 }
11668
11669 wxRichTextFontTable::~wxRichTextFontTable()
11670 {
11671     UnRef();
11672 }
11673
11674 bool wxRichTextFontTable::operator == (const wxRichTextFontTable& table) const
11675 {
11676     return (m_refData == table.m_refData);
11677 }
11678
11679 void wxRichTextFontTable::operator= (const wxRichTextFontTable& table)
11680 {
11681     Ref(table);
11682     m_fontScale = table.m_fontScale;
11683 }
11684
11685 wxFont wxRichTextFontTable::FindFont(const wxRichTextAttr& fontSpec)
11686 {
11687     wxRichTextFontTableData* data = (wxRichTextFontTableData*) m_refData;
11688     if (data)
11689         return data->FindFont(fontSpec, m_fontScale);
11690     else
11691         return wxFont();
11692 }
11693
11694 void wxRichTextFontTable::Clear()
11695 {
11696     wxRichTextFontTableData* data = (wxRichTextFontTableData*) m_refData;
11697     if (data)
11698         data->m_hashMap.clear();
11699 }
11700
11701 void wxRichTextFontTable::SetFontScale(double fontScale)
11702 {
11703     if (fontScale != m_fontScale)
11704         Clear();
11705     m_fontScale = fontScale;
11706 }
11707
11708 // wxTextBoxAttr
11709
11710 void wxTextBoxAttr::Reset()
11711 {
11712     m_flags = 0;
11713     m_floatMode = wxTEXT_BOX_ATTR_FLOAT_NONE;
11714     m_clearMode = wxTEXT_BOX_ATTR_CLEAR_NONE;
11715     m_collapseMode = wxTEXT_BOX_ATTR_COLLAPSE_NONE;
11716     m_verticalAlignment = wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_NONE;
11717     m_boxStyleName = wxEmptyString;
11718
11719     m_margins.Reset();
11720     m_padding.Reset();
11721     m_position.Reset();
11722
11723     m_size.Reset();
11724     m_minSize.Reset();
11725     m_maxSize.Reset();
11726
11727     m_border.Reset();
11728     m_outline.Reset();
11729 }
11730
11731 // Equality test
11732 bool wxTextBoxAttr::operator== (const wxTextBoxAttr& attr) const
11733 {
11734     return (
11735         m_flags == attr.m_flags &&
11736         m_floatMode == attr.m_floatMode &&
11737         m_clearMode == attr.m_clearMode &&
11738         m_collapseMode == attr.m_collapseMode &&
11739         m_verticalAlignment == attr.m_verticalAlignment &&
11740
11741         m_margins == attr.m_margins &&
11742         m_padding == attr.m_padding &&
11743         m_position == attr.m_position &&
11744
11745         m_size == attr.m_size &&
11746         m_minSize == attr.m_minSize &&
11747         m_maxSize == attr.m_maxSize &&
11748
11749         m_border == attr.m_border &&
11750         m_outline == attr.m_outline &&
11751
11752         m_boxStyleName == attr.m_boxStyleName
11753         );
11754 }
11755
11756 // Partial equality test
11757 bool wxTextBoxAttr::EqPartial(const wxTextBoxAttr& attr, bool weakTest) const
11758 {
11759     if (!weakTest &&
11760             ((!HasFloatMode() && attr.HasFloatMode()) ||
11761              (!HasClearMode() && attr.HasClearMode()) ||
11762              (!HasCollapseBorders() && attr.HasCollapseBorders()) ||
11763              (!HasVerticalAlignment() && attr.HasVerticalAlignment()) ||
11764              (!HasBoxStyleName() && attr.HasBoxStyleName())))
11765     {
11766         return false;
11767     }
11768     if (attr.HasFloatMode() && HasFloatMode() && (GetFloatMode() != attr.GetFloatMode()))
11769         return false;
11770
11771     if (attr.HasClearMode() && HasClearMode() && (GetClearMode() != attr.GetClearMode()))
11772         return false;
11773
11774     if (attr.HasCollapseBorders() && HasCollapseBorders() && (attr.GetCollapseBorders() != GetCollapseBorders()))
11775         return false;
11776
11777     if (attr.HasVerticalAlignment() && HasVerticalAlignment() && (attr.GetVerticalAlignment() != GetVerticalAlignment()))
11778         return false;
11779
11780     if (attr.HasBoxStyleName() && HasBoxStyleName() && (attr.GetBoxStyleName() != GetBoxStyleName()))
11781         return false;
11782
11783     // Position
11784
11785     if (!m_position.EqPartial(attr.m_position, weakTest))
11786         return false;
11787
11788     // Size
11789
11790     if (!m_size.EqPartial(attr.m_size, weakTest))
11791         return false;
11792     if (!m_minSize.EqPartial(attr.m_minSize, weakTest))
11793         return false;
11794     if (!m_maxSize.EqPartial(attr.m_maxSize, weakTest))
11795         return false;
11796
11797     // Margins
11798
11799     if (!m_margins.EqPartial(attr.m_margins, weakTest))
11800         return false;
11801
11802     // Padding
11803
11804     if (!m_padding.EqPartial(attr.m_padding, weakTest))
11805         return false;
11806
11807     // Border
11808
11809     if (!GetBorder().EqPartial(attr.GetBorder(), weakTest))
11810         return false;
11811
11812     // Outline
11813
11814     if (!GetOutline().EqPartial(attr.GetOutline(), weakTest))
11815         return false;
11816
11817     return true;
11818 }
11819
11820 // Merges the given attributes. If compareWith
11821 // is non-NULL, then it will be used to mask out those attributes that are the same in style
11822 // and compareWith, for situations where we don't want to explicitly set inherited attributes.
11823 bool wxTextBoxAttr::Apply(const wxTextBoxAttr& attr, const wxTextBoxAttr* compareWith)
11824 {
11825     if (attr.HasFloatMode())
11826     {
11827         if (!(compareWith && compareWith->HasFloatMode() && compareWith->GetFloatMode() == attr.GetFloatMode()))
11828             SetFloatMode(attr.GetFloatMode());
11829     }
11830
11831     if (attr.HasClearMode())
11832     {
11833         if (!(compareWith && compareWith->HasClearMode() && compareWith->GetClearMode() == attr.GetClearMode()))
11834             SetClearMode(attr.GetClearMode());
11835     }
11836
11837     if (attr.HasCollapseBorders())
11838     {
11839         if (!(compareWith && compareWith->HasCollapseBorders() && compareWith->GetCollapseBorders() == attr.GetCollapseBorders()))
11840             SetCollapseBorders(attr.GetCollapseBorders());
11841     }
11842
11843     if (attr.HasVerticalAlignment())
11844     {
11845         if (!(compareWith && compareWith->HasVerticalAlignment() && compareWith->GetVerticalAlignment() == attr.GetVerticalAlignment()))
11846             SetVerticalAlignment(attr.GetVerticalAlignment());
11847     }
11848
11849     if (attr.HasBoxStyleName())
11850     {
11851         if (!(compareWith && compareWith->HasBoxStyleName() && compareWith->GetBoxStyleName() == attr.GetBoxStyleName()))
11852             SetBoxStyleName(attr.GetBoxStyleName());
11853     }
11854
11855     m_margins.Apply(attr.m_margins, compareWith ? (& attr.m_margins) : (const wxTextAttrDimensions*) NULL);
11856     m_padding.Apply(attr.m_padding, compareWith ? (& attr.m_padding) : (const wxTextAttrDimensions*) NULL);
11857     m_position.Apply(attr.m_position, compareWith ? (& attr.m_position) : (const wxTextAttrDimensions*) NULL);
11858
11859     m_size.Apply(attr.m_size, compareWith ? (& attr.m_size) : (const wxTextAttrSize*) NULL);
11860     m_minSize.Apply(attr.m_minSize, compareWith ? (& attr.m_minSize) : (const wxTextAttrSize*) NULL);
11861     m_maxSize.Apply(attr.m_maxSize, compareWith ? (& attr.m_maxSize) : (const wxTextAttrSize*) NULL);
11862
11863     m_border.Apply(attr.m_border, compareWith ? (& attr.m_border) : (const wxTextAttrBorders*) NULL);
11864     m_outline.Apply(attr.m_outline, compareWith ? (& attr.m_outline) : (const wxTextAttrBorders*) NULL);
11865
11866     return true;
11867 }
11868
11869 // Remove specified attributes from this object
11870 bool wxTextBoxAttr::RemoveStyle(const wxTextBoxAttr& attr)
11871 {
11872     if (attr.HasFloatMode())
11873         RemoveFlag(wxTEXT_BOX_ATTR_FLOAT);
11874
11875     if (attr.HasClearMode())
11876         RemoveFlag(wxTEXT_BOX_ATTR_CLEAR);
11877
11878     if (attr.HasCollapseBorders())
11879         RemoveFlag(wxTEXT_BOX_ATTR_COLLAPSE_BORDERS);
11880
11881     if (attr.HasVerticalAlignment())
11882         RemoveFlag(wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT);
11883
11884     if (attr.HasBoxStyleName())
11885     {
11886         SetBoxStyleName(wxEmptyString);
11887         RemoveFlag(wxTEXT_BOX_ATTR_BOX_STYLE_NAME);
11888     }
11889
11890     m_margins.RemoveStyle(attr.m_margins);
11891     m_padding.RemoveStyle(attr.m_padding);
11892     m_position.RemoveStyle(attr.m_position);
11893
11894     m_size.RemoveStyle(attr.m_size);
11895     m_minSize.RemoveStyle(attr.m_minSize);
11896     m_maxSize.RemoveStyle(attr.m_maxSize);
11897
11898     m_border.RemoveStyle(attr.m_border);
11899     m_outline.RemoveStyle(attr.m_outline);
11900
11901     return true;
11902 }
11903
11904 // Collects the attributes that are common to a range of content, building up a note of
11905 // which attributes are absent in some objects and which clash in some objects.
11906 void wxTextBoxAttr::CollectCommonAttributes(const wxTextBoxAttr& attr, wxTextBoxAttr& clashingAttr, wxTextBoxAttr& absentAttr)
11907 {
11908     if (attr.HasFloatMode())
11909     {
11910         if (!clashingAttr.HasFloatMode() && !absentAttr.HasFloatMode())
11911         {
11912             if (HasFloatMode())
11913             {
11914                 if (GetFloatMode() != attr.GetFloatMode())
11915                 {
11916                     clashingAttr.AddFlag(wxTEXT_BOX_ATTR_FLOAT);
11917                     RemoveFlag(wxTEXT_BOX_ATTR_FLOAT);
11918                 }
11919             }
11920             else
11921                 SetFloatMode(attr.GetFloatMode());
11922         }
11923     }
11924     else
11925         absentAttr.AddFlag(wxTEXT_BOX_ATTR_FLOAT);
11926
11927     if (attr.HasClearMode())
11928     {
11929         if (!clashingAttr.HasClearMode() && !absentAttr.HasClearMode())
11930         {
11931             if (HasClearMode())
11932             {
11933                 if (GetClearMode() != attr.GetClearMode())
11934                 {
11935                     clashingAttr.AddFlag(wxTEXT_BOX_ATTR_CLEAR);
11936                     RemoveFlag(wxTEXT_BOX_ATTR_CLEAR);
11937                 }
11938             }
11939             else
11940                 SetClearMode(attr.GetClearMode());
11941         }
11942     }
11943     else
11944         absentAttr.AddFlag(wxTEXT_BOX_ATTR_CLEAR);
11945
11946     if (attr.HasCollapseBorders())
11947     {
11948         if (!clashingAttr.HasCollapseBorders() && !absentAttr.HasCollapseBorders())
11949         {
11950             if (HasCollapseBorders())
11951             {
11952                 if (GetCollapseBorders() != attr.GetCollapseBorders())
11953                 {
11954                     clashingAttr.AddFlag(wxTEXT_BOX_ATTR_COLLAPSE_BORDERS);
11955                     RemoveFlag(wxTEXT_BOX_ATTR_COLLAPSE_BORDERS);
11956                 }
11957             }
11958             else
11959                 SetCollapseBorders(attr.GetCollapseBorders());
11960         }
11961     }
11962     else
11963         absentAttr.AddFlag(wxTEXT_BOX_ATTR_COLLAPSE_BORDERS);
11964
11965     if (attr.HasVerticalAlignment())
11966     {
11967         if (!clashingAttr.HasVerticalAlignment() && !absentAttr.HasVerticalAlignment())
11968         {
11969             if (HasVerticalAlignment())
11970             {
11971                 if (GetVerticalAlignment() != attr.GetVerticalAlignment())
11972                 {
11973                     clashingAttr.AddFlag(wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT);
11974                     RemoveFlag(wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT);
11975                 }
11976             }
11977             else
11978                 SetVerticalAlignment(attr.GetVerticalAlignment());
11979         }
11980     }
11981     else
11982         absentAttr.AddFlag(wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT);
11983
11984     if (attr.HasBoxStyleName())
11985     {
11986         if (!clashingAttr.HasBoxStyleName() && !absentAttr.HasBoxStyleName())
11987         {
11988             if (HasBoxStyleName())
11989             {
11990                 if (GetBoxStyleName() != attr.GetBoxStyleName())
11991                 {
11992                     clashingAttr.AddFlag(wxTEXT_BOX_ATTR_BOX_STYLE_NAME);
11993                     RemoveFlag(wxTEXT_BOX_ATTR_BOX_STYLE_NAME);
11994                 }
11995             }
11996             else
11997                 SetBoxStyleName(attr.GetBoxStyleName());
11998         }
11999     }
12000     else
12001         absentAttr.AddFlag(wxTEXT_BOX_ATTR_BOX_STYLE_NAME);
12002
12003     m_margins.CollectCommonAttributes(attr.m_margins, clashingAttr.m_margins, absentAttr.m_margins);
12004     m_padding.CollectCommonAttributes(attr.m_padding, clashingAttr.m_padding, absentAttr.m_padding);
12005     m_position.CollectCommonAttributes(attr.m_position, clashingAttr.m_position, absentAttr.m_position);
12006
12007     m_size.CollectCommonAttributes(attr.m_size, clashingAttr.m_size, absentAttr.m_size);
12008     m_minSize.CollectCommonAttributes(attr.m_minSize, clashingAttr.m_minSize, absentAttr.m_minSize);
12009     m_maxSize.CollectCommonAttributes(attr.m_maxSize, clashingAttr.m_maxSize, absentAttr.m_maxSize);
12010
12011     m_border.CollectCommonAttributes(attr.m_border, clashingAttr.m_border, absentAttr.m_border);
12012     m_outline.CollectCommonAttributes(attr.m_outline, clashingAttr.m_outline, absentAttr.m_outline);
12013 }
12014
12015 bool wxTextBoxAttr::IsDefault() const
12016 {
12017     return GetFlags() == 0 && !m_border.IsValid() && !m_outline.IsValid() &&
12018         !m_size.IsValid() && !m_minSize.IsValid() && !m_maxSize.IsValid() &&
12019         !m_position.IsValid() && !m_padding.IsValid() && !m_margins.IsValid();
12020 }
12021
12022 // wxRichTextAttr
12023
12024 void wxRichTextAttr::Copy(const wxRichTextAttr& attr)
12025 {
12026     wxTextAttr::Copy(attr);
12027
12028     m_textBoxAttr = attr.m_textBoxAttr;
12029 }
12030
12031 bool wxRichTextAttr::operator==(const wxRichTextAttr& attr) const
12032 {
12033     if (!(wxTextAttr::operator==(attr)))
12034         return false;
12035
12036     return (m_textBoxAttr == attr.m_textBoxAttr);
12037 }
12038
12039 // Partial equality test
12040 bool wxRichTextAttr::EqPartial(const wxRichTextAttr& attr, bool weakTest) const
12041 {
12042     if (!(wxTextAttr::EqPartial(attr, weakTest)))
12043         return false;
12044
12045     return m_textBoxAttr.EqPartial(attr.m_textBoxAttr, weakTest);
12046 }
12047
12048 // Merges the given attributes. If compareWith
12049 // is non-NULL, then it will be used to mask out those attributes that are the same in style
12050 // and compareWith, for situations where we don't want to explicitly set inherited attributes.
12051 bool wxRichTextAttr::Apply(const wxRichTextAttr& style, const wxRichTextAttr* compareWith)
12052 {
12053     wxTextAttr::Apply(style, compareWith);
12054
12055     return m_textBoxAttr.Apply(style.m_textBoxAttr, compareWith ? (& compareWith->m_textBoxAttr) : (const wxTextBoxAttr*) NULL);
12056 }
12057
12058 // Remove specified attributes from this object
12059 bool wxRichTextAttr::RemoveStyle(const wxRichTextAttr& attr)
12060 {
12061     wxTextAttr::RemoveStyle(*this, attr);
12062
12063     return m_textBoxAttr.RemoveStyle(attr.m_textBoxAttr);
12064 }
12065
12066 // Collects the attributes that are common to a range of content, building up a note of
12067 // which attributes are absent in some objects and which clash in some objects.
12068 void wxRichTextAttr::CollectCommonAttributes(const wxRichTextAttr& attr, wxRichTextAttr& clashingAttr, wxRichTextAttr& absentAttr)
12069 {
12070     wxTextAttrCollectCommonAttributes(*this, attr, clashingAttr, absentAttr);
12071
12072     m_textBoxAttr.CollectCommonAttributes(attr.m_textBoxAttr, clashingAttr.m_textBoxAttr, absentAttr.m_textBoxAttr);
12073 }
12074
12075 // Partial equality test
12076 bool wxTextAttrBorder::EqPartial(const wxTextAttrBorder& border, bool weakTest) const
12077 {
12078     if (!weakTest &&
12079         ((!HasStyle() && border.HasStyle()) ||
12080          (!HasColour() && border.HasColour()) ||
12081          (!HasWidth() && border.HasWidth())))
12082     {
12083         return false;
12084     }
12085
12086     if (border.HasStyle() && HasStyle() && (border.GetStyle() != GetStyle()))
12087         return false;
12088
12089     if (border.HasColour() && HasColour() && (border.GetColourLong() != GetColourLong()))
12090         return false;
12091
12092     if (border.HasWidth() && HasWidth() && !(border.GetWidth() == GetWidth()))
12093         return false;
12094
12095     return true;
12096 }
12097
12098 // Apply border to 'this', but not if the same as compareWith
12099 bool wxTextAttrBorder::Apply(const wxTextAttrBorder& border, const wxTextAttrBorder* compareWith)
12100 {
12101     if (border.HasStyle())
12102     {
12103         if (!(compareWith && (border.GetStyle() == compareWith->GetStyle())))
12104             SetStyle(border.GetStyle());
12105     }
12106     if (border.HasColour())
12107     {
12108         if (!(compareWith && (border.GetColourLong() == compareWith->GetColourLong())))
12109             SetColour(border.GetColourLong());
12110     }
12111     if (border.HasWidth())
12112     {
12113         if (!(compareWith && (border.GetWidth() == compareWith->GetWidth())))
12114             SetWidth(border.GetWidth());
12115     }
12116
12117     return true;
12118 }
12119
12120 // Remove specified attributes from this object
12121 bool wxTextAttrBorder::RemoveStyle(const wxTextAttrBorder& attr)
12122 {
12123     if (attr.HasStyle() && HasStyle())
12124         SetFlags(GetFlags() & ~wxTEXT_BOX_ATTR_BORDER_STYLE);
12125     if (attr.HasColour() && HasColour())
12126         SetFlags(GetFlags() & ~wxTEXT_BOX_ATTR_BORDER_COLOUR);
12127     if (attr.HasWidth() && HasWidth())
12128         m_borderWidth.Reset();
12129
12130     return true;
12131 }
12132
12133 // Collects the attributes that are common to a range of content, building up a note of
12134 // which attributes are absent in some objects and which clash in some objects.
12135 void wxTextAttrBorder::CollectCommonAttributes(const wxTextAttrBorder& attr, wxTextAttrBorder& clashingAttr, wxTextAttrBorder& absentAttr)
12136 {
12137     if (attr.HasStyle())
12138     {
12139         if (!clashingAttr.HasStyle() && !absentAttr.HasStyle())
12140         {
12141             if (HasStyle())
12142             {
12143                 if (GetStyle() != attr.GetStyle())
12144                 {
12145                     clashingAttr.AddFlag(wxTEXT_BOX_ATTR_BORDER_STYLE);
12146                     RemoveFlag(wxTEXT_BOX_ATTR_BORDER_STYLE);
12147                 }
12148             }
12149             else
12150                 SetStyle(attr.GetStyle());
12151         }
12152     }
12153     else
12154         absentAttr.AddFlag(wxTEXT_BOX_ATTR_BORDER_STYLE);
12155
12156     if (attr.HasColour())
12157     {
12158         if (!clashingAttr.HasColour() && !absentAttr.HasColour())
12159         {
12160             if (HasColour())
12161             {
12162                 if (GetColour() != attr.GetColour())
12163                 {
12164                     clashingAttr.AddFlag(wxTEXT_BOX_ATTR_BORDER_COLOUR);
12165                     RemoveFlag(wxTEXT_BOX_ATTR_BORDER_COLOUR);
12166                 }
12167             }
12168             else
12169                 SetColour(attr.GetColourLong());
12170         }
12171     }
12172     else
12173         absentAttr.AddFlag(wxTEXT_BOX_ATTR_BORDER_COLOUR);
12174
12175     m_borderWidth.CollectCommonAttributes(attr.m_borderWidth, clashingAttr.m_borderWidth, absentAttr.m_borderWidth);
12176 }
12177
12178 // Partial equality test
12179 bool wxTextAttrBorders::EqPartial(const wxTextAttrBorders& borders, bool weakTest) const
12180 {
12181     return m_left.EqPartial(borders.m_left, weakTest) && m_right.EqPartial(borders.m_right, weakTest) &&
12182             m_top.EqPartial(borders.m_top, weakTest) && m_bottom.EqPartial(borders.m_bottom, weakTest);
12183 }
12184
12185 // Apply border to 'this', but not if the same as compareWith
12186 bool wxTextAttrBorders::Apply(const wxTextAttrBorders& borders, const wxTextAttrBorders* compareWith)
12187 {
12188     m_left.Apply(borders.m_left, compareWith ? (& compareWith->m_left) : (const wxTextAttrBorder*) NULL);
12189     m_right.Apply(borders.m_right, compareWith ? (& compareWith->m_right) : (const wxTextAttrBorder*) NULL);
12190     m_top.Apply(borders.m_top, compareWith ? (& compareWith->m_top) : (const wxTextAttrBorder*) NULL);
12191     m_bottom.Apply(borders.m_bottom, compareWith ? (& compareWith->m_bottom) : (const wxTextAttrBorder*) NULL);
12192     return true;
12193 }
12194
12195 // Remove specified attributes from this object
12196 bool wxTextAttrBorders::RemoveStyle(const wxTextAttrBorders& attr)
12197 {
12198     m_left.RemoveStyle(attr.m_left);
12199     m_right.RemoveStyle(attr.m_right);
12200     m_top.RemoveStyle(attr.m_top);
12201     m_bottom.RemoveStyle(attr.m_bottom);
12202     return true;
12203 }
12204
12205 // Collects the attributes that are common to a range of content, building up a note of
12206 // which attributes are absent in some objects and which clash in some objects.
12207 void wxTextAttrBorders::CollectCommonAttributes(const wxTextAttrBorders& attr, wxTextAttrBorders& clashingAttr, wxTextAttrBorders& absentAttr)
12208 {
12209     m_left.CollectCommonAttributes(attr.m_left, clashingAttr.m_left, absentAttr.m_left);
12210     m_right.CollectCommonAttributes(attr.m_right, clashingAttr.m_right, absentAttr.m_right);
12211     m_top.CollectCommonAttributes(attr.m_top, clashingAttr.m_top, absentAttr.m_top);
12212     m_bottom.CollectCommonAttributes(attr.m_bottom, clashingAttr.m_bottom, absentAttr.m_bottom);
12213 }
12214
12215 // Set style of all borders
12216 void wxTextAttrBorders::SetStyle(int style)
12217 {
12218     m_left.SetStyle(style);
12219     m_right.SetStyle(style);
12220     m_top.SetStyle(style);
12221     m_bottom.SetStyle(style);
12222 }
12223
12224 // Set colour of all borders
12225 void wxTextAttrBorders::SetColour(unsigned long colour)
12226 {
12227     m_left.SetColour(colour);
12228     m_right.SetColour(colour);
12229     m_top.SetColour(colour);
12230     m_bottom.SetColour(colour);
12231 }
12232
12233 void wxTextAttrBorders::SetColour(const wxColour& colour)
12234 {
12235     m_left.SetColour(colour);
12236     m_right.SetColour(colour);
12237     m_top.SetColour(colour);
12238     m_bottom.SetColour(colour);
12239 }
12240
12241 // Set width of all borders
12242 void wxTextAttrBorders::SetWidth(const wxTextAttrDimension& width)
12243 {
12244     m_left.SetWidth(width);
12245     m_right.SetWidth(width);
12246     m_top.SetWidth(width);
12247     m_bottom.SetWidth(width);
12248 }
12249
12250 // Partial equality test
12251 bool wxTextAttrDimension::EqPartial(const wxTextAttrDimension& dim, bool weakTest) const
12252 {
12253     if (!weakTest && !IsValid() && dim.IsValid())
12254         return false;
12255
12256     if (dim.IsValid() && IsValid() && !((*this) == dim))
12257         return false;
12258     else
12259         return true;
12260 }
12261
12262 bool wxTextAttrDimension::Apply(const wxTextAttrDimension& dim, const wxTextAttrDimension* compareWith)
12263 {
12264     if (dim.IsValid())
12265     {
12266         if (!(compareWith && dim == (*compareWith)))
12267             (*this) = dim;
12268     }
12269
12270     return true;
12271 }
12272
12273 // Collects the attributes that are common to a range of content, building up a note of
12274 // which attributes are absent in some objects and which clash in some objects.
12275 void wxTextAttrDimension::CollectCommonAttributes(const wxTextAttrDimension& attr, wxTextAttrDimension& clashingAttr, wxTextAttrDimension& absentAttr)
12276 {
12277     if (attr.IsValid())
12278     {
12279         if (!clashingAttr.IsValid() && !absentAttr.IsValid())
12280         {
12281             if (IsValid())
12282             {
12283                 if (!((*this) == attr))
12284                 {
12285                     clashingAttr.SetValid(true);
12286                     SetValid(false);
12287                 }
12288             }
12289             else
12290                 (*this) = attr;
12291         }
12292     }
12293     else
12294         absentAttr.SetValid(true);
12295 }
12296
12297 wxTextAttrDimensionConverter::wxTextAttrDimensionConverter(wxDC& dc, double scale, const wxSize& parentSize)
12298 {
12299     m_ppi = dc.GetPPI().x; m_scale = scale; m_parentSize = parentSize;
12300 }
12301
12302 wxTextAttrDimensionConverter::wxTextAttrDimensionConverter(int ppi, double scale, const wxSize& parentSize)
12303 {
12304     m_ppi = ppi; m_scale = scale; m_parentSize = parentSize;
12305 }
12306
12307 int wxTextAttrDimensionConverter::ConvertTenthsMMToPixels(int units) const
12308 {
12309     return wxRichTextObject::ConvertTenthsMMToPixels(m_ppi, units, m_scale);
12310 }
12311
12312 int wxTextAttrDimensionConverter::ConvertPixelsToTenthsMM(int pixels) const
12313 {
12314     return wxRichTextObject::ConvertPixelsToTenthsMM(m_ppi, pixels, m_scale);
12315 }
12316
12317 int wxTextAttrDimensionConverter::GetPixels(const wxTextAttrDimension& dim, int direction) const
12318 {
12319     if (dim.GetUnits() == wxTEXT_ATTR_UNITS_TENTHS_MM)
12320         return ConvertTenthsMMToPixels(dim.GetValue());
12321     else if (dim.GetUnits() == wxTEXT_ATTR_UNITS_PIXELS)
12322         return dim.GetValue();
12323     else if (dim.GetUnits() == wxTEXT_ATTR_UNITS_PERCENTAGE)
12324     {
12325         wxASSERT(m_parentSize != wxDefaultSize);
12326         if (direction == wxHORIZONTAL)
12327             return (int) (double(m_parentSize.x) * double(dim.GetValue()) / 100.0);
12328         else
12329             return (int) (double(m_parentSize.y) * double(dim.GetValue()) / 100.0);
12330     }
12331     else
12332     {
12333         wxASSERT(false);
12334         return 0;
12335     }
12336 }
12337
12338 int wxTextAttrDimensionConverter::GetTenthsMM(const wxTextAttrDimension& dim) const
12339 {
12340     if (dim.GetUnits() == wxTEXT_ATTR_UNITS_TENTHS_MM)
12341         return dim.GetValue();
12342     else if (dim.GetUnits() == wxTEXT_ATTR_UNITS_PIXELS)
12343         return ConvertPixelsToTenthsMM(dim.GetValue());
12344     else
12345     {
12346         wxASSERT(false);
12347         return 0;
12348     }
12349 }
12350
12351 // Partial equality test
12352 bool wxTextAttrDimensions::EqPartial(const wxTextAttrDimensions& dims, bool weakTest) const
12353 {
12354     if (!m_left.EqPartial(dims.m_left, weakTest))
12355         return false;
12356
12357     if (!m_right.EqPartial(dims.m_right, weakTest))
12358         return false;
12359
12360     if (!m_top.EqPartial(dims.m_top, weakTest))
12361         return false;
12362
12363     if (!m_bottom.EqPartial(dims.m_bottom, weakTest))
12364         return false;
12365
12366     return true;
12367 }
12368
12369 // Apply border to 'this', but not if the same as compareWith
12370 bool wxTextAttrDimensions::Apply(const wxTextAttrDimensions& dims, const wxTextAttrDimensions* compareWith)
12371 {
12372     m_left.Apply(dims.m_left, compareWith ? (& compareWith->m_left) : (const wxTextAttrDimension*) NULL);
12373     m_right.Apply(dims.m_right, compareWith ? (& compareWith->m_right): (const wxTextAttrDimension*) NULL);
12374     m_top.Apply(dims.m_top, compareWith ? (& compareWith->m_top): (const wxTextAttrDimension*) NULL);
12375     m_bottom.Apply(dims.m_bottom, compareWith ? (& compareWith->m_bottom): (const wxTextAttrDimension*) NULL);
12376
12377     return true;
12378 }
12379
12380 // Remove specified attributes from this object
12381 bool wxTextAttrDimensions::RemoveStyle(const wxTextAttrDimensions& attr)
12382 {
12383     if (attr.m_left.IsValid())
12384         m_left.Reset();
12385     if (attr.m_right.IsValid())
12386         m_right.Reset();
12387     if (attr.m_top.IsValid())
12388         m_top.Reset();
12389     if (attr.m_bottom.IsValid())
12390         m_bottom.Reset();
12391
12392     return true;
12393 }
12394
12395 // Collects the attributes that are common to a range of content, building up a note of
12396 // which attributes are absent in some objects and which clash in some objects.
12397 void wxTextAttrDimensions::CollectCommonAttributes(const wxTextAttrDimensions& attr, wxTextAttrDimensions& clashingAttr, wxTextAttrDimensions& absentAttr)
12398 {
12399     m_left.CollectCommonAttributes(attr.m_left, clashingAttr.m_left, absentAttr.m_left);
12400     m_right.CollectCommonAttributes(attr.m_right, clashingAttr.m_right, absentAttr.m_right);
12401     m_top.CollectCommonAttributes(attr.m_top, clashingAttr.m_top, absentAttr.m_top);
12402     m_bottom.CollectCommonAttributes(attr.m_bottom, clashingAttr.m_bottom, absentAttr.m_bottom);
12403 }
12404
12405 // Partial equality test
12406 bool wxTextAttrSize::EqPartial(const wxTextAttrSize& size, bool weakTest) const
12407 {
12408     if (!m_width.EqPartial(size.m_width, weakTest))
12409         return false;
12410
12411     if (!m_height.EqPartial(size.m_height, weakTest))
12412         return false;
12413
12414     return true;
12415 }
12416
12417 // Apply border to 'this', but not if the same as compareWith
12418 bool wxTextAttrSize::Apply(const wxTextAttrSize& size, const wxTextAttrSize* compareWith)
12419 {
12420     m_width.Apply(size.m_width, compareWith ? (& compareWith->m_width) : (const wxTextAttrDimension*) NULL);
12421     m_height.Apply(size.m_height, compareWith ? (& compareWith->m_height): (const wxTextAttrDimension*) NULL);
12422
12423     return true;
12424 }
12425
12426 // Remove specified attributes from this object
12427 bool wxTextAttrSize::RemoveStyle(const wxTextAttrSize& attr)
12428 {
12429     if (attr.m_width.IsValid())
12430         m_width.Reset();
12431     if (attr.m_height.IsValid())
12432         m_height.Reset();
12433
12434     return true;
12435 }
12436
12437 // Collects the attributes that are common to a range of content, building up a note of
12438 // which attributes are absent in some objects and which clash in some objects.
12439 void wxTextAttrSize::CollectCommonAttributes(const wxTextAttrSize& attr, wxTextAttrSize& clashingAttr, wxTextAttrSize& absentAttr)
12440 {
12441     m_width.CollectCommonAttributes(attr.m_width, clashingAttr.m_width, absentAttr.m_width);
12442     m_height.CollectCommonAttributes(attr.m_height, clashingAttr.m_height, absentAttr.m_height);
12443 }
12444
12445 // Collects the attributes that are common to a range of content, building up a note of
12446 // which attributes are absent in some objects and which clash in some objects.
12447 void wxTextAttrCollectCommonAttributes(wxTextAttr& currentStyle, const wxTextAttr& attr, wxTextAttr& clashingAttr, wxTextAttr& absentAttr)
12448 {
12449     absentAttr.SetFlags(absentAttr.GetFlags() | (~attr.GetFlags() & wxTEXT_ATTR_ALL));
12450     absentAttr.SetTextEffectFlags(absentAttr.GetTextEffectFlags() | (~attr.GetTextEffectFlags() & 0xFFFF));
12451
12452     long forbiddenFlags = clashingAttr.GetFlags()|absentAttr.GetFlags();
12453
12454     if (attr.HasFont())
12455     {
12456         // If different font size units are being used, this is a clash.
12457         if (((attr.GetFlags() & wxTEXT_ATTR_FONT_SIZE) | (currentStyle.GetFlags() & wxTEXT_ATTR_FONT_SIZE)) == wxTEXT_ATTR_FONT_SIZE)
12458         {
12459             currentStyle.SetFontSize(0);
12460             currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_SIZE);
12461             clashingAttr.AddFlag(wxTEXT_ATTR_FONT_SIZE);
12462         }
12463         else
12464         {
12465             if (attr.HasFontPointSize() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_POINT_SIZE))
12466             {
12467                 if (currentStyle.HasFontPointSize())
12468                 {
12469                     if (currentStyle.GetFontSize() != attr.GetFontSize())
12470                     {
12471                         // Clash of attr - mark as such
12472                         clashingAttr.AddFlag(wxTEXT_ATTR_FONT_POINT_SIZE);
12473                         currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_POINT_SIZE);
12474                     }
12475                 }
12476                 else
12477                     currentStyle.SetFontSize(attr.GetFontSize());
12478             }
12479
12480             if (attr.HasFontPixelSize() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_PIXEL_SIZE))
12481             {
12482                 if (currentStyle.HasFontPixelSize())
12483                 {
12484                     if (currentStyle.GetFontSize() != attr.GetFontSize())
12485                     {
12486                         // Clash of attr - mark as such
12487                         clashingAttr.AddFlag(wxTEXT_ATTR_FONT_PIXEL_SIZE);
12488                         currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_PIXEL_SIZE);
12489                     }
12490                 }
12491                 else
12492                     currentStyle.SetFontPixelSize(attr.GetFontSize());
12493             }
12494         }
12495
12496         if (attr.HasFontItalic() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_ITALIC))
12497         {
12498             if (currentStyle.HasFontItalic())
12499             {
12500                 if (currentStyle.GetFontStyle() != attr.GetFontStyle())
12501                 {
12502                     // Clash of attr - mark as such
12503                     clashingAttr.AddFlag(wxTEXT_ATTR_FONT_ITALIC);
12504                     currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_ITALIC);
12505                 }
12506             }
12507             else
12508                 currentStyle.SetFontStyle(attr.GetFontStyle());
12509         }
12510
12511         if (attr.HasFontFamily() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_FAMILY))
12512         {
12513             if (currentStyle.HasFontFamily())
12514             {
12515                 if (currentStyle.GetFontFamily() != attr.GetFontFamily())
12516                 {
12517                     // Clash of attr - mark as such
12518                     clashingAttr.AddFlag(wxTEXT_ATTR_FONT_FAMILY);
12519                     currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_FAMILY);
12520                 }
12521             }
12522             else
12523                 currentStyle.SetFontFamily(attr.GetFontFamily());
12524         }
12525
12526         if (attr.HasFontWeight() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_WEIGHT))
12527         {
12528             if (currentStyle.HasFontWeight())
12529             {
12530                 if (currentStyle.GetFontWeight() != attr.GetFontWeight())
12531                 {
12532                     // Clash of attr - mark as such
12533                     clashingAttr.AddFlag(wxTEXT_ATTR_FONT_WEIGHT);
12534                     currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_WEIGHT);
12535                 }
12536             }
12537             else
12538                 currentStyle.SetFontWeight(attr.GetFontWeight());
12539         }
12540
12541         if (attr.HasFontFaceName() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_FACE))
12542         {
12543             if (currentStyle.HasFontFaceName())
12544             {
12545                 wxString faceName1(currentStyle.GetFontFaceName());
12546                 wxString faceName2(attr.GetFontFaceName());
12547
12548                 if (faceName1 != faceName2)
12549                 {
12550                     // Clash of attr - mark as such
12551                     clashingAttr.AddFlag(wxTEXT_ATTR_FONT_FACE);
12552                     currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_FACE);
12553                 }
12554             }
12555             else
12556                 currentStyle.SetFontFaceName(attr.GetFontFaceName());
12557         }
12558
12559         if (attr.HasFontUnderlined() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_UNDERLINE))
12560         {
12561             if (currentStyle.HasFontUnderlined())
12562             {
12563                 if (currentStyle.GetFontUnderlined() != attr.GetFontUnderlined())
12564                 {
12565                     // Clash of attr - mark as such
12566                     clashingAttr.AddFlag(wxTEXT_ATTR_FONT_UNDERLINE);
12567                     currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_UNDERLINE);
12568                 }
12569             }
12570             else
12571                 currentStyle.SetFontUnderlined(attr.GetFontUnderlined());
12572         }
12573
12574         if (attr.HasFontStrikethrough() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_STRIKETHROUGH))
12575         {
12576             if (currentStyle.HasFontStrikethrough())
12577             {
12578                 if (currentStyle.GetFontStrikethrough() != attr.GetFontStrikethrough())
12579                 {
12580                     // Clash of attr - mark as such
12581                     clashingAttr.AddFlag(wxTEXT_ATTR_FONT_STRIKETHROUGH);
12582                     currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_STRIKETHROUGH);
12583                 }
12584             }
12585             else
12586                 currentStyle.SetFontStrikethrough(attr.GetFontStrikethrough());
12587         }
12588     }
12589
12590     if (attr.HasTextColour() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_TEXT_COLOUR))
12591     {
12592         if (currentStyle.HasTextColour())
12593         {
12594             if (currentStyle.GetTextColour() != attr.GetTextColour())
12595             {
12596                 // Clash of attr - mark as such
12597                 clashingAttr.AddFlag(wxTEXT_ATTR_TEXT_COLOUR);
12598                 currentStyle.RemoveFlag(wxTEXT_ATTR_TEXT_COLOUR);
12599             }
12600         }
12601         else
12602             currentStyle.SetTextColour(attr.GetTextColour());
12603     }
12604
12605     if (attr.HasBackgroundColour() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_BACKGROUND_COLOUR))
12606     {
12607         if (currentStyle.HasBackgroundColour())
12608         {
12609             if (currentStyle.GetBackgroundColour() != attr.GetBackgroundColour())
12610             {
12611                 // Clash of attr - mark as such
12612                 clashingAttr.AddFlag(wxTEXT_ATTR_BACKGROUND_COLOUR);
12613                 currentStyle.RemoveFlag(wxTEXT_ATTR_BACKGROUND_COLOUR);
12614             }
12615         }
12616         else
12617             currentStyle.SetBackgroundColour(attr.GetBackgroundColour());
12618     }
12619
12620     if (attr.HasAlignment() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_ALIGNMENT))
12621     {
12622         if (currentStyle.HasAlignment())
12623         {
12624             if (currentStyle.GetAlignment() != attr.GetAlignment())
12625             {
12626                 // Clash of attr - mark as such
12627                 clashingAttr.AddFlag(wxTEXT_ATTR_ALIGNMENT);
12628                 currentStyle.RemoveFlag(wxTEXT_ATTR_ALIGNMENT);
12629             }
12630         }
12631         else
12632             currentStyle.SetAlignment(attr.GetAlignment());
12633     }
12634
12635     if (attr.HasTabs() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_TABS))
12636     {
12637         if (currentStyle.HasTabs())
12638         {
12639             if (!wxRichTextTabsEq(currentStyle.GetTabs(), attr.GetTabs()))
12640             {
12641                 // Clash of attr - mark as such
12642                 clashingAttr.AddFlag(wxTEXT_ATTR_TABS);
12643                 currentStyle.RemoveFlag(wxTEXT_ATTR_TABS);
12644             }
12645         }
12646         else
12647             currentStyle.SetTabs(attr.GetTabs());
12648     }
12649
12650     if (attr.HasLeftIndent() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_LEFT_INDENT))
12651     {
12652         if (currentStyle.HasLeftIndent())
12653         {
12654             if (currentStyle.GetLeftIndent() != attr.GetLeftIndent() || currentStyle.GetLeftSubIndent() != attr.GetLeftSubIndent())
12655             {
12656                 // Clash of attr - mark as such
12657                 clashingAttr.AddFlag(wxTEXT_ATTR_LEFT_INDENT);
12658                 currentStyle.RemoveFlag(wxTEXT_ATTR_LEFT_INDENT);
12659             }
12660         }
12661         else
12662             currentStyle.SetLeftIndent(attr.GetLeftIndent(), attr.GetLeftSubIndent());
12663     }
12664
12665     if (attr.HasRightIndent() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_RIGHT_INDENT))
12666     {
12667         if (currentStyle.HasRightIndent())
12668         {
12669             if (currentStyle.GetRightIndent() != attr.GetRightIndent())
12670             {
12671                 // Clash of attr - mark as such
12672                 clashingAttr.AddFlag(wxTEXT_ATTR_RIGHT_INDENT);
12673                 currentStyle.RemoveFlag(wxTEXT_ATTR_RIGHT_INDENT);
12674             }
12675         }
12676         else
12677             currentStyle.SetRightIndent(attr.GetRightIndent());
12678     }
12679
12680     if (attr.HasParagraphSpacingAfter() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_PARA_SPACING_AFTER))
12681     {
12682         if (currentStyle.HasParagraphSpacingAfter())
12683         {
12684             if (currentStyle.GetParagraphSpacingAfter() != attr.GetParagraphSpacingAfter())
12685             {
12686                 // Clash of attr - mark as such
12687                 clashingAttr.AddFlag(wxTEXT_ATTR_PARA_SPACING_AFTER);
12688                 currentStyle.RemoveFlag(wxTEXT_ATTR_PARA_SPACING_AFTER);
12689             }
12690         }
12691         else
12692             currentStyle.SetParagraphSpacingAfter(attr.GetParagraphSpacingAfter());
12693     }
12694
12695     if (attr.HasParagraphSpacingBefore() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_PARA_SPACING_BEFORE))
12696     {
12697         if (currentStyle.HasParagraphSpacingBefore())
12698         {
12699             if (currentStyle.GetParagraphSpacingBefore() != attr.GetParagraphSpacingBefore())
12700             {
12701                 // Clash of attr - mark as such
12702                 clashingAttr.AddFlag(wxTEXT_ATTR_PARA_SPACING_BEFORE);
12703                 currentStyle.RemoveFlag(wxTEXT_ATTR_PARA_SPACING_BEFORE);
12704             }
12705         }
12706         else
12707             currentStyle.SetParagraphSpacingBefore(attr.GetParagraphSpacingBefore());
12708     }
12709
12710     if (attr.HasLineSpacing() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_LINE_SPACING))
12711     {
12712         if (currentStyle.HasLineSpacing())
12713         {
12714             if (currentStyle.GetLineSpacing() != attr.GetLineSpacing())
12715             {
12716                 // Clash of attr - mark as such
12717                 clashingAttr.AddFlag(wxTEXT_ATTR_LINE_SPACING);
12718                 currentStyle.RemoveFlag(wxTEXT_ATTR_LINE_SPACING);
12719             }
12720         }
12721         else
12722             currentStyle.SetLineSpacing(attr.GetLineSpacing());
12723     }
12724
12725     if (attr.HasCharacterStyleName() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_CHARACTER_STYLE_NAME))
12726     {
12727         if (currentStyle.HasCharacterStyleName())
12728         {
12729             if (currentStyle.GetCharacterStyleName() != attr.GetCharacterStyleName())
12730             {
12731                 // Clash of attr - mark as such
12732                 clashingAttr.AddFlag(wxTEXT_ATTR_CHARACTER_STYLE_NAME);
12733                 currentStyle.RemoveFlag(wxTEXT_ATTR_CHARACTER_STYLE_NAME);
12734             }
12735         }
12736         else
12737             currentStyle.SetCharacterStyleName(attr.GetCharacterStyleName());
12738     }
12739
12740     if (attr.HasParagraphStyleName() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_PARAGRAPH_STYLE_NAME))
12741     {
12742         if (currentStyle.HasParagraphStyleName())
12743         {
12744             if (currentStyle.GetParagraphStyleName() != attr.GetParagraphStyleName())
12745             {
12746                 // Clash of attr - mark as such
12747                 clashingAttr.AddFlag(wxTEXT_ATTR_PARAGRAPH_STYLE_NAME);
12748                 currentStyle.RemoveFlag(wxTEXT_ATTR_PARAGRAPH_STYLE_NAME);
12749             }
12750         }
12751         else
12752             currentStyle.SetParagraphStyleName(attr.GetParagraphStyleName());
12753     }
12754
12755     if (attr.HasListStyleName() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_LIST_STYLE_NAME))
12756     {
12757         if (currentStyle.HasListStyleName())
12758         {
12759             if (currentStyle.GetListStyleName() != attr.GetListStyleName())
12760             {
12761                 // Clash of attr - mark as such
12762                 clashingAttr.AddFlag(wxTEXT_ATTR_LIST_STYLE_NAME);
12763                 currentStyle.RemoveFlag(wxTEXT_ATTR_LIST_STYLE_NAME);
12764             }
12765         }
12766         else
12767             currentStyle.SetListStyleName(attr.GetListStyleName());
12768     }
12769
12770     if (attr.HasBulletStyle() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_BULLET_STYLE))
12771     {
12772         if (currentStyle.HasBulletStyle())
12773         {
12774             if (currentStyle.GetBulletStyle() != attr.GetBulletStyle())
12775             {
12776                 // Clash of attr - mark as such
12777                 clashingAttr.AddFlag(wxTEXT_ATTR_BULLET_STYLE);
12778                 currentStyle.RemoveFlag(wxTEXT_ATTR_BULLET_STYLE);
12779             }
12780         }
12781         else
12782             currentStyle.SetBulletStyle(attr.GetBulletStyle());
12783     }
12784
12785     if (attr.HasBulletNumber() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_BULLET_NUMBER))
12786     {
12787         if (currentStyle.HasBulletNumber())
12788         {
12789             if (currentStyle.GetBulletNumber() != attr.GetBulletNumber())
12790             {
12791                 // Clash of attr - mark as such
12792                 clashingAttr.AddFlag(wxTEXT_ATTR_BULLET_NUMBER);
12793                 currentStyle.RemoveFlag(wxTEXT_ATTR_BULLET_NUMBER);
12794             }
12795         }
12796         else
12797             currentStyle.SetBulletNumber(attr.GetBulletNumber());
12798     }
12799
12800     if (attr.HasBulletText() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_BULLET_TEXT))
12801     {
12802         if (currentStyle.HasBulletText())
12803         {
12804             if (currentStyle.GetBulletText() != attr.GetBulletText())
12805             {
12806                 // Clash of attr - mark as such
12807                 clashingAttr.AddFlag(wxTEXT_ATTR_BULLET_TEXT);
12808                 currentStyle.RemoveFlag(wxTEXT_ATTR_BULLET_TEXT);
12809             }
12810         }
12811         else
12812         {
12813             currentStyle.SetBulletText(attr.GetBulletText());
12814             currentStyle.SetBulletFont(attr.GetBulletFont());
12815         }
12816     }
12817
12818     if (attr.HasBulletName() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_BULLET_NAME))
12819     {
12820         if (currentStyle.HasBulletName())
12821         {
12822             if (currentStyle.GetBulletName() != attr.GetBulletName())
12823             {
12824                 // Clash of attr - mark as such
12825                 clashingAttr.AddFlag(wxTEXT_ATTR_BULLET_NAME);
12826                 currentStyle.RemoveFlag(wxTEXT_ATTR_BULLET_NAME);
12827             }
12828         }
12829         else
12830         {
12831             currentStyle.SetBulletName(attr.GetBulletName());
12832         }
12833     }
12834
12835     if (attr.HasURL() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_URL))
12836     {
12837         if (currentStyle.HasURL())
12838         {
12839             if (currentStyle.GetURL() != attr.GetURL())
12840             {
12841                 // Clash of attr - mark as such
12842                 clashingAttr.AddFlag(wxTEXT_ATTR_URL);
12843                 currentStyle.RemoveFlag(wxTEXT_ATTR_URL);
12844             }
12845         }
12846         else
12847         {
12848             currentStyle.SetURL(attr.GetURL());
12849         }
12850     }
12851
12852     if (attr.HasTextEffects() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_EFFECTS))
12853     {
12854         if (currentStyle.HasTextEffects())
12855         {
12856             // We need to find the bits in the new attr that are different:
12857             // just look at those bits that are specified by the new attr.
12858
12859             // We need to remove the bits and flags that are not common between current attr
12860             // and new attr. In so doing we need to take account of the styles absent from one or more of the
12861             // previous styles.
12862
12863             int currentRelevantTextEffects = currentStyle.GetTextEffects() & attr.GetTextEffectFlags();
12864             int newRelevantTextEffects = attr.GetTextEffects() & attr.GetTextEffectFlags();
12865
12866             if (currentRelevantTextEffects != newRelevantTextEffects)
12867             {
12868                 // Find the text effects that were different, using XOR
12869                 int differentEffects = currentRelevantTextEffects ^ newRelevantTextEffects;
12870
12871                 // Clash of attr - mark as such
12872                 clashingAttr.SetTextEffectFlags(clashingAttr.GetTextEffectFlags() | differentEffects);
12873                 currentStyle.SetTextEffectFlags(currentStyle.GetTextEffectFlags() & ~differentEffects);
12874             }
12875         }
12876         else
12877         {
12878             currentStyle.SetTextEffects(attr.GetTextEffects());
12879             currentStyle.SetTextEffectFlags(attr.GetTextEffectFlags());
12880         }
12881
12882         // Mask out the flags and values that cannot be common because they were absent in one or more objecrs
12883         // that we've looked at so far
12884         currentStyle.SetTextEffects(currentStyle.GetTextEffects() & ~absentAttr.GetTextEffectFlags());
12885         currentStyle.SetTextEffectFlags(currentStyle.GetTextEffectFlags() & ~absentAttr.GetTextEffectFlags());
12886
12887         if (currentStyle.GetTextEffectFlags() == 0)
12888             currentStyle.RemoveFlag(wxTEXT_ATTR_EFFECTS);
12889     }
12890
12891     if (attr.HasOutlineLevel() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_OUTLINE_LEVEL))
12892     {
12893         if (currentStyle.HasOutlineLevel())
12894         {
12895             if (currentStyle.GetOutlineLevel() != attr.GetOutlineLevel())
12896             {
12897                 // Clash of attr - mark as such
12898                 clashingAttr.AddFlag(wxTEXT_ATTR_OUTLINE_LEVEL);
12899                 currentStyle.RemoveFlag(wxTEXT_ATTR_OUTLINE_LEVEL);
12900             }
12901         }
12902         else
12903             currentStyle.SetOutlineLevel(attr.GetOutlineLevel());
12904     }
12905 }
12906
12907 WX_DEFINE_OBJARRAY(wxRichTextVariantArray);
12908
12909 IMPLEMENT_DYNAMIC_CLASS(wxRichTextProperties, wxObject)
12910
12911 bool wxRichTextProperties::operator==(const wxRichTextProperties& props) const
12912 {
12913     if (m_properties.GetCount() != props.GetCount())
12914         return false;
12915
12916     size_t i;
12917     for (i = 0; i < m_properties.GetCount(); i++)
12918     {
12919         const wxVariant& var1 = m_properties[i];
12920         int idx = props.Find(var1.GetName());
12921         if (idx == -1)
12922             return false;
12923         const wxVariant& var2 = props.m_properties[idx];
12924         if (!(var1 == var2))
12925             return false;
12926     }
12927
12928     return true;
12929 }
12930
12931 wxArrayString wxRichTextProperties::GetPropertyNames() const
12932 {
12933     wxArrayString arr;
12934     size_t i;
12935     for (i = 0; i < m_properties.GetCount(); i++)
12936     {
12937         arr.Add(m_properties[i].GetName());
12938     }
12939     return arr;
12940 }
12941
12942 int wxRichTextProperties::Find(const wxString& name) const
12943 {
12944     size_t i;
12945     for (i = 0; i < m_properties.GetCount(); i++)
12946     {
12947         if (m_properties[i].GetName() == name)
12948             return (int) i;
12949     }
12950     return -1;
12951 }
12952
12953 bool wxRichTextProperties::Remove(const wxString& name)
12954 {
12955     int idx = Find(name);
12956     if (idx != -1)
12957     {
12958         m_properties.RemoveAt(idx);
12959         return true;
12960     }
12961     else
12962         return false;
12963 }
12964
12965 wxVariant* wxRichTextProperties::FindOrCreateProperty(const wxString& name)
12966 {
12967     int idx = Find(name);
12968     if (idx == wxNOT_FOUND)
12969         SetProperty(name, wxString());
12970     idx = Find(name);
12971     if (idx != wxNOT_FOUND)
12972     {
12973         return & (*this)[idx];
12974     }
12975     else
12976         return NULL;
12977 }
12978
12979 const wxVariant& wxRichTextProperties::GetProperty(const wxString& name) const
12980 {
12981     static const wxVariant nullVariant;
12982     int idx = Find(name);
12983     if (idx != -1)
12984         return m_properties[idx];
12985     else
12986         return nullVariant;
12987 }
12988
12989 wxString wxRichTextProperties::GetPropertyString(const wxString& name) const
12990 {
12991     return GetProperty(name).GetString();
12992 }
12993
12994 long wxRichTextProperties::GetPropertyLong(const wxString& name) const
12995 {
12996     return GetProperty(name).GetLong();
12997 }
12998
12999 bool wxRichTextProperties::GetPropertyBool(const wxString& name) const
13000 {
13001     return GetProperty(name).GetBool();
13002 }
13003
13004 double wxRichTextProperties::GetPropertyDouble(const wxString& name) const
13005 {
13006     return GetProperty(name).GetDouble();
13007 }
13008
13009 void wxRichTextProperties::SetProperty(const wxVariant& variant)
13010 {
13011     wxASSERT(!variant.GetName().IsEmpty());
13012
13013     int idx = Find(variant.GetName());
13014
13015     if (idx == -1)
13016         m_properties.Add(variant);
13017     else
13018         m_properties[idx] = variant;
13019 }
13020
13021 void wxRichTextProperties::SetProperty(const wxString& name, const wxVariant& variant)
13022 {
13023     int idx = Find(name);
13024     wxVariant var(variant);
13025     var.SetName(name);
13026
13027     if (idx == -1)
13028         m_properties.Add(var);
13029     else
13030         m_properties[idx] = var;
13031 }
13032
13033 void wxRichTextProperties::SetProperty(const wxString& name, const wxString& value)
13034 {
13035     SetProperty(name, wxVariant(value, name));
13036 }
13037
13038 void wxRichTextProperties::SetProperty(const wxString& name, long value)
13039 {
13040     SetProperty(name, wxVariant(value, name));
13041 }
13042
13043 void wxRichTextProperties::SetProperty(const wxString& name, double value)
13044 {
13045     SetProperty(name, wxVariant(value, name));
13046 }
13047
13048 void wxRichTextProperties::SetProperty(const wxString& name, bool value)
13049 {
13050     SetProperty(name, wxVariant(value, name));
13051 }
13052
13053 void wxRichTextProperties::RemoveProperties(const wxRichTextProperties& properties)
13054 {
13055     size_t i;
13056     for (i = 0; i < properties.GetCount(); i++)
13057     {
13058         wxString name = properties.GetProperties()[i].GetName();
13059         if (HasProperty(name))
13060             Remove(name);
13061     }
13062 }
13063
13064 void wxRichTextProperties::MergeProperties(const wxRichTextProperties& properties)
13065 {
13066     size_t i;
13067     for (i = 0; i < properties.GetCount(); i++)
13068     {
13069         SetProperty(properties.GetProperties()[i]);
13070     }
13071 }
13072
13073 wxRichTextObject* wxRichTextObjectAddress::GetObject(wxRichTextParagraphLayoutBox* topLevelContainer) const
13074 {
13075     if (m_address.GetCount() == 0)
13076         return topLevelContainer;
13077
13078     wxRichTextCompositeObject* p = topLevelContainer;
13079     size_t i = 0;
13080     while (p && i < m_address.GetCount())
13081     {
13082         int pos = m_address[i];
13083         wxASSERT(pos >= 0 && pos < (int) p->GetChildren().GetCount());
13084         if (pos < 0 || pos >= (int) p->GetChildren().GetCount())
13085             return NULL;
13086
13087         wxRichTextObject* p1 = p->GetChild(pos);
13088         if (i == (m_address.GetCount()-1))
13089             return p1;
13090
13091         p = wxDynamicCast(p1, wxRichTextCompositeObject);
13092         i ++;
13093     }
13094     return NULL;
13095 }
13096
13097 bool wxRichTextObjectAddress::Create(wxRichTextParagraphLayoutBox* topLevelContainer, wxRichTextObject* obj)
13098 {
13099     m_address.Clear();
13100
13101     if (topLevelContainer == obj)
13102         return true;
13103
13104     wxRichTextObject* o = obj;
13105     while (o)
13106     {
13107         wxRichTextCompositeObject* p = wxDynamicCast(o->GetParent(), wxRichTextCompositeObject);
13108         if (!p)
13109             return false;
13110
13111         int pos = p->GetChildren().IndexOf(o);
13112         if (pos == -1)
13113             return false;
13114
13115         m_address.Insert(pos, 0);
13116
13117         if (p == topLevelContainer)
13118             return true;
13119
13120         o = p;
13121     }
13122     return false;
13123 }
13124
13125 // Equality test
13126 bool wxRichTextSelection::operator==(const wxRichTextSelection& sel) const
13127 {
13128     if (m_container != sel.m_container)
13129         return false;
13130     if (m_ranges.GetCount() != sel.m_ranges.GetCount())
13131         return false;
13132     size_t i;
13133     for (i = 0; i < m_ranges.GetCount(); i++)
13134         if (!(m_ranges[i] == sel.m_ranges[i]))
13135             return false;
13136     return true;
13137 }
13138
13139 // Get the selections appropriate to the specified object, if any; returns wxRICHTEXT_NO_SELECTION if none
13140 // or none at the level of the object's container.
13141 wxRichTextRangeArray wxRichTextSelection::GetSelectionForObject(wxRichTextObject* obj) const
13142 {
13143     if (IsValid())
13144     {
13145         wxRichTextParagraphLayoutBox* container = obj->GetParentContainer();
13146
13147         if (container == m_container)
13148             return m_ranges;
13149
13150         container = obj->GetContainer();
13151         while (container)
13152         {
13153             if (container->GetParent())
13154             {
13155                 // If we found that our object's container is within the range of
13156                 // a selection higher up, then assume the whole original object
13157                 // is also selected.
13158                 wxRichTextParagraphLayoutBox* parentContainer = container->GetParentContainer();
13159                 if (parentContainer == m_container)
13160                 {
13161                     if (WithinSelection(container->GetRange().GetStart(), m_ranges))
13162                     {
13163                         wxRichTextRangeArray ranges;
13164                         ranges.Add(obj->GetRange());
13165                         return ranges;
13166                     }
13167                 }
13168
13169                 container = parentContainer;
13170             }
13171             else
13172             {
13173                 container = NULL;
13174                 break;
13175             }
13176         }
13177     }
13178     return wxRichTextRangeArray();
13179 }
13180
13181 // Is the given position within the selection?
13182 bool wxRichTextSelection::WithinSelection(long pos, wxRichTextObject* obj) const
13183 {
13184     if (!IsValid())
13185         return false;
13186     else
13187     {
13188         wxRichTextRangeArray selectionRanges = GetSelectionForObject(obj);
13189         return WithinSelection(pos, selectionRanges);
13190     }
13191 }
13192
13193 // Is the given position within the selection range?
13194 bool wxRichTextSelection::WithinSelection(long pos, const wxRichTextRangeArray& ranges)
13195 {
13196     size_t i;
13197     for (i = 0; i < ranges.GetCount(); i++)
13198     {
13199         const wxRichTextRange& range = ranges[i];
13200         if (pos >= range.GetStart() && pos <= range.GetEnd())
13201             return true;
13202     }
13203     return false;
13204 }
13205
13206 // Is the given range completely within the selection range?
13207 bool wxRichTextSelection::WithinSelection(const wxRichTextRange& range, const wxRichTextRangeArray& ranges)
13208 {
13209     size_t i;
13210     for (i = 0; i < ranges.GetCount(); i++)
13211     {
13212         const wxRichTextRange& eachRange = ranges[i];
13213         if (range.IsWithin(eachRange))
13214             return true;
13215     }
13216     return false;
13217 }
13218
13219 IMPLEMENT_CLASS(wxRichTextDrawingHandler, wxObject)
13220 IMPLEMENT_CLASS(wxRichTextDrawingContext, wxObject)
13221
13222 bool wxRichTextDrawingContext::HasVirtualAttributes(wxRichTextObject* obj) const
13223 {
13224     wxList::compatibility_iterator node = m_buffer->GetDrawingHandlers().GetFirst();
13225     while (node)
13226     {
13227         wxRichTextDrawingHandler *handler = (wxRichTextDrawingHandler*)node->GetData();
13228         if (handler->HasVirtualAttributes(obj))
13229             return true;
13230
13231         node = node->GetNext();
13232     }
13233     return false;
13234 }
13235
13236 wxRichTextAttr wxRichTextDrawingContext::GetVirtualAttributes(wxRichTextObject* obj) const
13237 {
13238     wxRichTextAttr attr;
13239     // We apply all handlers, so we can may combine several different attributes
13240     wxList::compatibility_iterator node = m_buffer->GetDrawingHandlers().GetFirst();
13241     while (node)
13242     {
13243         wxRichTextDrawingHandler *handler = (wxRichTextDrawingHandler*)node->GetData();
13244         if (handler->HasVirtualAttributes(obj))
13245         {
13246             bool success = handler->GetVirtualAttributes(attr, obj);
13247             wxASSERT(success);
13248             wxUnusedVar(success);
13249         }
13250
13251         node = node->GetNext();
13252     }
13253     return attr;
13254 }
13255
13256 bool wxRichTextDrawingContext::ApplyVirtualAttributes(wxRichTextAttr& attr, wxRichTextObject* obj) const
13257 {
13258     if (HasVirtualAttributes(obj))
13259     {
13260         wxRichTextAttr a(GetVirtualAttributes(obj));
13261         attr.Apply(a);
13262         return true;
13263     }
13264     else
13265         return false;
13266 }
13267
13268 /// Adds a handler to the end
13269 void wxRichTextBuffer::AddDrawingHandler(wxRichTextDrawingHandler *handler)
13270 {
13271     sm_drawingHandlers.Append(handler);
13272 }
13273
13274 /// Inserts a handler at the front
13275 void wxRichTextBuffer::InsertDrawingHandler(wxRichTextDrawingHandler *handler)
13276 {
13277     sm_drawingHandlers.Insert( handler );
13278 }
13279
13280 /// Removes a handler
13281 bool wxRichTextBuffer::RemoveDrawingHandler(const wxString& name)
13282 {
13283     wxRichTextDrawingHandler *handler = FindDrawingHandler(name);
13284     if (handler)
13285     {
13286         sm_drawingHandlers.DeleteObject(handler);
13287         delete handler;
13288         return true;
13289     }
13290     else
13291         return false;
13292 }
13293
13294 wxRichTextDrawingHandler* wxRichTextBuffer::FindDrawingHandler(const wxString& name)
13295 {
13296     wxList::compatibility_iterator node = sm_drawingHandlers.GetFirst();
13297     while (node)
13298     {
13299         wxRichTextDrawingHandler *handler = (wxRichTextDrawingHandler*)node->GetData();
13300         if (handler->GetName().Lower() == name.Lower()) return handler;
13301
13302         node = node->GetNext();
13303     }
13304     return NULL;
13305 }
13306
13307 void wxRichTextBuffer::CleanUpDrawingHandlers()
13308 {
13309     wxList::compatibility_iterator node = sm_drawingHandlers.GetFirst();
13310     while (node)
13311     {
13312         wxRichTextDrawingHandler* handler = (wxRichTextDrawingHandler*)node->GetData();
13313         wxList::compatibility_iterator next = node->GetNext();
13314         delete handler;
13315         node = next;
13316     }
13317
13318     sm_drawingHandlers.Clear();
13319 }
13320
13321 void wxRichTextBuffer::AddFieldType(wxRichTextFieldType *fieldType)
13322 {
13323     sm_fieldTypes[fieldType->GetName()] = fieldType;
13324 }
13325
13326 bool wxRichTextBuffer::RemoveFieldType(const wxString& name)
13327 {
13328     wxRichTextFieldTypeHashMap::iterator it = sm_fieldTypes.find(name);
13329     if (it == sm_fieldTypes.end())
13330         return false;
13331     else
13332     {
13333         wxRichTextFieldType* fieldType = it->second;
13334         sm_fieldTypes.erase(it);
13335         delete fieldType;
13336         return true;
13337     }
13338 }
13339
13340 wxRichTextFieldType *wxRichTextBuffer::FindFieldType(const wxString& name)
13341 {
13342     wxRichTextFieldTypeHashMap::iterator it = sm_fieldTypes.find(name);
13343     if (it == sm_fieldTypes.end())
13344         return NULL;
13345     else
13346         return it->second;
13347 }
13348
13349 void wxRichTextBuffer::CleanUpFieldTypes()
13350 {
13351     wxRichTextFieldTypeHashMap::iterator it;
13352     for( it = sm_fieldTypes.begin(); it != sm_fieldTypes.end(); ++it )
13353     {
13354         wxRichTextFieldType* fieldType = it->second;
13355         delete fieldType;
13356     }
13357
13358     sm_fieldTypes.clear();
13359 }
13360
13361 #endif
13362     // wxUSE_RICHTEXT