+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+
+ // Don't recurse if the child is a top-level object,
+ // such as a text box, because the character position will no longer
+ // apply. By definition, a top-level object has its own range of
+ // character positions.
+ if (!child->IsTopLevel() && child->FindPosition(dc, index, pt, height, forceLineStart))
+ return true;
+
+ node = node->GetNext();
+ }
+
+ return false;
+}
+
+/// Calculate range
+void wxRichTextCompositeObject::CalculateRange(long start, long& end)
+{
+ long current = start;
+ long lastEnd = current;
+
+ if (IsTopLevel())
+ {
+ current = 0;
+ lastEnd = 0;
+ }
+
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+ long childEnd = 0;
+
+ child->CalculateRange(current, childEnd);
+ lastEnd = childEnd;
+
+ current = childEnd + 1;
+
+ node = node->GetNext();
+ }
+
+ if (IsTopLevel())
+ {
+ // A top-level object always has a range of size 1,
+ // because its children don't count at this level.
+ end = start;
+ m_range.SetRange(start, start);
+
+ // An object with no children has zero length
+ if (m_children.GetCount() == 0)
+ lastEnd --;
+ m_ownRange.SetRange(0, lastEnd);
+ }
+ else
+ {
+ end = lastEnd;
+
+ // An object with no children has zero length
+ if (m_children.GetCount() == 0)
+ end --;
+
+ m_range.SetRange(start, end);
+ }
+}
+
+/// Delete range from layout.
+bool wxRichTextCompositeObject::DeleteRange(const wxRichTextRange& range)
+{
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+
+ while (node)
+ {
+ wxRichTextObject* obj = (wxRichTextObject*) node->GetData();
+ wxRichTextObjectList::compatibility_iterator next = node->GetNext();
+
+ // Delete the range in each paragraph
+
+ // When a chunk has been deleted, internally the content does not
+ // now match the ranges.
+ // However, so long as deletion is not done on the same object twice this is OK.
+ // If you may delete content from the same object twice, recalculate
+ // the ranges inbetween DeleteRange calls by calling CalculateRanges, and
+ // adjust the range you're deleting accordingly.
+
+ if (!obj->GetRange().IsOutside(range))
+ {
+ // No need to delete within a top-level object; just removing this object will do fine
+ if (!obj->IsTopLevel())
+ obj->DeleteRange(range);
+
+ // Delete an empty object, or paragraph within this range.
+ if (obj->IsEmpty() ||
+ (range.GetStart() <= obj->GetRange().GetStart() && range.GetEnd() >= obj->GetRange().GetEnd()))
+ {
+ // An empty paragraph has length 1, so won't be deleted unless the
+ // whole range is deleted.
+ RemoveChild(obj, true);
+ }
+ }
+
+ node = next;
+ }
+
+ return true;
+}
+
+/// Get any text in this object for the given range
+wxString wxRichTextCompositeObject::GetTextForRange(const wxRichTextRange& range) const
+{
+ wxString text;
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+ wxRichTextRange childRange = range;
+ if (!child->GetRange().IsOutside(range))
+ {
+ childRange.LimitTo(child->GetRange());
+
+ wxString childText = child->GetTextForRange(childRange);
+
+ text += childText;
+ }
+ node = node->GetNext();
+ }
+
+ return text;
+}
+
+/// Get the child object at the given character position
+wxRichTextObject* wxRichTextCompositeObject::GetChildAtPosition(long pos) const
+{
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+ if (child->GetRange().GetStart() == pos)
+ return child;
+ node = node->GetNext();
+ }
+ return NULL;
+}
+
+/// Recursively merge all pieces that can be merged.
+bool wxRichTextCompositeObject::Defragment(const wxRichTextRange& range)
+{
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+ if (range == wxRICHTEXT_ALL || !child->GetRange().IsOutside(range))
+ {
+ wxRichTextCompositeObject* composite = wxDynamicCast(child, wxRichTextCompositeObject);
+ if (composite)
+ composite->Defragment();
+
+ if (node->GetNext())
+ {
+ wxRichTextObject* nextChild = node->GetNext()->GetData();
+ if (child->CanMerge(nextChild) && child->Merge(nextChild))
+ {
+ nextChild->Dereference();
+ m_children.Erase(node->GetNext());
+
+ // Don't set node -- we'll see if we can merge again with the next
+ // child.
+ }
+ else
+ node = node->GetNext();
+ }
+ else
+ node = node->GetNext();
+ }
+ else
+ node = node->GetNext();
+ }
+
+ // Delete any remaining empty objects, but leave at least one empty object per composite object.
+ if (GetChildCount() > 1)
+ {
+ node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObjectList::compatibility_iterator next = node->GetNext();
+ wxRichTextObject* child = node->GetData();
+ if (range == wxRICHTEXT_ALL || !child->GetRange().IsOutside(range))
+ {
+ if (child->IsEmpty())
+ {
+ child->Dereference();
+ m_children.Erase(node);
+ }
+ node = next;
+ }
+ else
+ node = node->GetNext();
+ }
+ }
+
+ return true;
+}
+
+/// Dump to output stream for debugging
+void wxRichTextCompositeObject::Dump(wxTextOutputStream& stream)
+{
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+ child->Dump(stream);
+ node = node->GetNext();
+ }
+}
+
+/// Get/set the object size for the given range. Returns false if the range
+/// is invalid for this object.
+bool wxRichTextCompositeObject::GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position, wxArrayInt* partialExtents) const
+{
+ if (!range.IsWithin(GetRange()))
+ return false;
+
+ wxSize sz;
+
+ wxArrayInt childExtents;
+ wxArrayInt* p;
+ if (partialExtents)
+ p = & childExtents;
+ else
+ p = NULL;
+
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+ if (!child->GetRange().IsOutside(range))
+ {
+ // Floating objects have a zero size within the paragraph.
+ if (child->IsFloating())
+ {
+ if (partialExtents)
+ {
+ int lastSize;
+ if (partialExtents->GetCount() > 0)
+ lastSize = (*partialExtents)[partialExtents->GetCount()-1];
+ else
+ lastSize = 0;
+
+ partialExtents->Add(0 /* zero size */ + lastSize);
+ }
+ }
+ else
+ {
+ wxSize childSize;
+
+ wxRichTextRange rangeToUse = range;
+ rangeToUse.LimitTo(child->GetRange());
+ if (child->IsTopLevel())
+ rangeToUse = child->GetOwnRange();
+
+ int childDescent = 0;
+
+ // At present wxRICHTEXT_HEIGHT_ONLY is only fast if we're already cached the size,
+ // but it's only going to be used after caching has taken place.
+ if ((flags & wxRICHTEXT_HEIGHT_ONLY) && child->GetCachedSize().y != 0)
+ {
+ childDescent = child->GetDescent();
+ childSize = child->GetCachedSize();
+
+ sz.y = wxMax(sz.y, childSize.y);
+ sz.x += childSize.x;
+ descent = wxMax(descent, childDescent);
+ }
+ else if (child->GetRangeSize(rangeToUse, childSize, childDescent, dc, flags, wxPoint(position.x + sz.x, position.y), p))
+ {
+ sz.y = wxMax(sz.y, childSize.y);
+ sz.x += childSize.x;
+ descent = wxMax(descent, childDescent);
+
+ if ((flags & wxRICHTEXT_CACHE_SIZE) && (rangeToUse == child->GetRange() || child->IsTopLevel()))
+ {
+ child->SetCachedSize(childSize);
+ child->SetDescent(childDescent);
+ }
+
+ if (partialExtents)
+ {
+ int lastSize;
+ if (partialExtents->GetCount() > 0)
+ lastSize = (*partialExtents)[partialExtents->GetCount()-1];
+ else
+ lastSize = 0;
+
+ size_t i;
+ for (i = 0; i < childExtents.GetCount(); i++)
+ {
+ partialExtents->Add(childExtents[i] + lastSize);
+ }
+ }
+ }
+ }
+
+ if (p)
+ p->Clear();
+ }
+
+ node = node->GetNext();
+ }
+ size = sz;
+ return true;
+}
+
+// Invalidate the buffer. With no argument, invalidates whole buffer.
+void wxRichTextCompositeObject::Invalidate(const wxRichTextRange& invalidRange)
+{
+ wxRichTextObject::Invalidate(invalidRange);
+
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+ if (invalidRange != wxRICHTEXT_ALL && invalidRange != wxRICHTEXT_NONE && child->GetRange().IsOutside(invalidRange))
+ {
+ // Skip
+ }
+ else if (child->IsTopLevel())
+ {
+ if (invalidRange == wxRICHTEXT_NONE)
+ child->Invalidate(wxRICHTEXT_NONE);
+ else
+ child->Invalidate(wxRICHTEXT_ALL); // All children must be invalidated if within parent range
+ }
+ else
+ child->Invalidate(invalidRange);
+ node = node->GetNext();
+ }
+}
+
+// Move the object recursively, by adding the offset from old to new
+void wxRichTextCompositeObject::Move(const wxPoint& pt)
+{
+ wxPoint oldPos = GetPosition();
+ SetPosition(pt);
+ wxPoint offset = pt - oldPos;
+
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+ wxPoint childPos = child->GetPosition() + offset;
+ child->Move(childPos);
+ node = node->GetNext();
+ }
+}
+
+
+/*!
+ * wxRichTextParagraphLayoutBox
+ * This box knows how to lay out paragraphs.
+ */
+
+IMPLEMENT_DYNAMIC_CLASS(wxRichTextParagraphLayoutBox, wxRichTextCompositeObject)
+
+wxRichTextParagraphLayoutBox::wxRichTextParagraphLayoutBox(wxRichTextObject* parent):
+ wxRichTextCompositeObject(parent)
+{
+ Init();
+}
+
+wxRichTextParagraphLayoutBox::~wxRichTextParagraphLayoutBox()
+{
+ if (m_floatCollector)
+ {
+ delete m_floatCollector;
+ m_floatCollector = NULL;
+ }
+}
+
+/// Initialize the object.
+void wxRichTextParagraphLayoutBox::Init()
+{
+ m_ctrl = NULL;
+
+ // For now, assume is the only box and has no initial size.
+ m_range = wxRichTextRange(0, -1);
+ m_ownRange = wxRichTextRange(0, -1);
+
+ m_invalidRange = wxRICHTEXT_ALL;
+
+ SetMargins(4);
+ m_partialParagraph = false;
+ m_floatCollector = NULL;
+}
+
+void wxRichTextParagraphLayoutBox::Clear()
+{
+ DeleteChildren();
+
+ if (m_floatCollector)
+ delete m_floatCollector;
+ m_floatCollector = NULL;
+ m_partialParagraph = false;
+}
+
+/// Copy
+void wxRichTextParagraphLayoutBox::Copy(const wxRichTextParagraphLayoutBox& obj)
+{
+ Clear();
+
+ wxRichTextCompositeObject::Copy(obj);
+
+ m_partialParagraph = obj.m_partialParagraph;
+ m_defaultAttributes = obj.m_defaultAttributes;
+}
+
+// Gather information about floating objects; only gather floats for those paragraphs that
+// will not be formatted again due to optimization, after which floats will be gathered per-paragraph
+// during layout.
+bool wxRichTextParagraphLayoutBox::UpdateFloatingObjects(const wxRect& availableRect, wxRichTextObject* untilObj)
+{
+ if (m_floatCollector != NULL)
+ delete m_floatCollector;
+ m_floatCollector = new wxRichTextFloatCollector(availableRect);
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ // Only gather floats up to the point we'll start formatting paragraphs.
+ while (untilObj && node && node->GetData() != untilObj)
+ {
+ wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+ wxASSERT (child != NULL);
+ if (child)
+ m_floatCollector->CollectFloat(child);
+ node = node->GetNext();
+ }
+
+ return true;
+}
+
+// Returns the style sheet associated with the overall buffer.
+wxRichTextStyleSheet* wxRichTextParagraphLayoutBox::GetStyleSheet() const
+{
+ return GetBuffer() ? GetBuffer()->GetStyleSheet() : (wxRichTextStyleSheet*) NULL;
+}
+
+// Get the number of floating objects at this level
+int wxRichTextParagraphLayoutBox::GetFloatingObjectCount() const
+{
+ if (m_floatCollector)
+ return m_floatCollector->GetFloatingObjectCount();
+ else
+ return 0;
+}
+
+// Get a list of floating objects
+bool wxRichTextParagraphLayoutBox::GetFloatingObjects(wxRichTextObjectList& objects) const
+{
+ if (m_floatCollector)
+ {
+ return m_floatCollector->GetFloatingObjects(objects);
+ }
+ else
+ return false;
+}
+
+// Calculate ranges
+void wxRichTextParagraphLayoutBox::UpdateRanges()
+{
+ long start = 0;
+ if (GetParent())
+ start = GetRange().GetStart();
+ long end;
+ CalculateRange(start, end);
+}
+
+// HitTest
+int wxRichTextParagraphLayoutBox::HitTest(wxDC& dc, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags)
+{
+ if (!IsShown())
+ return wxRICHTEXT_HITTEST_NONE;
+
+ int ret = wxRICHTEXT_HITTEST_NONE;
+ if (m_floatCollector && (flags & wxRICHTEXT_HITTEST_NO_FLOATING_OBJECTS) == 0)
+ ret = m_floatCollector->HitTest(dc, pt, textPosition, obj, flags);
+
+ if (ret == wxRICHTEXT_HITTEST_NONE)
+ return wxRichTextCompositeObject::HitTest(dc, pt, textPosition, obj, contextObj, flags);
+ else
+ {
+ *contextObj = this;
+ return ret;
+ }
+}
+
+/// Draw the floating objects
+void wxRichTextParagraphLayoutBox::DrawFloats(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style)
+{
+ if (m_floatCollector)
+ m_floatCollector->Draw(dc, range, selection, rect, descent, style);
+}
+
+void wxRichTextParagraphLayoutBox::MoveAnchoredObjectToParagraph(wxRichTextParagraph* from, wxRichTextParagraph* to, wxRichTextObject* obj)
+{
+ if (from == to)
+ return;
+
+ from->RemoveChild(obj);
+ to->AppendChild(obj);
+}
+
+/// Draw the item
+bool wxRichTextParagraphLayoutBox::Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style)
+{
+ if (!IsShown())
+ return true;
+
+ wxRect thisRect(GetPosition(), GetCachedSize());
+
+ int flags = style;
+ if (selection.IsValid() && GetParentContainer() != this && selection.WithinSelection(GetRange().GetStart(), GetParentContainer()))
+ flags |= wxRICHTEXT_DRAW_SELECTED;
+
+ // Don't draw guidelines if at top level
+ int theseFlags = flags;
+ if (!GetParent())
+ theseFlags &= ~wxRICHTEXT_DRAW_GUIDELINES;
+ DrawBoxAttributes(dc, GetBuffer(), GetAttributes(), thisRect, theseFlags);
+
+ DrawFloats(dc, range, selection, rect, descent, style);
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+
+ if (child && !child->GetRange().IsOutside(range))
+ {
+ wxRect childRect(child->GetPosition(), child->GetCachedSize());
+ wxRichTextRange childRange = range;
+ if (child->IsTopLevel())
+ {
+ childRange = child->GetOwnRange();
+ }
+
+ if (((style & wxRICHTEXT_DRAW_IGNORE_CACHE) == 0) && childRect.GetTop() > rect.GetBottom())
+ {
+ // Stop drawing
+ break;
+ }
+ else if (((style & wxRICHTEXT_DRAW_IGNORE_CACHE) == 0) && childRect.GetBottom() < rect.GetTop())
+ {
+ // Skip
+ }
+ else
+ child->Draw(dc, childRange, selection, rect, descent, style);
+ }
+
+ node = node->GetNext();
+ }
+ return true;
+}
+
+/// Lay the item out
+bool wxRichTextParagraphLayoutBox::Layout(wxDC& dc, const wxRect& rect, int style)
+{
+ SetPosition(rect.GetPosition());
+
+ if (!IsShown())
+ return true;
+
+ wxRect availableSpace;
+ bool formatRect = (style & wxRICHTEXT_LAYOUT_SPECIFIED_RECT) == wxRICHTEXT_LAYOUT_SPECIFIED_RECT;
+
+ // If only laying out a specific area, the passed rect has a different meaning:
+ // the visible part of the buffer. This is used in wxRichTextCtrl::OnSize,
+ // so that during a size, only the visible part will be relaid out, or
+ // it would take too long causing flicker. As an approximation, we assume that
+ // everything up to the start of the visible area is laid out correctly.
+ if (formatRect)
+ {
+ wxRect rect2(0, 0, rect.width, rect.height);
+ availableSpace = GetAvailableContentArea(dc, rect2);
+
+ // Invalidate the part of the buffer from the first visible line
+ // to the end. If other parts of the buffer are currently invalid,
+ // then they too will be taken into account if they are above
+ // the visible point.
+ long startPos = 0;
+ wxRichTextLine* line = GetLineAtYPosition(rect.y);
+ if (line)
+ startPos = line->GetAbsoluteRange().GetStart();
+
+ Invalidate(wxRichTextRange(startPos, GetOwnRange().GetEnd()));
+ }
+ else
+ {
+ availableSpace = GetAvailableContentArea(dc, rect);
+ }
+
+ int leftMargin, rightMargin, topMargin, bottomMargin;
+ wxRichTextObject::GetTotalMargin(dc, GetBuffer(), GetAttributes(), leftMargin, rightMargin,
+ topMargin, bottomMargin);
+
+ int maxWidth = 0;
+ int maxHeight = 0;
+
+ // The maximum paragraph maximum width, so we can set the overall maximum width for this object
+ int maxMaxWidth = 0;
+
+ // The maximum paragraph minimum width, so we can set the overall minimum width for this object
+ int maxMinWidth = 0;
+
+ // If we have vertical alignment, we must recalculate everything.
+ bool hasVerticalAlignment = (GetAttributes().GetTextBoxAttr().HasVerticalAlignment() &&
+ (GetAttributes().GetTextBoxAttr().GetVerticalAlignment() > wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_TOP));
+
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+
+ bool layoutAll = true;
+
+ // Get invalid range, rounding to paragraph start/end.
+ wxRichTextRange invalidRange = GetInvalidRange(true);
+
+ if (invalidRange == wxRICHTEXT_NONE && !formatRect)
+ return true;
+
+ if (invalidRange == wxRICHTEXT_ALL || hasVerticalAlignment)
+ layoutAll = true;
+ else // If we know what range is affected, start laying out from that point on.
+ if (invalidRange.GetStart() >= GetOwnRange().GetStart())
+ {
+ wxRichTextParagraph* firstParagraph = GetParagraphAtPosition(invalidRange.GetStart());
+ if (firstParagraph)
+ {
+ wxRichTextObjectList::compatibility_iterator firstNode = m_children.Find(firstParagraph);
+ wxRichTextObjectList::compatibility_iterator previousNode;
+ if ( firstNode )
+ previousNode = firstNode->GetPrevious();
+ if (firstNode)
+ {
+ if (previousNode)
+ {
+ wxRichTextParagraph* previousParagraph = wxDynamicCast(previousNode->GetData(), wxRichTextParagraph);
+ availableSpace.y = previousParagraph->GetPosition().y + previousParagraph->GetCachedSize().y;
+ }
+
+ // Now we're going to start iterating from the first affected paragraph.
+ node = firstNode;
+
+ layoutAll = false;
+ }
+ }
+ }
+
+ // Gather information about only those floating objects that will not be formatted,
+ // after which floats will be gathered per-paragraph during layout.
+ UpdateFloatingObjects(availableSpace, node ? node->GetData() : (wxRichTextObject*) NULL);
+
+ // A way to force speedy rest-of-buffer layout (the 'else' below)
+ bool forceQuickLayout = false;
+
+ while (node)
+ {
+ // Assume this box only contains paragraphs
+
+ wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+ // Unsure if this is needed
+ // wxCHECK_MSG( child, false, wxT("Unknown object in layout") );
+
+ if (child && child->IsShown())
+ {
+ // TODO: what if the child hasn't been laid out (e.g. involved in Undo) but still has 'old' lines
+ if ( !forceQuickLayout &&
+ (layoutAll ||
+ child->GetLines().IsEmpty() ||
+ !child->GetRange().IsOutside(invalidRange)) )
+ {
+ // Lays out the object first with a given amount of space, and then if no width was specified in attr,
+ // lays out the object again using the minimum size
+ child->LayoutToBestSize(dc, GetBuffer(),
+ GetAttributes(), child->GetAttributes(), availableSpace, style&~wxRICHTEXT_LAYOUT_SPECIFIED_RECT);
+
+ // Layout must set the cached size
+ availableSpace.y += child->GetCachedSize().y;
+ maxWidth = wxMax(maxWidth, child->GetCachedSize().x);
+ maxMinWidth = wxMax(maxMinWidth, child->GetMinSize().x);
+ maxMaxWidth = wxMax(maxMaxWidth, child->GetMaxSize().x);
+
+ // If we're just formatting the visible part of the buffer,
+ // and we're now past the bottom of the window, and we don't have any
+ // floating objects (since they may cause wrapping to change for the rest of the
+ // the buffer), start quick layout.
+ if (!hasVerticalAlignment && formatRect && child->GetPosition().y > rect.GetBottom() && GetFloatingObjectCount() == 0)
+ forceQuickLayout = true;
+ }
+ else
+ {
+ // We're outside the immediately affected range, so now let's just
+ // move everything up or down. This assumes that all the children have previously
+ // been laid out and have wrapped line lists associated with them.
+ // TODO: check all paragraphs before the affected range.
+
+ int inc = availableSpace.y - child->GetPosition().y;
+
+ while (node)
+ {
+ wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+ if (child)
+ {
+ if (child->GetLines().GetCount() == 0)
+ {
+ // Lays out the object first with a given amount of space, and then if no width was specified in attr,
+ // lays out the object again using the minimum size
+ child->LayoutToBestSize(dc, GetBuffer(),
+ GetAttributes(), child->GetAttributes(), availableSpace, style&~wxRICHTEXT_LAYOUT_SPECIFIED_RECT);
+
+ //child->Layout(dc, availableChildRect, style);
+ }
+ else
+ child->Move(wxPoint(child->GetPosition().x, child->GetPosition().y + inc));
+
+ availableSpace.y += child->GetCachedSize().y;
+ maxWidth = wxMax(maxWidth, child->GetCachedSize().x);
+ maxMinWidth = wxMax(maxMinWidth, child->GetMinSize().x);
+ maxMaxWidth = wxMax(maxMaxWidth, child->GetMaxSize().x);
+ }
+
+ node = node->GetNext();
+ }
+ break;
+ }
+ }
+
+ node = node->GetNext();
+ }
+
+ node = m_children.GetLast();
+ if (node && node->GetData()->IsShown())
+ {
+ wxRichTextObject* child = node->GetData();
+ // maxHeight = (child->GetPosition().y - GetPosition().y) + child->GetCachedSize().y;
+ maxHeight = child->GetPosition().y - (GetPosition().y + topMargin) + child->GetCachedSize().y;
+ }
+ else
+ maxHeight = 0; // topMargin + bottomMargin;
+
+ // TODO: (also in para layout) should set the
+ // object's size to an absolute one if specified,
+ // but if not specified, calculate it from content.
+
+ // We need to add back the margins etc.
+ {
+ wxRect marginRect, borderRect, contentRect, paddingRect, outlineRect;
+ contentRect = wxRect(wxPoint(0, 0), wxSize(maxWidth, maxHeight));
+ GetBoxRects(dc, GetBuffer(), GetAttributes(), marginRect, borderRect, contentRect, paddingRect, outlineRect);
+ SetCachedSize(marginRect.GetSize());
+ }
+
+ // The maximum size is the greatest of all maximum widths for all paragraphs.
+ {
+ wxRect marginRect, borderRect, contentRect, paddingRect, outlineRect;
+ contentRect = wxRect(wxPoint(0, 0), wxSize(maxMaxWidth, maxHeight)); // Actually max height is a lie, we can't know it
+ GetBoxRects(dc, GetBuffer(), GetAttributes(), marginRect, borderRect, contentRect, paddingRect, outlineRect);
+ SetMaxSize(marginRect.GetSize());
+ }
+
+ // The minimum size is the greatest of all minimum widths for all paragraphs.
+ {
+ wxRect marginRect, borderRect, contentRect, paddingRect, outlineRect;
+ contentRect = wxRect(wxPoint(0, 0), wxSize(maxMinWidth, maxHeight)); // Actually max height is a lie, we can't know it
+ GetBoxRects(dc, GetBuffer(), GetAttributes(), marginRect, borderRect, contentRect, paddingRect, outlineRect);
+ SetMinSize(marginRect.GetSize());
+ }
+
+ if (GetAttributes().GetTextBoxAttr().HasVerticalAlignment() &&
+ (GetAttributes().GetTextBoxAttr().GetVerticalAlignment() > wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_TOP))
+ {
+ int yOffset = 0;
+ int leftOverSpace = availableSpace.height - topMargin - bottomMargin - maxHeight;
+ if (leftOverSpace > 0)
+ {
+ if (GetAttributes().GetTextBoxAttr().GetVerticalAlignment() == wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_CENTRE)
+ {
+ yOffset = (leftOverSpace/2);
+ }
+ else if (GetAttributes().GetTextBoxAttr().GetVerticalAlignment() == wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_BOTTOM)
+ {
+ yOffset = leftOverSpace;
+ }
+ }
+
+ // Move all the children to vertically align the content
+ // This doesn't take into account floating objects, unfortunately.
+ if (yOffset != 0)
+ {
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+ if (child)
+ child->Move(wxPoint(child->GetPosition().x, child->GetPosition().y + yOffset));
+
+ node = node->GetNext();
+ }
+ }
+ }
+
+ m_invalidRange = wxRICHTEXT_NONE;
+
+ return true;
+}
+
+/// Get/set the size for the given range.
+bool wxRichTextParagraphLayoutBox::GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position, wxArrayInt* WXUNUSED(partialExtents)) const
+{
+ wxSize sz;
+
+ wxRichTextObjectList::compatibility_iterator startPara = wxRichTextObjectList::compatibility_iterator();
+ wxRichTextObjectList::compatibility_iterator endPara = wxRichTextObjectList::compatibility_iterator();
+
+ // First find the first paragraph whose starting position is within the range.
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ // child is a paragraph
+ wxRichTextObject* child = node->GetData();
+ const wxRichTextRange& r = child->GetRange();
+
+ if (r.GetStart() <= range.GetStart() && r.GetEnd() >= range.GetStart())
+ {
+ startPara = node;
+ break;
+ }
+
+ node = node->GetNext();
+ }
+
+ // Next find the last paragraph containing part of the range
+ node = m_children.GetFirst();
+ while (node)
+ {
+ // child is a paragraph
+ wxRichTextObject* child = node->GetData();
+ const wxRichTextRange& r = child->GetRange();
+
+ if (r.GetStart() <= range.GetEnd() && r.GetEnd() >= range.GetEnd())
+ {
+ endPara = node;
+ break;
+ }
+
+ node = node->GetNext();
+ }
+
+ if (!startPara || !endPara)
+ return false;
+
+ // Now we can add up the sizes
+ for (node = startPara; node ; node = node->GetNext())
+ {
+ // child is a paragraph
+ wxRichTextObject* child = node->GetData();
+ const wxRichTextRange& childRange = child->GetRange();
+ wxRichTextRange rangeToFind = range;
+ rangeToFind.LimitTo(childRange);
+
+ if (child->IsTopLevel())
+ rangeToFind = child->GetOwnRange();
+
+ wxSize childSize;
+
+ int childDescent = 0;
+ child->GetRangeSize(rangeToFind, childSize, childDescent, dc, flags, position);
+
+ descent = wxMax(childDescent, descent);
+
+ sz.x = wxMax(sz.x, childSize.x);
+ sz.y += childSize.y;
+
+ if (node == endPara)
+ break;
+ }
+
+ size = sz;
+
+ return true;
+}
+
+/// Get the paragraph at the given position
+wxRichTextParagraph* wxRichTextParagraphLayoutBox::GetParagraphAtPosition(long pos, bool caretPosition) const
+{
+ if (caretPosition)
+ pos ++;
+
+ // First find the first paragraph whose starting position is within the range.
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ // child is a paragraph
+ wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+ // wxASSERT (child != NULL);
+
+ if (child)
+ {
+ // Return first child in buffer if position is -1
+ // if (pos == -1)
+ // return child;
+
+ if (child->GetRange().Contains(pos))
+ return child;
+ }
+
+ node = node->GetNext();
+ }
+ return NULL;
+}
+
+/// Get the line at the given position
+wxRichTextLine* wxRichTextParagraphLayoutBox::GetLineAtPosition(long pos, bool caretPosition) const
+{
+ if (caretPosition)
+ pos ++;
+
+ // First find the first paragraph whose starting position is within the range.
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* obj = (wxRichTextObject*) node->GetData();
+ if (obj->GetRange().Contains(pos))
+ {
+ // child is a paragraph
+ wxRichTextParagraph* child = wxDynamicCast(obj, wxRichTextParagraph);
+ // wxASSERT (child != NULL);
+
+ if (child)
+ {
+ wxRichTextLineList::compatibility_iterator node2 = child->GetLines().GetFirst();
+ while (node2)
+ {
+ wxRichTextLine* line = node2->GetData();
+
+ wxRichTextRange range = line->GetAbsoluteRange();
+
+ if (range.Contains(pos) ||
+
+ // If the position is end-of-paragraph, then return the last line of
+ // of the paragraph.
+ ((range.GetEnd() == child->GetRange().GetEnd()-1) && (pos == child->GetRange().GetEnd())))
+ return line;
+
+ node2 = node2->GetNext();
+ }
+ }
+ }
+
+ node = node->GetNext();
+ }
+
+ int lineCount = GetLineCount();
+ if (lineCount > 0)
+ return GetLineForVisibleLineNumber(lineCount-1);
+ else
+ return NULL;
+}
+
+/// Get the line at the given y pixel position, or the last line.
+wxRichTextLine* wxRichTextParagraphLayoutBox::GetLineAtYPosition(int y) const
+{
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+ // wxASSERT (child != NULL);
+
+ if (child)
+ {
+ wxRichTextLineList::compatibility_iterator node2 = child->GetLines().GetFirst();
+ while (node2)
+ {
+ wxRichTextLine* line = node2->GetData();
+
+ wxRect rect(line->GetRect());
+
+ if (y <= rect.GetBottom())
+ return line;
+
+ node2 = node2->GetNext();
+ }
+ }
+
+ node = node->GetNext();
+ }
+
+ // Return last line
+ int lineCount = GetLineCount();
+ if (lineCount > 0)
+ return GetLineForVisibleLineNumber(lineCount-1);
+ else
+ return NULL;
+}
+
+/// Get the number of visible lines
+int wxRichTextParagraphLayoutBox::GetLineCount() const
+{
+ int count = 0;
+
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+ // wxASSERT (child != NULL);
+
+ if (child)
+ count += child->GetLines().GetCount();
+
+ node = node->GetNext();
+ }
+ return count;
+}
+
+
+/// Get the paragraph for a given line
+wxRichTextParagraph* wxRichTextParagraphLayoutBox::GetParagraphForLine(wxRichTextLine* line) const
+{
+ return GetParagraphAtPosition(line->GetAbsoluteRange().GetStart());
+}
+
+/// Get the line size at the given position
+wxSize wxRichTextParagraphLayoutBox::GetLineSizeAtPosition(long pos, bool caretPosition) const
+{
+ wxRichTextLine* line = GetLineAtPosition(pos, caretPosition);
+ if (line)
+ {
+ return line->GetSize();
+ }
+ else
+ return wxSize(0, 0);
+}
+
+
+/// Convenience function to add a paragraph of text
+wxRichTextRange wxRichTextParagraphLayoutBox::AddParagraph(const wxString& text, wxRichTextAttr* paraStyle)
+{
+ // Don't use the base style, just the default style, and the base style will
+ // be combined at display time.
+ // Divide into paragraph and character styles.
+
+ wxRichTextAttr defaultCharStyle;
+ wxRichTextAttr defaultParaStyle;
+
+ // If the default style is a named paragraph style, don't apply any character formatting
+ // to the initial text string.
+ if (GetDefaultStyle().HasParagraphStyleName() && GetStyleSheet())
+ {
+ wxRichTextParagraphStyleDefinition* def = GetStyleSheet()->FindParagraphStyle(GetDefaultStyle().GetParagraphStyleName());
+ if (def)
+ defaultParaStyle = def->GetStyleMergedWithBase(GetStyleSheet());
+ }
+ else
+ wxRichTextSplitParaCharStyles(GetDefaultStyle(), defaultParaStyle, defaultCharStyle);
+
+ wxRichTextAttr* pStyle = paraStyle ? paraStyle : (wxRichTextAttr*) & defaultParaStyle;
+ wxRichTextAttr* cStyle = & defaultCharStyle;
+
+ wxRichTextParagraph* para = new wxRichTextParagraph(text, this, pStyle, cStyle);
+
+ AppendChild(para);
+
+ UpdateRanges();
+
+ return para->GetRange();
+}
+
+/// Adds multiple paragraphs, based on newlines.
+wxRichTextRange wxRichTextParagraphLayoutBox::AddParagraphs(const wxString& text, wxRichTextAttr* paraStyle)
+{
+ // Don't use the base style, just the default style, and the base style will
+ // be combined at display time.
+ // Divide into paragraph and character styles.
+
+ wxRichTextAttr defaultCharStyle;
+ wxRichTextAttr defaultParaStyle;
+
+ // If the default style is a named paragraph style, don't apply any character formatting
+ // to the initial text string.
+ if (GetDefaultStyle().HasParagraphStyleName() && GetStyleSheet())
+ {
+ wxRichTextParagraphStyleDefinition* def = GetStyleSheet()->FindParagraphStyle(GetDefaultStyle().GetParagraphStyleName());
+ if (def)
+ defaultParaStyle = def->GetStyleMergedWithBase(GetStyleSheet());
+ }
+ else
+ wxRichTextSplitParaCharStyles(GetDefaultStyle(), defaultParaStyle, defaultCharStyle);
+
+ wxRichTextAttr* pStyle = paraStyle ? paraStyle : (wxRichTextAttr*) & defaultParaStyle;
+ wxRichTextAttr* cStyle = & defaultCharStyle;
+
+ wxRichTextParagraph* firstPara = NULL;
+ wxRichTextParagraph* lastPara = NULL;
+
+ wxRichTextRange range(-1, -1);
+
+ size_t i = 0;
+ size_t len = text.length();
+ wxString line;
+ wxRichTextParagraph* para = new wxRichTextParagraph(wxEmptyString, this, pStyle, cStyle);
+
+ AppendChild(para);
+
+ firstPara = para;
+ lastPara = para;
+
+ while (i < len)
+ {
+ wxChar ch = text[i];
+ if (ch == wxT('\n') || ch == wxT('\r'))
+ {
+ if (i != (len-1))
+ {
+ wxRichTextPlainText* plainText = (wxRichTextPlainText*) para->GetChildren().GetFirst()->GetData();
+ plainText->SetText(line);
+
+ para = new wxRichTextParagraph(wxEmptyString, this, pStyle, cStyle);
+
+ AppendChild(para);
+
+ lastPara = para;
+ line = wxEmptyString;
+ }
+ }
+ else
+ line += ch;
+
+ i ++;
+ }
+
+ if (!line.empty())
+ {
+ wxRichTextPlainText* plainText = (wxRichTextPlainText*) para->GetChildren().GetFirst()->GetData();
+ plainText->SetText(line);
+ }
+
+ UpdateRanges();
+
+ return wxRichTextRange(firstPara->GetRange().GetStart(), lastPara->GetRange().GetEnd());
+}
+
+/// Convenience function to add an image
+wxRichTextRange wxRichTextParagraphLayoutBox::AddImage(const wxImage& image, wxRichTextAttr* paraStyle)
+{
+ // Don't use the base style, just the default style, and the base style will
+ // be combined at display time.
+ // Divide into paragraph and character styles.
+
+ wxRichTextAttr defaultCharStyle;
+ wxRichTextAttr defaultParaStyle;
+
+ // If the default style is a named paragraph style, don't apply any character formatting
+ // to the initial text string.
+ if (GetDefaultStyle().HasParagraphStyleName() && GetStyleSheet())
+ {
+ wxRichTextParagraphStyleDefinition* def = GetStyleSheet()->FindParagraphStyle(GetDefaultStyle().GetParagraphStyleName());
+ if (def)
+ defaultParaStyle = def->GetStyleMergedWithBase(GetStyleSheet());
+ }
+ else
+ wxRichTextSplitParaCharStyles(GetDefaultStyle(), defaultParaStyle, defaultCharStyle);
+
+ wxRichTextAttr* pStyle = paraStyle ? paraStyle : (wxRichTextAttr*) & defaultParaStyle;
+ wxRichTextAttr* cStyle = & defaultCharStyle;
+
+ wxRichTextParagraph* para = new wxRichTextParagraph(this, pStyle);
+ AppendChild(para);
+ para->AppendChild(new wxRichTextImage(image, this, cStyle));
+
+ UpdateRanges();
+
+ return para->GetRange();
+}
+
+
+/// Insert fragment into this box at the given position. If partialParagraph is true,
+/// it is assumed that the last (or only) paragraph is just a piece of data with no paragraph
+/// marker.
+
+bool wxRichTextParagraphLayoutBox::InsertFragment(long position, wxRichTextParagraphLayoutBox& fragment)
+{
+ // First, find the first paragraph whose starting position is within the range.
+ wxRichTextParagraph* para = GetParagraphAtPosition(position);
+ if (para)
+ {
+ wxRichTextAttr originalAttr = para->GetAttributes();
+
+ wxRichTextObjectList::compatibility_iterator node = m_children.Find(para);
+
+ // Now split at this position, returning the object to insert the new
+ // ones in front of.
+ wxRichTextObject* nextObject = para->SplitAt(position);
+
+ // Special case: partial paragraph, just one paragraph. Might be a small amount of
+ // text, for example, so let's optimize.
+
+ if (fragment.GetPartialParagraph() && fragment.GetChildren().GetCount() == 1)
+ {
+ // Add the first para to this para...
+ wxRichTextObjectList::compatibility_iterator firstParaNode = fragment.GetChildren().GetFirst();
+ if (!firstParaNode)
+ return false;
+
+ // Iterate through the fragment paragraph inserting the content into this paragraph.
+ wxRichTextParagraph* firstPara = wxDynamicCast(firstParaNode->GetData(), wxRichTextParagraph);
+ wxASSERT (firstPara != NULL);
+
+ wxRichTextObjectList::compatibility_iterator objectNode = firstPara->GetChildren().GetFirst();
+ while (objectNode)
+ {
+ wxRichTextObject* newObj = objectNode->GetData()->Clone();
+
+ if (!nextObject)
+ {
+ // Append
+ para->AppendChild(newObj);
+ }
+ else
+ {
+ // Insert before nextObject
+ para->InsertChild(newObj, nextObject);
+ }
+
+ objectNode = objectNode->GetNext();
+ }
+
+ return true;
+ }
+ else
+ {
+ // Procedure for inserting a fragment consisting of a number of
+ // paragraphs:
+ //
+ // 1. Remove and save the content that's after the insertion point, for adding
+ // back once we've added the fragment.
+ // 2. Add the content from the first fragment paragraph to the current
+ // paragraph.
+ // 3. Add remaining fragment paragraphs after the current paragraph.
+ // 4. Add back the saved content from the first paragraph. If partialParagraph
+ // is true, add it to the last paragraph added and not a new one.
+
+ // 1. Remove and save objects after split point.
+ wxList savedObjects;
+ if (nextObject)
+ para->MoveToList(nextObject, savedObjects);
+
+ // 2. Add the content from the 1st fragment paragraph.
+ wxRichTextObjectList::compatibility_iterator firstParaNode = fragment.GetChildren().GetFirst();
+ if (!firstParaNode)
+ return false;
+
+ wxRichTextParagraph* firstPara = wxDynamicCast(firstParaNode->GetData(), wxRichTextParagraph);
+ wxASSERT(firstPara != NULL);
+
+ if (!(fragment.GetAttributes().GetFlags() & wxTEXT_ATTR_KEEP_FIRST_PARA_STYLE))
+ para->SetAttributes(firstPara->GetAttributes());
+
+ // Save empty paragraph attributes for appending later
+ // These are character attributes deliberately set for a new paragraph. Without this,
+ // we couldn't pass default attributes when appending a new paragraph.
+ wxRichTextAttr emptyParagraphAttributes;
+
+ wxRichTextObjectList::compatibility_iterator objectNode = firstPara->GetChildren().GetFirst();
+
+ if (objectNode && firstPara->GetChildren().GetCount() == 1 && objectNode->GetData()->IsEmpty())
+ emptyParagraphAttributes = objectNode->GetData()->GetAttributes();
+
+ while (objectNode)
+ {
+ wxRichTextObject* newObj = objectNode->GetData()->Clone();
+
+ // Append
+ para->AppendChild(newObj);
+
+ objectNode = objectNode->GetNext();
+ }
+
+ // 3. Add remaining fragment paragraphs after the current paragraph.
+ wxRichTextObjectList::compatibility_iterator nextParagraphNode = node->GetNext();
+ wxRichTextObject* nextParagraph = NULL;
+ if (nextParagraphNode)
+ nextParagraph = nextParagraphNode->GetData();
+
+ wxRichTextObjectList::compatibility_iterator i = fragment.GetChildren().GetFirst()->GetNext();
+ wxRichTextParagraph* finalPara = para;
+
+ bool needExtraPara = (!i || !fragment.GetPartialParagraph());
+
+ // If there was only one paragraph, we need to insert a new one.
+ while (i)
+ {
+ wxRichTextParagraph* para = wxDynamicCast(i->GetData(), wxRichTextParagraph);
+ wxASSERT( para != NULL );
+
+ finalPara = (wxRichTextParagraph*) para->Clone();
+
+ if (nextParagraph)
+ InsertChild(finalPara, nextParagraph);
+ else
+ AppendChild(finalPara);
+
+ i = i->GetNext();
+ }
+
+ // If there was only one paragraph, or we have full paragraphs in our fragment,
+ // we need to insert a new one.
+ if (needExtraPara)
+ {
+ finalPara = new wxRichTextParagraph;
+
+ if (nextParagraph)
+ InsertChild(finalPara, nextParagraph);
+ else
+ AppendChild(finalPara);
+ }
+
+ // 4. Add back the remaining content.
+ if (finalPara)
+ {
+ if (nextObject)
+ finalPara->MoveFromList(savedObjects);
+
+ // Ensure there's at least one object
+ if (finalPara->GetChildCount() == 0)
+ {
+ wxRichTextPlainText* text = new wxRichTextPlainText(wxEmptyString);
+ text->SetAttributes(emptyParagraphAttributes);
+
+ finalPara->AppendChild(text);
+ }
+ }
+
+ if ((fragment.GetAttributes().GetFlags() & wxTEXT_ATTR_KEEP_FIRST_PARA_STYLE) && firstPara)
+ finalPara->SetAttributes(firstPara->GetAttributes());
+ else if (finalPara && finalPara != para)
+ finalPara->SetAttributes(originalAttr);
+
+ return true;
+ }
+ }
+ else
+ {
+ // Append
+ wxRichTextObjectList::compatibility_iterator i = fragment.GetChildren().GetFirst();
+ while (i)
+ {
+ wxRichTextParagraph* para = wxDynamicCast(i->GetData(), wxRichTextParagraph);
+ wxASSERT( para != NULL );
+
+ AppendChild(para->Clone());
+
+ i = i->GetNext();
+ }
+
+ return true;
+ }
+}
+
+/// Make a copy of the fragment corresponding to the given range, putting it in 'fragment'.
+/// If there was an incomplete paragraph at the end, partialParagraph is set to true.
+bool wxRichTextParagraphLayoutBox::CopyFragment(const wxRichTextRange& range, wxRichTextParagraphLayoutBox& fragment)
+{
+ wxRichTextObjectList::compatibility_iterator i = GetChildren().GetFirst();
+ while (i)
+ {
+ wxRichTextParagraph* para = wxDynamicCast(i->GetData(), wxRichTextParagraph);
+ wxASSERT( para != NULL );
+
+ if (!para->GetRange().IsOutside(range))
+ {
+ fragment.AppendChild(para->Clone());
+ }
+ i = i->GetNext();
+ }
+
+ // Now top and tail the first and last paragraphs in our new fragment (which might be the same).
+ if (!fragment.IsEmpty())
+ {
+ wxRichTextParagraph* firstPara = wxDynamicCast(fragment.GetChildren().GetFirst()->GetData(), wxRichTextParagraph);
+ wxASSERT( firstPara != NULL );
+
+ wxRichTextParagraph* lastPara = wxDynamicCast(fragment.GetChildren().GetLast()->GetData(), wxRichTextParagraph);
+ wxASSERT( lastPara != NULL );
+
+ if (!firstPara || !lastPara)
+ return false;
+
+ bool isFragment = (range.GetEnd() < lastPara->GetRange().GetEnd());
+
+ long firstPos = firstPara->GetRange().GetStart();
+
+ // Adjust for renumbering from zero
+ wxRichTextRange topTailRange(range.GetStart() - firstPos, range.GetEnd() - firstPos);
+
+ long end;
+ fragment.CalculateRange(0, end);
+
+ // Chop off the start of the paragraph
+ if (topTailRange.GetStart() > 0)
+ {
+ wxRichTextRange r(0, topTailRange.GetStart()-1);
+ firstPara->DeleteRange(r);
+
+ // Make sure the numbering is correct
+ fragment.CalculateRange(0, end);
+
+ // Now, we've deleted some positions, so adjust the range
+ // accordingly.
+ topTailRange.SetStart(range.GetLength());
+ topTailRange.SetEnd(fragment.GetOwnRange().GetEnd());
+ }
+ else
+ {
+ topTailRange.SetStart(range.GetLength());
+ topTailRange.SetEnd(fragment.GetOwnRange().GetEnd());
+ }
+
+ if (topTailRange.GetStart() < (lastPara->GetRange().GetEnd()-1))
+ {
+ lastPara->DeleteRange(topTailRange);
+
+ // Make sure the numbering is correct
+ long end;
+ fragment.CalculateRange(0, end);
+
+ // We only have part of a paragraph at the end
+ fragment.SetPartialParagraph(true);
+ }
+ else
+ {
+ // We have a partial paragraph (don't save last new paragraph marker)
+ // or complete paragraph
+ fragment.SetPartialParagraph(isFragment);
+ }
+ }
+
+ return true;
+}
+
+/// Given a position, get the number of the visible line (potentially many to a paragraph),
+/// starting from zero at the start of the buffer.
+long wxRichTextParagraphLayoutBox::GetVisibleLineNumber(long pos, bool caretPosition, bool startOfLine) const
+{
+ if (caretPosition)
+ pos ++;
+
+ int lineCount = 0;
+
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+ // wxASSERT( child != NULL );
+
+ if (child)
+ {
+ if (child->GetRange().Contains(pos))
+ {
+ wxRichTextLineList::compatibility_iterator node2 = child->GetLines().GetFirst();
+ while (node2)
+ {
+ wxRichTextLine* line = node2->GetData();
+ wxRichTextRange lineRange = line->GetAbsoluteRange();
+
+ if (lineRange.Contains(pos) || pos == lineRange.GetStart())
+ {
+ // If the caret is displayed at the end of the previous wrapped line,
+ // we want to return the line it's _displayed_ at (not the actual line
+ // containing the position).
+ if (lineRange.GetStart() == pos && !startOfLine && child->GetRange().GetStart() != pos)
+ return lineCount - 1;
+ else
+ return lineCount;
+ }
+
+ lineCount ++;
+
+ node2 = node2->GetNext();
+ }
+ // If we didn't find it in the lines, it must be
+ // the last position of the paragraph. So return the last line.
+ return lineCount-1;
+ }
+ else
+ lineCount += child->GetLines().GetCount();
+ }
+
+ node = node->GetNext();
+ }
+
+ // Not found
+ return -1;
+}
+
+/// Given a line number, get the corresponding wxRichTextLine object.
+wxRichTextLine* wxRichTextParagraphLayoutBox::GetLineForVisibleLineNumber(long lineNumber) const
+{
+ int lineCount = 0;
+
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextParagraph* child = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+ // wxASSERT(child != NULL);
+
+ if (child)
+ {
+ if (lineNumber < (int) (child->GetLines().GetCount() + lineCount))
+ {
+ wxRichTextLineList::compatibility_iterator node2 = child->GetLines().GetFirst();
+ while (node2)
+ {
+ wxRichTextLine* line = node2->GetData();
+
+ if (lineCount == lineNumber)
+ return line;
+
+ lineCount ++;
+
+ node2 = node2->GetNext();
+ }
+ }
+ else
+ lineCount += child->GetLines().GetCount();
+ }
+
+ node = node->GetNext();
+ }
+
+ // Didn't find it
+ return NULL;
+}
+
+/// Delete range from layout.
+bool wxRichTextParagraphLayoutBox::DeleteRange(const wxRichTextRange& range)
+{
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+
+ wxRichTextParagraph* firstPara = NULL;
+ while (node)
+ {
+ wxRichTextParagraph* obj = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+ // wxASSERT (obj != NULL);
+
+ wxRichTextObjectList::compatibility_iterator next = node->GetNext();
+
+ if (obj)
+ {
+ // Delete the range in each paragraph
+
+ if (!obj->GetRange().IsOutside(range))
+ {
+ // Deletes the content of this object within the given range
+ obj->DeleteRange(range);
+
+ wxRichTextRange thisRange = obj->GetRange();
+ wxRichTextAttr thisAttr = obj->GetAttributes();
+
+ // If the whole paragraph is within the range to delete,
+ // delete the whole thing.
+ if (range.GetStart() <= thisRange.GetStart() && range.GetEnd() >= thisRange.GetEnd())
+ {
+ // Delete the whole object
+ RemoveChild(obj, true);
+ obj = NULL;
+ }
+ else if (!firstPara)
+ firstPara = obj;
+
+ // If the range includes the paragraph end, we need to join this
+ // and the next paragraph.
+ if (range.GetEnd() <= thisRange.GetEnd())
+ {
+ // We need to move the objects from the next paragraph
+ // to this paragraph
+
+ wxRichTextParagraph* nextParagraph = NULL;
+ if ((range.GetEnd() < thisRange.GetEnd()) && obj)
+ nextParagraph = obj;
+ else
+ {
+ // We're ending at the end of the paragraph, so merge the _next_ paragraph.
+ if (next)
+ nextParagraph = wxDynamicCast(next->GetData(), wxRichTextParagraph);
+ }
+
+ bool applyFinalParagraphStyle = firstPara && nextParagraph && nextParagraph != firstPara;
+
+ wxRichTextAttr nextParaAttr;
+ if (applyFinalParagraphStyle)
+ {
+ // Special case when deleting the end of a paragraph - use _this_ paragraph's style,
+ // not the next one.
+ if (range.GetStart() == range.GetEnd() && range.GetStart() == thisRange.GetEnd())
+ nextParaAttr = thisAttr;
+ else
+ nextParaAttr = nextParagraph->GetAttributes();
+ }
+
+ if (firstPara && nextParagraph && firstPara != nextParagraph)
+ {
+ // Move the objects to the previous para
+ wxRichTextObjectList::compatibility_iterator node1 = nextParagraph->GetChildren().GetFirst();
+
+ while (node1)
+ {
+ wxRichTextObject* obj1 = node1->GetData();
+
+ firstPara->AppendChild(obj1);
+
+ wxRichTextObjectList::compatibility_iterator next1 = node1->GetNext();
+ nextParagraph->GetChildren().Erase(node1);
+
+ node1 = next1;
+ }
+
+ // Delete the paragraph
+ RemoveChild(nextParagraph, true);
+ }
+
+ // Avoid empty paragraphs
+ if (firstPara && firstPara->GetChildren().GetCount() == 0)
+ {
+ wxRichTextPlainText* text = new wxRichTextPlainText(wxEmptyString);
+ firstPara->AppendChild(text);
+ }
+
+ if (applyFinalParagraphStyle)
+ firstPara->SetAttributes(nextParaAttr);
+
+ return true;
+ }
+ }
+ }
+
+ node = next;
+ }
+
+ return true;
+}
+
+/// Get any text in this object for the given range
+wxString wxRichTextParagraphLayoutBox::GetTextForRange(const wxRichTextRange& range) const
+{
+ int lineCount = 0;
+ wxString text;
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+ if (!child->GetRange().IsOutside(range))
+ {
+ wxRichTextRange childRange = range;
+ childRange.LimitTo(child->GetRange());
+
+ wxString childText = child->GetTextForRange(childRange);
+
+ text += childText;
+
+ if ((childRange.GetEnd() == child->GetRange().GetEnd()) && node->GetNext())
+ text += wxT("\n");
+
+ lineCount ++;
+ }
+ node = node->GetNext();
+ }
+
+ return text;
+}
+
+/// Get all the text
+wxString wxRichTextParagraphLayoutBox::GetText() const
+{
+ return GetTextForRange(GetOwnRange());
+}
+
+/// Get the paragraph by number
+wxRichTextParagraph* wxRichTextParagraphLayoutBox::GetParagraphAtLine(long paragraphNumber) const
+{
+ if ((size_t) paragraphNumber >= GetChildCount())
+ return NULL;
+
+ return (wxRichTextParagraph*) GetChild((size_t) paragraphNumber);
+}
+
+/// Get the length of the paragraph
+int wxRichTextParagraphLayoutBox::GetParagraphLength(long paragraphNumber) const
+{
+ wxRichTextParagraph* para = GetParagraphAtLine(paragraphNumber);
+ if (para)
+ return para->GetRange().GetLength() - 1; // don't include newline
+ else
+ return 0;
+}
+
+/// Get the text of the paragraph
+wxString wxRichTextParagraphLayoutBox::GetParagraphText(long paragraphNumber) const
+{
+ wxRichTextParagraph* para = GetParagraphAtLine(paragraphNumber);
+ if (para)
+ return para->GetTextForRange(para->GetRange());
+ else
+ return wxEmptyString;
+}
+
+/// Convert zero-based line column and paragraph number to a position.
+long wxRichTextParagraphLayoutBox::XYToPosition(long x, long y) const
+{
+ wxRichTextParagraph* para = GetParagraphAtLine(y);
+ if (para)
+ {
+ return para->GetRange().GetStart() + x;
+ }
+ else
+ return -1;
+}
+
+/// Convert zero-based position to line column and paragraph number
+bool wxRichTextParagraphLayoutBox::PositionToXY(long pos, long* x, long* y) const
+{
+ wxRichTextParagraph* para = GetParagraphAtPosition(pos);
+ if (para)
+ {
+ int count = 0;
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+ if (child == para)
+ break;
+ count ++;
+ node = node->GetNext();
+ }
+
+ *y = count;
+ *x = pos - para->GetRange().GetStart();
+
+ return true;
+ }
+ else
+ return false;
+}
+
+/// Get the leaf object in a paragraph at this position.
+/// Given a line number, get the corresponding wxRichTextLine object.
+wxRichTextObject* wxRichTextParagraphLayoutBox::GetLeafObjectAtPosition(long position) const
+{
+ wxRichTextParagraph* para = GetParagraphAtPosition(position);
+ if (para)
+ {
+ wxRichTextObjectList::compatibility_iterator node = para->GetChildren().GetFirst();
+
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+ if (child->GetRange().Contains(position))
+ return child;
+
+ node = node->GetNext();
+ }
+ if (position == para->GetRange().GetEnd() && para->GetChildCount() > 0)
+ return para->GetChildren().GetLast()->GetData();
+ }
+ return NULL;
+}
+
+/// Set character or paragraph text attributes: apply character styles only to immediate text nodes
+bool wxRichTextParagraphLayoutBox::SetStyle(const wxRichTextRange& range, const wxRichTextAttr& style, int flags)
+{
+ bool characterStyle = false;
+ bool paragraphStyle = false;
+
+ if (style.IsCharacterStyle())
+ characterStyle = true;
+ if (style.IsParagraphStyle())
+ paragraphStyle = true;
+
+ wxRichTextBuffer* buffer = GetBuffer();
+
+ bool withUndo = ((flags & wxRICHTEXT_SETSTYLE_WITH_UNDO) != 0);
+ bool applyMinimal = ((flags & wxRICHTEXT_SETSTYLE_OPTIMIZE) != 0);
+ bool parasOnly = ((flags & wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY) != 0);
+ bool charactersOnly = ((flags & wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY) != 0);
+ bool resetExistingStyle = ((flags & wxRICHTEXT_SETSTYLE_RESET) != 0);
+ bool removeStyle = ((flags & wxRICHTEXT_SETSTYLE_REMOVE) != 0);
+
+ // Apply paragraph style first, if any
+ wxRichTextAttr wholeStyle(style);
+
+ if (!removeStyle && wholeStyle.HasParagraphStyleName() && buffer->GetStyleSheet())
+ {
+ wxRichTextParagraphStyleDefinition* def = buffer->GetStyleSheet()->FindParagraphStyle(wholeStyle.GetParagraphStyleName());
+ if (def)
+ wxRichTextApplyStyle(wholeStyle, def->GetStyleMergedWithBase(buffer->GetStyleSheet()));
+ }
+
+ // Limit the attributes to be set to the content to only character attributes.
+ wxRichTextAttr characterAttributes(wholeStyle);
+ characterAttributes.SetFlags(characterAttributes.GetFlags() & (wxTEXT_ATTR_CHARACTER));
+
+ if (!removeStyle && characterAttributes.HasCharacterStyleName() && buffer->GetStyleSheet())
+ {
+ wxRichTextCharacterStyleDefinition* def = buffer->GetStyleSheet()->FindCharacterStyle(characterAttributes.GetCharacterStyleName());
+ if (def)
+ wxRichTextApplyStyle(characterAttributes, def->GetStyleMergedWithBase(buffer->GetStyleSheet()));
+ }
+
+ // If we are associated with a control, make undoable; otherwise, apply immediately
+ // to the data.
+
+ bool haveControl = (buffer->GetRichTextCtrl() != NULL);
+
+ wxRichTextAction* action = NULL;
+
+ if (haveControl && withUndo)
+ {
+ action = new wxRichTextAction(NULL, _("Change Style"), wxRICHTEXT_CHANGE_STYLE, buffer, this, buffer->GetRichTextCtrl());
+ action->SetRange(range);
+ action->SetPosition(buffer->GetRichTextCtrl()->GetCaretPosition());
+ }
+
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+ // wxASSERT (para != NULL);
+
+ if (para && para->GetChildCount() > 0)
+ {
+ // Stop searching if we're beyond the range of interest
+ if (para->GetRange().GetStart() > range.GetEnd())
+ break;
+
+ if (!para->GetRange().IsOutside(range))
+ {
+ // We'll be using a copy of the paragraph to make style changes,
+ // not updating the buffer directly.
+ wxRichTextParagraph* newPara wxDUMMY_INITIALIZE(NULL);
+
+ if (haveControl && withUndo)
+ {
+ newPara = new wxRichTextParagraph(*para);
+ action->GetNewParagraphs().AppendChild(newPara);
+
+ // Also store the old ones for Undo
+ action->GetOldParagraphs().AppendChild(new wxRichTextParagraph(*para));
+ }
+ else
+ newPara = para;
+
+ // If we're specifying paragraphs only, then we really mean character formatting
+ // to be included in the paragraph style
+ if ((paragraphStyle || parasOnly) && !charactersOnly)
+ {
+ if (removeStyle)
+ {
+ // Removes the given style from the paragraph
+ wxRichTextRemoveStyle(newPara->GetAttributes(), style);
+ }
+ else if (resetExistingStyle)
+ newPara->GetAttributes() = wholeStyle;
+ else
+ {
+ if (applyMinimal)
+ {
+ // Only apply attributes that will make a difference to the combined
+ // style as seen on the display
+ wxRichTextAttr combinedAttr(para->GetCombinedAttributes(true));
+ wxRichTextApplyStyle(newPara->GetAttributes(), wholeStyle, & combinedAttr);
+ }
+ else
+ wxRichTextApplyStyle(newPara->GetAttributes(), wholeStyle);
+ }
+ }
+
+ // When applying paragraph styles dynamically, don't change the text objects' attributes
+ // since they will computed as needed. Only apply the character styling if it's _only_
+ // character styling. This policy is subject to change and might be put under user control.
+
+ // Hm. we might well be applying a mix of paragraph and character styles, in which
+ // case we _do_ want to apply character styles regardless of what para styles are set.
+ // But if we're applying a paragraph style, which has some character attributes, but
+ // we only want the paragraphs to hold this character style, then we _don't_ want to
+ // apply the character style. So we need to be able to choose.
+
+ if (!parasOnly && (characterStyle|charactersOnly) && range.GetStart() != newPara->GetRange().GetEnd())
+ {
+ wxRichTextRange childRange(range);
+ childRange.LimitTo(newPara->GetRange());
+
+ // Find the starting position and if necessary split it so
+ // we can start applying a different style.
+ // TODO: check that the style actually changes or is different
+ // from style outside of range
+ wxRichTextObject* firstObject wxDUMMY_INITIALIZE(NULL);
+ wxRichTextObject* lastObject wxDUMMY_INITIALIZE(NULL);
+
+ if (childRange.GetStart() == newPara->GetRange().GetStart())
+ firstObject = newPara->GetChildren().GetFirst()->GetData();
+ else
+ firstObject = newPara->SplitAt(range.GetStart());
+
+ // Increment by 1 because we're apply the style one _after_ the split point
+ long splitPoint = childRange.GetEnd();
+ if (splitPoint != newPara->GetRange().GetEnd())
+ splitPoint ++;
+
+ // Find last object
+ if (splitPoint == newPara->GetRange().GetEnd())
+ lastObject = newPara->GetChildren().GetLast()->GetData();
+ else
+ // lastObject is set as a side-effect of splitting. It's
+ // returned as the object before the new object.
+ (void) newPara->SplitAt(splitPoint, & lastObject);
+
+ wxASSERT(firstObject != NULL);
+ wxASSERT(lastObject != NULL);
+
+ if (!firstObject || !lastObject)
+ continue;
+
+ wxRichTextObjectList::compatibility_iterator firstNode = newPara->GetChildren().Find(firstObject);
+ wxRichTextObjectList::compatibility_iterator lastNode = newPara->GetChildren().Find(lastObject);
+
+ wxASSERT(firstNode);
+ wxASSERT(lastNode);
+
+ wxRichTextObjectList::compatibility_iterator node2 = firstNode;
+
+ while (node2)
+ {
+ wxRichTextObject* child = node2->GetData();
+
+ if (removeStyle)
+ {
+ // Removes the given style from the paragraph
+ wxRichTextRemoveStyle(child->GetAttributes(), style);
+ }
+ else if (resetExistingStyle)
+ child->GetAttributes() = characterAttributes;
+ else
+ {
+ if (applyMinimal)
+ {
+ // Only apply attributes that will make a difference to the combined
+ // style as seen on the display
+ wxRichTextAttr combinedAttr(newPara->GetCombinedAttributes(child->GetAttributes(), true));
+ wxRichTextApplyStyle(child->GetAttributes(), characterAttributes, & combinedAttr);
+ }
+ else
+ wxRichTextApplyStyle(child->GetAttributes(), characterAttributes);
+ }
+
+ if (node2 == lastNode)
+ break;
+
+ node2 = node2->GetNext();
+ }
+ }
+ }
+ }
+
+ node = node->GetNext();
+ }
+
+ // Do action, or delay it until end of batch.
+ if (haveControl && withUndo)
+ buffer->SubmitAction(action);
+
+ return true;
+}
+
+// Just change the attributes for this single object.
+void wxRichTextParagraphLayoutBox::SetStyle(wxRichTextObject* obj, const wxRichTextAttr& textAttr, int flags)
+{
+ wxRichTextBuffer* buffer = GetBuffer();
+ bool withUndo = flags & wxRICHTEXT_SETSTYLE_WITH_UNDO;
+ bool resetExistingStyle = ((flags & wxRICHTEXT_SETSTYLE_RESET) != 0);
+ bool haveControl = (buffer->GetRichTextCtrl() != NULL);
+
+ wxRichTextAction *action = NULL;
+ wxRichTextAttr newAttr = obj->GetAttributes();
+ if (resetExistingStyle)
+ newAttr = textAttr;
+ else
+ newAttr.Apply(textAttr);
+
+ if (haveControl && withUndo)
+ {
+ action = new wxRichTextAction(NULL, _("Change Object Style"), wxRICHTEXT_CHANGE_ATTRIBUTES, buffer, obj->GetContainer(), buffer->GetRichTextCtrl());
+ action->SetRange(obj->GetRange().FromInternal());
+ action->SetPosition(buffer->GetRichTextCtrl()->GetCaretPosition());
+ action->MakeObject(obj);
+
+ action->GetAttributes() = newAttr;
+ }
+ else
+ obj->GetAttributes() = newAttr;
+
+ if (haveControl && withUndo)
+ buffer->SubmitAction(action);
+}
+
+/// Get the text attributes for this position.
+bool wxRichTextParagraphLayoutBox::GetStyle(long position, wxRichTextAttr& style)
+{
+ return DoGetStyle(position, style, true);
+}
+
+bool wxRichTextParagraphLayoutBox::GetUncombinedStyle(long position, wxRichTextAttr& style)
+{
+ return DoGetStyle(position, style, false);
+}
+
+/// Implementation helper for GetStyle. If combineStyles is true, combine base, paragraph and
+/// context attributes.
+bool wxRichTextParagraphLayoutBox::DoGetStyle(long position, wxRichTextAttr& style, bool combineStyles)
+{
+ wxRichTextObject* obj wxDUMMY_INITIALIZE(NULL);
+
+ if (style.IsParagraphStyle())
+ {
+ obj = GetParagraphAtPosition(position);
+ if (obj)
+ {
+ if (combineStyles)
+ {
+ // Start with the base style
+ style = GetAttributes();
+
+ // Apply the paragraph style
+ wxRichTextApplyStyle(style, obj->GetAttributes());
+ }
+ else
+ style = obj->GetAttributes();
+
+ return true;
+ }
+ }
+ else
+ {
+ obj = GetLeafObjectAtPosition(position);
+ if (obj)
+ {
+ if (combineStyles)
+ {
+ wxRichTextParagraph* para = wxDynamicCast(obj->GetParent(), wxRichTextParagraph);
+ style = para ? para->GetCombinedAttributes(obj->GetAttributes()) : obj->GetAttributes();
+ }
+ else
+ style = obj->GetAttributes();
+
+ return true;
+ }
+ }
+ return false;
+}
+
+static bool wxHasStyle(long flags, long style)
+{
+ return (flags & style) != 0;
+}
+
+/// Combines 'style' with 'currentStyle' for the purpose of summarising the attributes of a range of
+/// content.
+bool wxRichTextParagraphLayoutBox::CollectStyle(wxRichTextAttr& currentStyle, const wxRichTextAttr& style, wxRichTextAttr& clashingAttr, wxRichTextAttr& absentAttr)
+{
+ currentStyle.CollectCommonAttributes(style, clashingAttr, absentAttr);
+
+ return true;
+}
+
+/// Get the combined style for a range - if any attribute is different within the range,
+/// that attribute is not present within the flags.
+/// *** Note that this is not recursive, and so assumes that content inside a paragraph is not itself
+/// nested.
+bool wxRichTextParagraphLayoutBox::GetStyleForRange(const wxRichTextRange& range, wxRichTextAttr& style)
+{
+ style = wxRichTextAttr();
+
+ wxRichTextAttr clashingAttr;
+ wxRichTextAttr absentAttrPara, absentAttrChar;
+
+ wxRichTextObjectList::compatibility_iterator node = GetChildren().GetFirst();
+ while (node)
+ {
+ wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+ if (para && !(para->GetRange().GetStart() > range.GetEnd() || para->GetRange().GetEnd() < range.GetStart()))
+ {
+ if (para->GetChildren().GetCount() == 0)
+ {
+ wxRichTextAttr paraStyle = para->GetCombinedAttributes(true /* use box attributes */);
+
+ CollectStyle(style, paraStyle, clashingAttr, absentAttrPara);
+ }
+ else
+ {
+ wxRichTextRange paraRange(para->GetRange());
+ paraRange.LimitTo(range);
+
+ // First collect paragraph attributes only
+ wxRichTextAttr paraStyle = para->GetCombinedAttributes();
+ paraStyle.SetFlags(paraStyle.GetFlags() & wxTEXT_ATTR_PARAGRAPH);
+ CollectStyle(style, paraStyle, clashingAttr, absentAttrPara);
+
+ wxRichTextObjectList::compatibility_iterator childNode = para->GetChildren().GetFirst();
+
+ while (childNode)
+ {
+ wxRichTextObject* child = childNode->GetData();
+ if (!(child->GetRange().GetStart() > range.GetEnd() || child->GetRange().GetEnd() < range.GetStart()))
+ {
+ wxRichTextAttr childStyle = para->GetCombinedAttributes(child->GetAttributes(), true /* include box attributes */);
+
+ // Now collect character attributes only
+ childStyle.SetFlags(childStyle.GetFlags() & wxTEXT_ATTR_CHARACTER);
+
+ CollectStyle(style, childStyle, clashingAttr, absentAttrChar);
+ }
+
+ childNode = childNode->GetNext();
+ }
+ }
+ }
+ node = node->GetNext();
+ }
+ return true;
+}
+
+/// Set default style
+bool wxRichTextParagraphLayoutBox::SetDefaultStyle(const wxRichTextAttr& style)
+{
+ m_defaultAttributes = style;
+ return true;
+}
+
+/// Test if this whole range has character attributes of the specified kind. If any
+/// of the attributes are different within the range, the test fails. You
+/// can use this to implement, for example, bold button updating. style must have
+/// flags indicating which attributes are of interest.
+bool wxRichTextParagraphLayoutBox::HasCharacterAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const
+{
+ int foundCount = 0;
+ int matchingCount = 0;
+
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+ // wxASSERT (para != NULL);
+
+ if (para)
+ {
+ // Stop searching if we're beyond the range of interest
+ if (para->GetRange().GetStart() > range.GetEnd())
+ return foundCount == matchingCount && foundCount != 0;
+
+ if (!para->GetRange().IsOutside(range))
+ {
+ wxRichTextObjectList::compatibility_iterator node2 = para->GetChildren().GetFirst();
+
+ while (node2)
+ {
+ wxRichTextObject* child = node2->GetData();
+ // Allow for empty string if no buffer
+ wxRichTextRange childRange = child->GetRange();
+ if (childRange.GetLength() == 0 && GetRange().GetLength() == 1)
+ childRange.SetEnd(childRange.GetEnd()+1);
+
+ if (!childRange.IsOutside(range) && child->IsKindOf(CLASSINFO(wxRichTextPlainText)))
+ {
+ foundCount ++;
+ wxRichTextAttr textAttr = para->GetCombinedAttributes(child->GetAttributes());
+
+ if (wxTextAttrEqPartial(textAttr, style))
+ matchingCount ++;
+ }
+
+ node2 = node2->GetNext();
+ }
+ }
+ }
+
+ node = node->GetNext();
+ }
+
+ return foundCount == matchingCount && foundCount != 0;
+}
+
+/// Test if this whole range has paragraph attributes of the specified kind. If any
+/// of the attributes are different within the range, the test fails. You
+/// can use this to implement, for example, centering button updating. style must have
+/// flags indicating which attributes are of interest.
+bool wxRichTextParagraphLayoutBox::HasParagraphAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const
+{
+ int foundCount = 0;
+ int matchingCount = 0;
+
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+ // wxASSERT (para != NULL);
+
+ if (para)
+ {
+ // Stop searching if we're beyond the range of interest
+ if (para->GetRange().GetStart() > range.GetEnd())
+ return foundCount == matchingCount && foundCount != 0;
+
+ if (!para->GetRange().IsOutside(range))
+ {
+ wxRichTextAttr textAttr = GetAttributes();
+ // Apply the paragraph style
+ wxRichTextApplyStyle(textAttr, para->GetAttributes());
+
+ foundCount ++;
+ if (wxTextAttrEqPartial(textAttr, style))
+ matchingCount ++;
+ }
+ }
+
+ node = node->GetNext();
+ }
+ return foundCount == matchingCount && foundCount != 0;
+}
+
+void wxRichTextParagraphLayoutBox::Reset()
+{
+ Clear();
+
+ wxRichTextBuffer* buffer = GetBuffer();
+ if (buffer && buffer->GetRichTextCtrl())
+ {
+ wxRichTextEvent event(wxEVT_COMMAND_RICHTEXT_BUFFER_RESET, buffer->GetRichTextCtrl()->GetId());
+ event.SetEventObject(buffer->GetRichTextCtrl());
+ event.SetContainer(this);
+
+ buffer->SendEvent(event, true);
+ }
+
+ AddParagraph(wxEmptyString);
+
+ InvalidateHierarchy(wxRICHTEXT_ALL);
+}
+
+/// Invalidate the buffer. With no argument, invalidates whole buffer.
+void wxRichTextParagraphLayoutBox::Invalidate(const wxRichTextRange& invalidRange)
+{
+ wxRichTextCompositeObject::Invalidate(invalidRange);
+
+ DoInvalidate(invalidRange);
+}
+
+// Do the (in)validation for this object only
+void wxRichTextParagraphLayoutBox::DoInvalidate(const wxRichTextRange& invalidRange)
+{
+ if (invalidRange == wxRICHTEXT_ALL)
+ {
+ m_invalidRange = wxRICHTEXT_ALL;
+ }
+ // Already invalidating everything
+ else if (m_invalidRange == wxRICHTEXT_ALL)
+ {
+ }
+ else
+ {
+ if ((invalidRange.GetStart() < m_invalidRange.GetStart()) || m_invalidRange.GetStart() == -1)
+ m_invalidRange.SetStart(invalidRange.GetStart());
+ if (invalidRange.GetEnd() > m_invalidRange.GetEnd())
+ m_invalidRange.SetEnd(invalidRange.GetEnd());
+ }
+}
+
+// Do the (in)validation both up and down the hierarchy
+void wxRichTextParagraphLayoutBox::InvalidateHierarchy(const wxRichTextRange& invalidRange)
+{
+ Invalidate(invalidRange);
+
+ if (invalidRange != wxRICHTEXT_NONE)
+ {
+ // Now go up the hierarchy
+ wxRichTextObject* thisObj = this;
+ wxRichTextObject* p = GetParent();
+ while (p)
+ {
+ wxRichTextParagraphLayoutBox* l = wxDynamicCast(p, wxRichTextParagraphLayoutBox);
+ if (l)
+ l->DoInvalidate(thisObj->GetRange());
+
+ thisObj = p;
+ p = p->GetParent();
+ }
+ }
+}
+
+/// Get invalid range, rounding to entire paragraphs if argument is true.
+wxRichTextRange wxRichTextParagraphLayoutBox::GetInvalidRange(bool wholeParagraphs) const
+{
+ if (m_invalidRange == wxRICHTEXT_ALL || m_invalidRange == wxRICHTEXT_NONE)
+ return m_invalidRange;
+
+ wxRichTextRange range = m_invalidRange;
+
+ if (wholeParagraphs)
+ {
+ wxRichTextParagraph* para1 = GetParagraphAtPosition(range.GetStart());
+ if (para1)
+ range.SetStart(para1->GetRange().GetStart());
+ // floating layout make all child should be relayout
+ range.SetEnd(GetOwnRange().GetEnd());
+ }
+ return range;
+}
+
+/// Apply the style sheet to the buffer, for example if the styles have changed.
+bool wxRichTextParagraphLayoutBox::ApplyStyleSheet(wxRichTextStyleSheet* styleSheet)
+{
+ wxASSERT(styleSheet != NULL);
+ if (!styleSheet)
+ return false;
+
+ int foundCount = 0;
+
+ wxRichTextAttr attr(GetBasicStyle());
+ if (GetBasicStyle().HasParagraphStyleName())
+ {
+ wxRichTextParagraphStyleDefinition* paraDef = styleSheet->FindParagraphStyle(GetBasicStyle().GetParagraphStyleName());
+ if (paraDef)
+ {
+ attr.Apply(paraDef->GetStyleMergedWithBase(styleSheet));
+ SetBasicStyle(attr);
+ foundCount ++;
+ }
+ }
+
+ if (GetBasicStyle().HasCharacterStyleName())
+ {
+ wxRichTextCharacterStyleDefinition* charDef = styleSheet->FindCharacterStyle(GetBasicStyle().GetCharacterStyleName());
+ if (charDef)
+ {
+ attr.Apply(charDef->GetStyleMergedWithBase(styleSheet));
+ SetBasicStyle(attr);
+ foundCount ++;
+ }
+ }
+
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+ // wxASSERT (para != NULL);
+
+ if (para)
+ {
+ // Combine paragraph and list styles. If there is a list style in the original attributes,
+ // the current indentation overrides anything else and is used to find the item indentation.
+ // Also, for applying paragraph styles, consider having 2 modes: (1) we merge with what we have,
+ // thereby taking into account all user changes, (2) reset the style completely (except for indentation/list
+ // exception as above).
+ // Problem: when changing from one list style to another, there's a danger that the level info will get lost.
+ // So when changing a list style interactively, could retrieve level based on current style, then
+ // set appropriate indent and apply new style.
+
+ int outline = -1;
+ int num = -1;
+ if (para->GetAttributes().HasOutlineLevel())
+ outline = para->GetAttributes().GetOutlineLevel();
+ if (para->GetAttributes().HasBulletNumber())
+ num = para->GetAttributes().GetBulletNumber();
+
+ if (!para->GetAttributes().GetParagraphStyleName().IsEmpty() && !para->GetAttributes().GetListStyleName().IsEmpty())
+ {
+ int currentIndent = para->GetAttributes().GetLeftIndent();
+
+ wxRichTextParagraphStyleDefinition* paraDef = styleSheet->FindParagraphStyle(para->GetAttributes().GetParagraphStyleName());
+ wxRichTextListStyleDefinition* listDef = styleSheet->FindListStyle(para->GetAttributes().GetListStyleName());
+ if (paraDef && !listDef)
+ {
+ para->GetAttributes() = paraDef->GetStyleMergedWithBase(styleSheet);
+ foundCount ++;
+ }
+ else if (listDef && !paraDef)
+ {
+ // Set overall style defined for the list style definition
+ para->GetAttributes() = listDef->GetStyleMergedWithBase(styleSheet);
+
+ // Apply the style for this level
+ wxRichTextApplyStyle(para->GetAttributes(), * listDef->GetLevelAttributes(listDef->FindLevelForIndent(currentIndent)));
+ foundCount ++;
+ }
+ else if (listDef && paraDef)
+ {
+ // Combines overall list style, style for level, and paragraph style
+ para->GetAttributes() = listDef->CombineWithParagraphStyle(currentIndent, paraDef->GetStyleMergedWithBase(styleSheet));
+ foundCount ++;
+ }
+ }
+ else if (para->GetAttributes().GetParagraphStyleName().IsEmpty() && !para->GetAttributes().GetListStyleName().IsEmpty())
+ {
+ int currentIndent = para->GetAttributes().GetLeftIndent();
+
+ wxRichTextListStyleDefinition* listDef = styleSheet->FindListStyle(para->GetAttributes().GetListStyleName());
+
+ // Overall list definition style
+ para->GetAttributes() = listDef->GetStyleMergedWithBase(styleSheet);
+
+ // Style for this level
+ wxRichTextApplyStyle(para->GetAttributes(), * listDef->GetLevelAttributes(listDef->FindLevelForIndent(currentIndent)));
+
+ foundCount ++;
+ }
+ else if (!para->GetAttributes().GetParagraphStyleName().IsEmpty() && para->GetAttributes().GetListStyleName().IsEmpty())
+ {
+ wxRichTextParagraphStyleDefinition* def = styleSheet->FindParagraphStyle(para->GetAttributes().GetParagraphStyleName());
+ if (def)
+ {
+ para->GetAttributes() = def->GetStyleMergedWithBase(styleSheet);
+ foundCount ++;
+ }
+ }
+
+ if (outline != -1)
+ para->GetAttributes().SetOutlineLevel(outline);
+ if (num != -1)
+ para->GetAttributes().SetBulletNumber(num);
+ }
+
+ node = node->GetNext();
+ }
+ return foundCount != 0;
+}
+
+/// Set list style
+bool wxRichTextParagraphLayoutBox::SetListStyle(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags, int startFrom, int specifiedLevel)
+{
+ wxRichTextBuffer* buffer = GetBuffer();
+ wxRichTextStyleSheet* styleSheet = buffer->GetStyleSheet();
+
+ bool withUndo = ((flags & wxRICHTEXT_SETSTYLE_WITH_UNDO) != 0);
+ // bool applyMinimal = ((flags & wxRICHTEXT_SETSTYLE_OPTIMIZE) != 0);
+ bool specifyLevel = ((flags & wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL) != 0);
+ bool renumber = ((flags & wxRICHTEXT_SETSTYLE_RENUMBER) != 0);
+
+ // Current number, if numbering
+ int n = startFrom;
+
+ wxASSERT (!specifyLevel || (specifyLevel && (specifiedLevel >= 0)));
+
+ // If we are associated with a control, make undoable; otherwise, apply immediately
+ // to the data.
+
+ bool haveControl = (buffer->GetRichTextCtrl() != NULL);
+
+ wxRichTextAction* action = NULL;
+
+ if (haveControl && withUndo)
+ {
+ action = new wxRichTextAction(NULL, _("Change List Style"), wxRICHTEXT_CHANGE_STYLE, buffer, this, buffer->GetRichTextCtrl());
+ action->SetRange(range);
+ action->SetPosition(buffer->GetRichTextCtrl()->GetCaretPosition());
+ }
+
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+ // wxASSERT (para != NULL);
+
+ if (para && para->GetChildCount() > 0)
+ {
+ // Stop searching if we're beyond the range of interest
+ if (para->GetRange().GetStart() > range.GetEnd())
+ break;
+
+ if (!para->GetRange().IsOutside(range))
+ {
+ // We'll be using a copy of the paragraph to make style changes,
+ // not updating the buffer directly.
+ wxRichTextParagraph* newPara wxDUMMY_INITIALIZE(NULL);
+
+ if (haveControl && withUndo)
+ {
+ newPara = new wxRichTextParagraph(*para);
+ action->GetNewParagraphs().AppendChild(newPara);
+
+ // Also store the old ones for Undo
+ action->GetOldParagraphs().AppendChild(new wxRichTextParagraph(*para));
+ }
+ else
+ newPara = para;
+
+ if (def)
+ {
+ int thisIndent = newPara->GetAttributes().GetLeftIndent();
+ int thisLevel = specifyLevel ? specifiedLevel : def->FindLevelForIndent(thisIndent);
+
+ // How is numbering going to work?
+ // If we are renumbering, or numbering for the first time, we need to keep
+ // track of the number for each level. But we might be simply applying a different
+ // list style.
+ // In Word, applying a style to several paragraphs, even if at different levels,
+ // reverts the level back to the same one. So we could do the same here.
+ // Renumbering will need to be done when we promote/demote a paragraph.
+
+ // Apply the overall list style, and item style for this level
+ wxRichTextAttr listStyle(def->GetCombinedStyleForLevel(thisLevel, styleSheet));
+ wxRichTextApplyStyle(newPara->GetAttributes(), listStyle);
+
+ // Now we need to do numbering
+ if (renumber)
+ {
+ newPara->GetAttributes().SetBulletNumber(n);
+ }
+
+ n ++;
+ }
+ else if (!newPara->GetAttributes().GetListStyleName().IsEmpty())
+ {
+ // if def is NULL, remove list style, applying any associated paragraph style
+ // to restore the attributes
+
+ newPara->GetAttributes().SetListStyleName(wxEmptyString);
+ newPara->GetAttributes().SetLeftIndent(0, 0);
+ newPara->GetAttributes().SetBulletText(wxEmptyString);
+
+ // Eliminate the main list-related attributes
+ 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);
+
+ if (styleSheet && !newPara->GetAttributes().GetParagraphStyleName().IsEmpty())
+ {
+ wxRichTextParagraphStyleDefinition* def = styleSheet->FindParagraphStyle(newPara->GetAttributes().GetParagraphStyleName());
+ if (def)
+ {
+ newPara->GetAttributes() = def->GetStyleMergedWithBase(styleSheet);
+ }
+ }
+ }
+ }
+ }
+
+ node = node->GetNext();
+ }
+
+ // Do action, or delay it until end of batch.
+ if (haveControl && withUndo)
+ buffer->SubmitAction(action);
+
+ return true;
+}
+
+bool wxRichTextParagraphLayoutBox::SetListStyle(const wxRichTextRange& range, const wxString& defName, int flags, int startFrom, int specifiedLevel)
+{
+ wxRichTextBuffer* buffer = GetBuffer();
+ if (buffer && buffer->GetStyleSheet())
+ {
+ wxRichTextListStyleDefinition* def = buffer->GetStyleSheet()->FindListStyle(defName);
+ if (def)
+ return SetListStyle(range, def, flags, startFrom, specifiedLevel);
+ }
+ return false;
+}
+
+/// Clear list for given range
+bool wxRichTextParagraphLayoutBox::ClearListStyle(const wxRichTextRange& range, int flags)
+{
+ return SetListStyle(range, NULL, flags);
+}
+
+/// Number/renumber any list elements in the given range
+bool wxRichTextParagraphLayoutBox::NumberList(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags, int startFrom, int specifiedLevel)
+{
+ return DoNumberList(range, range, 0, def, flags, startFrom, specifiedLevel);
+}
+
+/// Number/renumber any list elements in the given range. Also do promotion or demotion of items, if specified
+bool wxRichTextParagraphLayoutBox::DoNumberList(const wxRichTextRange& range, const wxRichTextRange& promotionRange, int promoteBy,
+ wxRichTextListStyleDefinition* def, int flags, int startFrom, int specifiedLevel)
+{
+ wxRichTextBuffer* buffer = GetBuffer();
+ wxRichTextStyleSheet* styleSheet = buffer->GetStyleSheet();
+
+ bool withUndo = ((flags & wxRICHTEXT_SETSTYLE_WITH_UNDO) != 0);
+ // bool applyMinimal = ((flags & wxRICHTEXT_SETSTYLE_OPTIMIZE) != 0);
+#if wxDEBUG_LEVEL
+ bool specifyLevel = ((flags & wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL) != 0);
+#endif
+
+ bool renumber = ((flags & wxRICHTEXT_SETSTYLE_RENUMBER) != 0);
+
+ // Max number of levels
+ const int maxLevels = 10;
+
+ // The level we're looking at now
+ int currentLevel = -1;
+
+ // The item number for each level
+ int levels[maxLevels];
+ int i;
+
+ // Reset all numbering
+ for (i = 0; i < maxLevels; i++)
+ {
+ if (startFrom != -1)
+ levels[i] = startFrom-1;
+ else if (renumber) // start again
+ levels[i] = 0;
+ else
+ levels[i] = -1; // start from the number we found, if any
+ }
+
+ wxASSERT(!specifyLevel || (specifyLevel && (specifiedLevel >= 0)));
+
+ // If we are associated with a control, make undoable; otherwise, apply immediately
+ // to the data.
+
+ bool haveControl = (buffer->GetRichTextCtrl() != NULL);
+
+ wxRichTextAction* action = NULL;
+
+ if (haveControl && withUndo)
+ {
+ action = new wxRichTextAction(NULL, _("Renumber List"), wxRICHTEXT_CHANGE_STYLE, buffer, this, buffer->GetRichTextCtrl());
+ action->SetRange(range);
+ action->SetPosition(buffer->GetRichTextCtrl()->GetCaretPosition());
+ }
+
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextParagraph* para = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+ // wxASSERT (para != NULL);
+
+ if (para && para->GetChildCount() > 0)
+ {
+ // Stop searching if we're beyond the range of interest
+ if (para->GetRange().GetStart() > range.GetEnd())
+ break;
+
+ if (!para->GetRange().IsOutside(range))
+ {
+ // We'll be using a copy of the paragraph to make style changes,
+ // not updating the buffer directly.
+ wxRichTextParagraph* newPara wxDUMMY_INITIALIZE(NULL);
+
+ if (haveControl && withUndo)
+ {
+ newPara = new wxRichTextParagraph(*para);
+ action->GetNewParagraphs().AppendChild(newPara);
+
+ // Also store the old ones for Undo
+ action->GetOldParagraphs().AppendChild(new wxRichTextParagraph(*para));
+ }
+ else
+ newPara = para;
+
+ wxRichTextListStyleDefinition* defToUse = def;
+ if (!defToUse)
+ {
+ if (styleSheet && !newPara->GetAttributes().GetListStyleName().IsEmpty())
+ defToUse = styleSheet->FindListStyle(newPara->GetAttributes().GetListStyleName());
+ }
+
+ if (defToUse)
+ {
+ int thisIndent = newPara->GetAttributes().GetLeftIndent();
+ int thisLevel = defToUse->FindLevelForIndent(thisIndent);
+
+ // If we've specified a level to apply to all, change the level.
+ if (specifiedLevel != -1)
+ thisLevel = specifiedLevel;
+
+ // Do promotion if specified
+ if ((promoteBy != 0) && !para->GetRange().IsOutside(promotionRange))
+ {
+ thisLevel = thisLevel - promoteBy;
+ if (thisLevel < 0)
+ thisLevel = 0;
+ if (thisLevel > 9)
+ thisLevel = 9;
+ }
+
+ // Apply the overall list style, and item style for this level
+ wxRichTextAttr listStyle(defToUse->GetCombinedStyleForLevel(thisLevel, styleSheet));
+ wxRichTextApplyStyle(newPara->GetAttributes(), listStyle);
+
+ // OK, we've (re)applied the style, now let's get the numbering right.
+
+ if (currentLevel == -1)
+ currentLevel = thisLevel;
+
+ // Same level as before, do nothing except increment level's number afterwards
+ if (currentLevel == thisLevel)
+ {
+ }
+ // A deeper level: start renumbering all levels after current level
+ else if (thisLevel > currentLevel)
+ {
+ for (i = currentLevel+1; i <= thisLevel; i++)
+ {
+ levels[i] = 0;
+ }
+ currentLevel = thisLevel;
+ }
+ else if (thisLevel < currentLevel)
+ {
+ currentLevel = thisLevel;
+ }
+
+ // Use the current numbering if -1 and we have a bullet number already
+ if (levels[currentLevel] == -1)
+ {
+ if (newPara->GetAttributes().HasBulletNumber())
+ levels[currentLevel] = newPara->GetAttributes().GetBulletNumber();
+ else
+ levels[currentLevel] = 1;
+ }
+ else
+ {
+ levels[currentLevel] ++;
+ }
+
+ newPara->GetAttributes().SetBulletNumber(levels[currentLevel]);
+
+ // Create the bullet text if an outline list
+ if (listStyle.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_OUTLINE)
+ {
+ wxString text;
+ for (i = 0; i <= currentLevel; i++)
+ {
+ if (!text.IsEmpty())
+ text += wxT(".");
+ text += wxString::Format(wxT("%d"), levels[i]);
+ }
+ newPara->GetAttributes().SetBulletText(text);
+ }
+ }
+ }
+ }
+
+ node = node->GetNext();
+ }
+
+ // Do action, or delay it until end of batch.
+ if (haveControl && withUndo)
+ buffer->SubmitAction(action);
+
+ return true;
+}
+
+bool wxRichTextParagraphLayoutBox::NumberList(const wxRichTextRange& range, const wxString& defName, int flags, int startFrom, int specifiedLevel)
+{
+ wxRichTextBuffer* buffer = GetBuffer();
+ if (buffer->GetStyleSheet())
+ {
+ wxRichTextListStyleDefinition* def = NULL;
+ if (!defName.IsEmpty())
+ def = buffer->GetStyleSheet()->FindListStyle(defName);
+ return NumberList(range, def, flags, startFrom, specifiedLevel);
+ }
+ return false;
+}
+
+/// Promote the list items within the given range. promoteBy can be a positive or negative number, e.g. 1 or -1
+bool wxRichTextParagraphLayoutBox::PromoteList(int promoteBy, const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags, int specifiedLevel)
+{
+ // TODO
+ // One strategy is to first work out the range within which renumbering must occur. Then could pass these two ranges
+ // to NumberList with a flag indicating promotion is required within one of the ranges.
+ // Find first and last paragraphs in range. Then for first, calculate new indentation and look back until we find
+ // a paragraph that either has no list style, or has one that is different or whose indentation is less.
+ // We start renumbering from the para after that different para we found. We specify that the numbering of that
+ // list position will start from 1.
+ // Similarly, we look after the last para in the promote range for an indentation that is less (or no list style).
+ // We can end the renumbering at this point.
+
+ // For now, only renumber within the promotion range.
+
+ return DoNumberList(range, range, promoteBy, def, flags, 1, specifiedLevel);
+}
+
+bool wxRichTextParagraphLayoutBox::PromoteList(int promoteBy, const wxRichTextRange& range, const wxString& defName, int flags, int specifiedLevel)
+{
+ wxRichTextBuffer* buffer = GetBuffer();
+ if (buffer->GetStyleSheet())
+ {
+ wxRichTextListStyleDefinition* def = NULL;
+ if (!defName.IsEmpty())
+ def = buffer->GetStyleSheet()->FindListStyle(defName);
+ return PromoteList(promoteBy, range, def, flags, specifiedLevel);
+ }
+ return false;
+}
+
+/// Fills in the attributes for numbering a paragraph after previousParagraph. It also finds the
+/// position of the paragraph that it had to start looking from.
+bool wxRichTextParagraphLayoutBox::FindNextParagraphNumber(wxRichTextParagraph* previousParagraph, wxRichTextAttr& attr) const
+{
+ if (!previousParagraph->GetAttributes().HasFlag(wxTEXT_ATTR_BULLET_STYLE) || previousParagraph->GetAttributes().GetBulletStyle() == wxTEXT_ATTR_BULLET_STYLE_NONE)
+ return false;
+
+ wxRichTextBuffer* buffer = GetBuffer();
+ wxRichTextStyleSheet* styleSheet = buffer->GetStyleSheet();
+ if (styleSheet && !previousParagraph->GetAttributes().GetListStyleName().IsEmpty())
+ {
+ wxRichTextListStyleDefinition* def = styleSheet->FindListStyle(previousParagraph->GetAttributes().GetListStyleName());
+ if (def)
+ {
+ // int thisIndent = previousParagraph->GetAttributes().GetLeftIndent();
+ // int thisLevel = def->FindLevelForIndent(thisIndent);
+
+ bool isOutline = (previousParagraph->GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_OUTLINE) != 0;
+
+ attr.SetFlags(previousParagraph->GetAttributes().GetFlags() & (wxTEXT_ATTR_BULLET_STYLE|wxTEXT_ATTR_BULLET_NUMBER|wxTEXT_ATTR_BULLET_TEXT|wxTEXT_ATTR_BULLET_NAME));
+ if (previousParagraph->GetAttributes().HasBulletName())
+ attr.SetBulletName(previousParagraph->GetAttributes().GetBulletName());
+ attr.SetBulletStyle(previousParagraph->GetAttributes().GetBulletStyle());
+ attr.SetListStyleName(previousParagraph->GetAttributes().GetListStyleName());
+
+ int nextNumber = previousParagraph->GetAttributes().GetBulletNumber() + 1;
+ attr.SetBulletNumber(nextNumber);
+
+ if (isOutline)
+ {
+ wxString text = previousParagraph->GetAttributes().GetBulletText();
+ if (!text.IsEmpty())
+ {
+ int pos = text.Find(wxT('.'), true);
+ if (pos != wxNOT_FOUND)
+ {
+ text = text.Mid(0, text.Length() - pos - 1);
+ }
+ else
+ text = wxEmptyString;
+ if (!text.IsEmpty())
+ text += wxT(".");
+ text += wxString::Format(wxT("%d"), nextNumber);
+ attr.SetBulletText(text);
+ }
+ }
+
+ return true;
+ }
+ else
+ return false;
+ }
+ else
+ return false;
+}
+
+/*!
+ * wxRichTextParagraph
+ * This object represents a single paragraph (or in a straight text editor, a line).
+ */
+
+IMPLEMENT_DYNAMIC_CLASS(wxRichTextParagraph, wxRichTextCompositeObject)
+
+wxArrayInt wxRichTextParagraph::sm_defaultTabs;
+
+wxRichTextParagraph::wxRichTextParagraph(wxRichTextObject* parent, wxRichTextAttr* style):
+ wxRichTextCompositeObject(parent)
+{
+ if (style)
+ SetAttributes(*style);
+}
+
+wxRichTextParagraph::wxRichTextParagraph(const wxString& text, wxRichTextObject* parent, wxRichTextAttr* paraStyle, wxRichTextAttr* charStyle):
+ wxRichTextCompositeObject(parent)
+{
+ if (paraStyle)
+ SetAttributes(*paraStyle);
+
+ AppendChild(new wxRichTextPlainText(text, this, charStyle));
+}
+
+wxRichTextParagraph::~wxRichTextParagraph()
+{
+ ClearLines();
+}
+
+/// Draw the item
+bool wxRichTextParagraph::Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int WXUNUSED(descent), int style)
+{
+ if (!IsShown())
+ return true;
+
+ // Currently we don't merge these attributes with the parent, but we
+ // should consider whether we should (e.g. if we set a border colour
+ // for all paragraphs). But generally box attributes are likely to be
+ // different for different objects.
+ wxRect paraRect = GetRect();
+ DrawBoxAttributes(dc, GetBuffer(), GetAttributes(), paraRect);
+
+ wxRichTextAttr attr = GetCombinedAttributes();
+
+ // Draw the bullet, if any
+ if (attr.GetBulletStyle() != wxTEXT_ATTR_BULLET_STYLE_NONE)
+ {
+ if (attr.GetLeftSubIndent() != 0)
+ {
+ int spaceBeforePara = ConvertTenthsMMToPixels(dc, attr.GetParagraphSpacingBefore());
+ int leftIndent = ConvertTenthsMMToPixels(dc, attr.GetLeftIndent());
+
+ wxRichTextAttr bulletAttr(GetCombinedAttributes());
+
+ // Combine with the font of the first piece of content, if one is specified
+ if (GetChildren().GetCount() > 0)
+ {
+ wxRichTextObject* firstObj = (wxRichTextObject*) GetChildren().GetFirst()->GetData();
+ if (!firstObj->IsFloatable() && firstObj->GetAttributes().HasFont())
+ {
+ wxRichTextApplyStyle(bulletAttr, firstObj->GetAttributes());
+ }
+ }
+
+ // Get line height from first line, if any
+ wxRichTextLine* line = m_cachedLines.GetFirst() ? (wxRichTextLine* ) m_cachedLines.GetFirst()->GetData() : NULL;
+
+ wxPoint linePos;
+ int lineHeight wxDUMMY_INITIALIZE(0);
+ if (line)
+ {
+ lineHeight = line->GetSize().y;
+ linePos = line->GetPosition() + GetPosition();
+ }
+ else
+ {
+ wxFont font;
+ if (bulletAttr.HasFont() && GetBuffer())
+ font = GetBuffer()->GetFontTable().FindFont(bulletAttr);
+ else
+ font = (*wxNORMAL_FONT);
+
+ wxCheckSetFont(dc, font);
+
+ lineHeight = dc.GetCharHeight();
+ linePos = GetPosition();
+ linePos.y += spaceBeforePara;
+ }
+
+ wxRect bulletRect(GetPosition().x + leftIndent, linePos.y, linePos.x - (GetPosition().x + leftIndent), lineHeight);
+
+ if (attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_BITMAP)
+ {
+ if (wxRichTextBuffer::GetRenderer())
+ wxRichTextBuffer::GetRenderer()->DrawBitmapBullet(this, dc, bulletAttr, bulletRect);
+ }
+ else if (attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_STANDARD)
+ {
+ if (wxRichTextBuffer::GetRenderer())
+ wxRichTextBuffer::GetRenderer()->DrawStandardBullet(this, dc, bulletAttr, bulletRect);
+ }
+ else
+ {
+ wxString bulletText = GetBulletText();
+
+ if (!bulletText.empty() && wxRichTextBuffer::GetRenderer())
+ wxRichTextBuffer::GetRenderer()->DrawTextBullet(this, dc, bulletAttr, bulletRect, bulletText);
+ }
+ }
+ }
+
+ // Draw the range for each line, one object at a time.
+
+ wxRichTextLineList::compatibility_iterator node = m_cachedLines.GetFirst();
+ while (node)
+ {
+ wxRichTextLine* line = node->GetData();
+ wxRichTextRange lineRange = line->GetAbsoluteRange();
+
+ // Lines are specified relative to the paragraph
+
+ wxPoint linePosition = line->GetPosition() + GetPosition();
+
+ // Don't draw if off the screen
+ if (((style & wxRICHTEXT_DRAW_IGNORE_CACHE) != 0) || ((linePosition.y + line->GetSize().y) >= rect.y && linePosition.y <= rect.y + rect.height))
+ {
+ wxPoint objectPosition = linePosition;
+ int maxDescent = line->GetDescent();
+
+ // Loop through objects until we get to the one within range
+ wxRichTextObjectList::compatibility_iterator node2 = m_children.GetFirst();
+
+ int i = 0;
+ while (node2)
+ {
+ wxRichTextObject* child = node2->GetData();
+
+ if (!child->IsFloating() && child->GetRange().GetLength() > 0 && !child->GetRange().IsOutside(lineRange) && !lineRange.IsOutside(range))
+ {
+ // Draw this part of the line at the correct position
+ wxRichTextRange objectRange(child->GetRange());
+ objectRange.LimitTo(lineRange);
+
+ wxSize objectSize;
+ if (child->IsTopLevel())
+ {
+ objectSize = child->GetCachedSize();
+ objectRange = child->GetOwnRange();
+ }
+ else
+ {
+#if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING && wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
+ if (i < (int) line->GetObjectSizes().GetCount())
+ {
+ objectSize.x = line->GetObjectSizes()[(size_t) i];
+ }
+ else
+#endif
+ {
+ int descent = 0;
+ child->GetRangeSize(objectRange, objectSize, descent, dc, wxRICHTEXT_UNFORMATTED, objectPosition);
+ }
+ }
+
+ // Use the child object's width, but the whole line's height
+ wxRect childRect(objectPosition, wxSize(objectSize.x, line->GetSize().y));
+ child->Draw(dc, objectRange, selection, childRect, maxDescent, style);
+
+ objectPosition.x += objectSize.x;
+ i ++;
+ }
+ else if (child->GetRange().GetStart() > lineRange.GetEnd())
+ // Can break out of inner loop now since we've passed this line's range
+ break;
+
+ node2 = node2->GetNext();
+ }
+ }
+
+ node = node->GetNext();
+ }
+
+ return true;
+}
+
+// Get the range width using partial extents calculated for the whole paragraph.
+static int wxRichTextGetRangeWidth(const wxRichTextParagraph& para, const wxRichTextRange& range, const wxArrayInt& partialExtents)
+{
+ wxASSERT(partialExtents.GetCount() >= (size_t) range.GetLength());
+
+ if (partialExtents.GetCount() < (size_t) range.GetLength())
+ return 0;
+
+ int leftMostPos = 0;
+ if (range.GetStart() - para.GetRange().GetStart() > 0)
+ leftMostPos = partialExtents[range.GetStart() - para.GetRange().GetStart() - 1];
+
+ int rightMostPos = partialExtents[range.GetEnd() - para.GetRange().GetStart()];
+
+ int w = rightMostPos - leftMostPos;
+
+ return w;
+}
+
+/// Lay the item out
+bool wxRichTextParagraph::Layout(wxDC& dc, const wxRect& rect, int style)
+{
+ // Deal with floating objects firstly before the normal layout
+ wxRichTextBuffer* buffer = GetBuffer();
+ wxASSERT(buffer);
+ wxRichTextFloatCollector* collector = GetContainer()->GetFloatCollector();
+ wxASSERT(collector);
+ LayoutFloat(dc, rect, style, collector);
+
+ wxRichTextAttr attr = GetCombinedAttributes();
+
+ // ClearLines();
+
+ // Increase the size of the paragraph due to spacing
+ int spaceBeforePara = ConvertTenthsMMToPixels(dc, attr.GetParagraphSpacingBefore());
+ int spaceAfterPara = ConvertTenthsMMToPixels(dc, attr.GetParagraphSpacingAfter());
+ int leftIndent = ConvertTenthsMMToPixels(dc, attr.GetLeftIndent());
+ int leftSubIndent = ConvertTenthsMMToPixels(dc, attr.GetLeftSubIndent());
+ int rightIndent = ConvertTenthsMMToPixels(dc, attr.GetRightIndent());
+
+ int lineSpacing = 0;
+
+ // Let's assume line spacing of 10 is normal, 15 is 1.5, 20 is 2, etc.
+ if (attr.HasLineSpacing() && attr.GetLineSpacing() > 0 && attr.GetFont().IsOk())
+ {
+ wxCheckSetFont(dc, attr.GetFont());
+ lineSpacing = (int) (double(dc.GetCharHeight()) * (double(attr.GetLineSpacing())/10.0 - 1.0));
+ }
+
+ // Start position for each line relative to the paragraph
+ int startPositionFirstLine = leftIndent;
+ int startPositionSubsequentLines = leftIndent + leftSubIndent;
+
+ // If we have a bullet in this paragraph, the start position for the first line's text
+ // is actually leftIndent + leftSubIndent.
+ if (attr.GetBulletStyle() != wxTEXT_ATTR_BULLET_STYLE_NONE)
+ startPositionFirstLine = startPositionSubsequentLines;
+
+ long lastEndPos = GetRange().GetStart()-1;
+ long lastCompletedEndPos = lastEndPos;
+
+ int currentWidth = 0;
+ SetPosition(rect.GetPosition());
+
+ wxPoint currentPosition(0, spaceBeforePara); // We will calculate lines relative to paragraph
+ int lineHeight = 0;
+ int maxWidth = 0;
+ int maxHeight = currentPosition.y;
+ int maxAscent = 0;
+ int maxDescent = 0;
+ int lineCount = 0;
+ int lineAscent = 0;
+ int lineDescent = 0;
+
+ wxRichTextObjectList::compatibility_iterator node;
+
+#if wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
+ wxUnusedVar(style);
+ wxArrayInt partialExtents;
+
+ wxSize paraSize;
+ int paraDescent = 0;
+
+ // This calculates the partial text extents
+ GetRangeSize(GetRange(), paraSize, paraDescent, dc, wxRICHTEXT_UNFORMATTED|wxRICHTEXT_CACHE_SIZE, rect.GetPosition(), & partialExtents);
+#else
+ node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+
+ //child->SetCachedSize(wxDefaultSize);
+ child->Layout(dc, rect, style);
+
+ node = node->GetNext();
+ }
+
+#endif
+
+ // Split up lines
+
+ // We may need to go back to a previous child, in which case create the new line,
+ // find the child corresponding to the start position of the string, and
+ // continue.
+
+ wxRect availableRect;
+
+ node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+
+ // If floating, ignore. We already laid out floats.
+ // Also ignore if empty object, except if we haven't got any
+ // size yet.
+ if (child->IsFloating() || !child->IsShown() ||
+ (child->GetRange().GetLength() == 0 && maxHeight > spaceBeforePara)
+ )
+ {
+ node = node->GetNext();
+ continue;
+ }
+
+ // If this is e.g. a composite text box, it will need to be laid out itself.
+ // But if just a text fragment or image, for example, this will
+ // do nothing. NB: won't we need to set the position after layout?
+ // since for example if position is dependent on vertical line size, we
+ // can't tell the position until the size is determined. So possibly introduce
+ // another layout phase.
+
+ // We may only be looking at part of a child, if we searched back for wrapping
+ // and found a suitable point some way into the child. So get the size for the fragment
+ // if necessary.
+
+ long nextBreakPos = GetFirstLineBreakPosition(lastEndPos+1);
+ long lastPosToUse = child->GetRange().GetEnd();
+ bool lineBreakInThisObject = (nextBreakPos > -1 && nextBreakPos <= child->GetRange().GetEnd());
+
+ if (lineBreakInThisObject)
+ lastPosToUse = nextBreakPos;
+
+ wxSize childSize;
+ int childDescent = 0;
+
+ int startOffset = (lineCount == 0 ? startPositionFirstLine : startPositionSubsequentLines);
+ availableRect = wxRect(rect.x + startOffset, rect.y + currentPosition.y,
+ rect.width - startOffset - rightIndent, rect.height);
+
+ if (child->IsTopLevel())
+ {
+ wxSize oldSize = child->GetCachedSize();
+
+ child->Invalidate(wxRICHTEXT_ALL);
+ child->SetPosition(wxPoint(0, 0));
+
+ // Lays out the object first with a given amount of space, and then if no width was specified in attr,
+ // lays out the object again using the minimum size
+ // The position will be determined by its location in its line,
+ // and not by the child's actual position.
+ child->LayoutToBestSize(dc, buffer,
+ GetAttributes(), child->GetAttributes(), availableRect, style);
+
+ if (oldSize != child->GetCachedSize())
+ {
+ partialExtents.Clear();
+
+ // Recalculate the partial text extents since the child object changed size
+ GetRangeSize(GetRange(), paraSize, paraDescent, dc, wxRICHTEXT_UNFORMATTED|wxRICHTEXT_CACHE_SIZE, wxPoint(0,0), & partialExtents);
+ }
+ }
+
+ // Problem: we need to layout composites here for which we need the available width,
+ // but we can't get the available width without using the float collector which
+ // needs to know the object height.
+
+ if ((nextBreakPos == -1) && (lastEndPos == child->GetRange().GetStart() - 1)) // i.e. we want to get the whole thing
+ {
+ childSize = child->GetCachedSize();
+ childDescent = child->GetDescent();
+ }
+ else
+ {
+#if wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
+ // Get height only, then the width using the partial extents
+ GetRangeSize(wxRichTextRange(lastEndPos+1, lastPosToUse), childSize, childDescent, dc, wxRICHTEXT_UNFORMATTED|wxRICHTEXT_HEIGHT_ONLY);
+ childSize.x = wxRichTextGetRangeWidth(*this, wxRichTextRange(lastEndPos+1, lastPosToUse), partialExtents);
+#else
+ GetRangeSize(wxRichTextRange(lastEndPos+1, lastPosToUse), childSize, childDescent, dc, wxRICHTEXT_UNFORMATTED, rect.GetPosition());
+#endif
+ }
+
+ bool doLoop = true;
+ int loopIterations = 0;
+
+ // If there are nested objects that need to lay themselves out, we have to do this in a
+ // loop because the height of the object may well depend on the available width.
+ // And because of floating object positioning, the available width depends on the
+ // height of the object and whether it will clash with the floating objects.
+ // So, we see whether the available width changes due to the presence of floating images.
+ // If it does, then we'll use the new restricted width to find the object height again.
+ // If this causes another restriction in the available width, we'll try again, until
+ // either we lose patience or the available width settles down.
+ do
+ {
+ loopIterations ++;
+
+ wxRect oldAvailableRect = availableRect;
+
+ // Available width depends on the floating objects and the line height.
+ // Note: the floating objects may be placed vertically along the two side of
+ // buffer, so we may have different available line widths with different
+ // [startY, endY]. So, we can't determine how wide the available
+ // space is until we know the exact line height.
+ lineDescent = wxMax(childDescent, maxDescent);
+ lineAscent = wxMax(childSize.y-childDescent, maxAscent);
+ lineHeight = lineDescent + lineAscent;
+ wxRect floatAvailableRect = collector->GetAvailableRect(rect.y + currentPosition.y, rect.y + currentPosition.y + lineHeight);
+
+ // Adjust availableRect to the space that is available when taking floating objects into account.
+
+ if (floatAvailableRect.x + startOffset > availableRect.x)
+ {
+ int newX = floatAvailableRect.x + startOffset;
+ int newW = availableRect.width - (newX - availableRect.x);
+ availableRect.x = newX;
+ availableRect.width = newW;
+ }
+
+ if (floatAvailableRect.width < availableRect.width)
+ availableRect.width = floatAvailableRect.width;
+
+ currentPosition.x = availableRect.x - rect.x;
+
+ if (child->IsTopLevel() && loopIterations <= 20)
+ {
+ if (availableRect != oldAvailableRect)
+ {
+ wxSize oldSize = child->GetCachedSize();
+
+ //child->SetCachedSize(wxDefaultSize);
+ // Lays out the object first with a given amount of space, and then if no width was specified in attr,
+ // lays out the object again using the minimum size
+ child->Invalidate(wxRICHTEXT_ALL);
+ child->LayoutToBestSize(dc, buffer,
+ GetAttributes(), child->GetAttributes(), availableRect, style);
+ childSize = child->GetCachedSize();
+ childDescent = child->GetDescent();
+ //child->SetPosition(availableRect.GetPosition());
+
+ if (oldSize != child->GetCachedSize())
+ {
+ partialExtents.Clear();
+
+ // Recalculate the partial text extents since the child object changed size
+ GetRangeSize(GetRange(), paraSize, paraDescent, dc, wxRICHTEXT_UNFORMATTED|wxRICHTEXT_CACHE_SIZE, wxPoint(0,0), & partialExtents);
+ }
+
+ // Go around the loop finding the available rect for the given floating objects
+ }
+ else
+ doLoop = false;
+ }
+ else
+ doLoop = false;
+ }
+ while (doLoop);
+
+ // Cases:
+ // 1) There was a line break BEFORE the natural break
+ // 2) There was a line break AFTER the natural break
+ // 3) It's the last line
+ // 4) The child still fits (carry on) - 'else' clause
+
+ if ((lineBreakInThisObject && (childSize.x + currentWidth <= availableRect.width))
+ ||
+ (childSize.x + currentWidth > availableRect.width)
+ ||
+ ((childSize.x + currentWidth <= availableRect.width) && !node->GetNext())
+
+ )
+ {
+ if (child->IsTopLevel())
+ {
+ // We can move it to the correct position at this point
+ child->Move(GetPosition() + wxPoint(currentWidth, currentPosition.y));
+ }
+
+ long wrapPosition = 0;
+ if ((childSize.x + currentWidth <= availableRect.width) && !node->GetNext() && !lineBreakInThisObject)
+ wrapPosition = child->GetRange().GetEnd();
+ else
+
+ // Find a place to wrap. This may walk back to previous children,
+ // for example if a word spans several objects.
+ // Note: one object must contains only one wxTextAtrr, so the line height will not
+ // change inside one object. Thus, we can pass the remain line width to the
+ // FindWrapPosition function.
+ if (!FindWrapPosition(wxRichTextRange(lastCompletedEndPos+1, child->GetRange().GetEnd()), dc, availableRect.width, wrapPosition, & partialExtents))
+ {
+ // If the function failed, just cut it off at the end of this child.
+ wrapPosition = child->GetRange().GetEnd();
+ }
+
+ // FindWrapPosition can still return a value that will put us in an endless wrapping loop
+ if (wrapPosition <= lastCompletedEndPos)
+ wrapPosition = wxMax(lastCompletedEndPos+1,child->GetRange().GetEnd());
+
+ // Line end position shouldn't be the same as the end, or greater.
+ if (wrapPosition >= GetRange().GetEnd())
+ wrapPosition = GetRange().GetEnd()-1;
+
+ // wxLogDebug(wxT("Split at %ld"), wrapPosition);
+
+ // Let's find the actual size of the current line now
+ wxSize actualSize;
+ wxRichTextRange actualRange(lastCompletedEndPos+1, wrapPosition);
+
+ /// Use previous descent, not the wrapping descent we just found, since this may be too big
+ /// for the fragment we're about to add.
+ childDescent = maxDescent;
+
+#if wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
+ if (!child->IsEmpty())
+ {
+ // Get height only, then the width using the partial extents
+ GetRangeSize(actualRange, actualSize, childDescent, dc, wxRICHTEXT_UNFORMATTED|wxRICHTEXT_HEIGHT_ONLY);
+ actualSize.x = wxRichTextGetRangeWidth(*this, actualRange, partialExtents);
+ }
+ else
+#endif
+ GetRangeSize(actualRange, actualSize, childDescent, dc, wxRICHTEXT_UNFORMATTED);
+
+ currentWidth = actualSize.x;
+ maxDescent = wxMax(childDescent, maxDescent);
+ maxAscent = wxMax(actualSize.y-childDescent, maxAscent);
+ lineHeight = maxDescent + maxAscent;
+
+ if (lineHeight == 0 && buffer)
+ {
+ wxFont font(buffer->GetFontTable().FindFont(attr));
+ wxCheckSetFont(dc, font);
+ lineHeight = dc.GetCharHeight();
+ }
+
+ if (maxDescent == 0)
+ {
+ int w, h;
+ dc.GetTextExtent(wxT("X"), & w, &h, & maxDescent);
+ }
+
+ // Add a new line
+ wxRichTextLine* line = AllocateLine(lineCount);
+
+ // Set relative range so we won't have to change line ranges when paragraphs are moved
+ line->SetRange(wxRichTextRange(actualRange.GetStart() - GetRange().GetStart(), actualRange.GetEnd() - GetRange().GetStart()));
+ line->SetPosition(currentPosition);
+ line->SetSize(wxSize(currentWidth, lineHeight));
+ line->SetDescent(maxDescent);
+
+ maxHeight = currentPosition.y + lineHeight;
+
+ // Now move down a line. TODO: add margins, spacing
+ currentPosition.y += lineHeight;
+ currentPosition.y += lineSpacing;
+ maxDescent = 0;
+ maxAscent = 0;
+ maxWidth = wxMax(maxWidth, currentWidth+startOffset);
+ currentWidth = 0;
+
+ lineCount ++;
+
+ // TODO: account for zero-length objects, such as fields
+ // wxASSERT(wrapPosition > lastCompletedEndPos);
+
+ lastEndPos = wrapPosition;
+ lastCompletedEndPos = lastEndPos;
+
+ lineHeight = 0;
+
+ if (wrapPosition < GetRange().GetEnd()-1)
+ {
+ // May need to set the node back to a previous one, due to searching back in wrapping
+ wxRichTextObject* childAfterWrapPosition = FindObjectAtPosition(wrapPosition+1);
+ if (childAfterWrapPosition)
+ node = m_children.Find(childAfterWrapPosition);
+ else
+ node = node->GetNext();
+ }
+ else
+ node = node->GetNext();
+
+ // Apply paragraph styles such as alignment to the wrapped line
+ ApplyParagraphStyle(line, attr, availableRect, dc);
+ }
+ else
+ {
+ // We still fit, so don't add a line, and keep going
+ currentWidth += childSize.x;
+ maxDescent = wxMax(childDescent, maxDescent);
+ maxAscent = wxMax(childSize.y-childDescent, maxAscent);
+ lineHeight = maxDescent + maxAscent;
+
+ maxWidth = wxMax(maxWidth, currentWidth+startOffset);
+ lastEndPos = child->GetRange().GetEnd();
+
+ node = node->GetNext();
+ }
+ }
+
+ //wxASSERT(!(lastCompletedEndPos != -1 && lastCompletedEndPos < GetRange().GetEnd()-1));
+
+ // Remove remaining unused line objects, if any
+ ClearUnusedLines(lineCount);
+
+ // We need to add back the margins etc.
+ {
+ wxRect marginRect, borderRect, contentRect, paddingRect, outlineRect;
+ contentRect = wxRect(wxPoint(0, 0), wxSize(maxWidth, currentPosition.y + spaceAfterPara));
+ GetBoxRects(dc, buffer, GetAttributes(), marginRect, borderRect, contentRect, paddingRect, outlineRect);
+ SetCachedSize(marginRect.GetSize());
+ }
+
+ // The maximum size is the length of the paragraph stretched out into a line.
+ // So if there were a single word, or an image, or a fixed-size text box, the object could be shrunk around
+ // this size. TODO: take into account line breaks.
+ {
+ wxRect marginRect, borderRect, contentRect, paddingRect, outlineRect;
+ contentRect = wxRect(wxPoint(0, 0), wxSize(paraSize.x, currentPosition.y + spaceAfterPara));
+ GetBoxRects(dc, buffer, GetAttributes(), marginRect, borderRect, contentRect, paddingRect, outlineRect);
+ SetMaxSize(marginRect.GetSize());
+ }
+
+ // Find the greatest minimum size. Currently we only look at non-text objects,
+ // which isn't ideal but it would be slow to find the maximum word width to
+ // use as the minimum.
+ {
+ int minWidth = 0;
+ node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+
+ // If floating, ignore. We already laid out floats.
+ // Also ignore if empty object, except if we haven't got any
+ // size yet.
+ if (!child->IsFloating() && child->GetRange().GetLength() != 0 && !child->IsKindOf(CLASSINFO(wxRichTextPlainText)))
+ {
+ if (child->GetCachedSize().x > minWidth)
+ minWidth = child->GetMinSize().x;
+ }
+ node = node->GetNext();
+ }
+
+ wxRect marginRect, borderRect, contentRect, paddingRect, outlineRect;
+ contentRect = wxRect(wxPoint(0, 0), wxSize(minWidth, currentPosition.y + spaceAfterPara));
+ GetBoxRects(dc, buffer, GetAttributes(), marginRect, borderRect, contentRect, paddingRect, outlineRect);
+ SetMinSize(marginRect.GetSize());
+ }
+
+
+#if wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
+#if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING
+ // Use the text extents to calculate the size of each fragment in each line
+ wxRichTextLineList::compatibility_iterator lineNode = m_cachedLines.GetFirst();
+ while (lineNode)
+ {
+ wxRichTextLine* line = lineNode->GetData();
+ wxRichTextRange lineRange = line->GetAbsoluteRange();
+
+ // Loop through objects until we get to the one within range
+ wxRichTextObjectList::compatibility_iterator node2 = m_children.GetFirst();
+
+ while (node2)
+ {
+ wxRichTextObject* child = node2->GetData();
+
+ if (child->GetRange().GetLength() > 0 && !child->GetRange().IsOutside(lineRange))
+ {
+ wxRichTextRange rangeToUse = lineRange;
+ rangeToUse.LimitTo(child->GetRange());
+
+ // Find the size of the child from the text extents, and store in an array
+ // for drawing later
+ int left = 0;
+ if (rangeToUse.GetStart() > GetRange().GetStart())
+ left = partialExtents[(rangeToUse.GetStart()-1) - GetRange().GetStart()];
+ int right = partialExtents[rangeToUse.GetEnd() - GetRange().GetStart()];
+ int sz = right - left;
+ line->GetObjectSizes().Add(sz);
+ }
+ else if (child->GetRange().GetStart() > lineRange.GetEnd())
+ // Can break out of inner loop now since we've passed this line's range
+ break;
+
+ node2 = node2->GetNext();
+ }
+
+ lineNode = lineNode->GetNext();
+ }
+#endif
+#endif
+
+ return true;
+}
+
+/// Apply paragraph styles, such as centering, to wrapped lines
+/// TODO: take into account box attributes, possibly
+void wxRichTextParagraph::ApplyParagraphStyle(wxRichTextLine* line, const wxRichTextAttr& attr, const wxRect& rect, wxDC& dc)
+{
+ if (!attr.HasAlignment())
+ return;
+
+ wxPoint pos = line->GetPosition();
+ wxSize size = line->GetSize();
+
+ // centering, right-justification
+ if (attr.HasAlignment() && GetAttributes().GetAlignment() == wxTEXT_ALIGNMENT_CENTRE)
+ {
+ int rightIndent = ConvertTenthsMMToPixels(dc, attr.GetRightIndent());
+ pos.x = (rect.GetWidth() - rightIndent - size.x)/2 + pos.x;
+ line->SetPosition(pos);
+ }
+ else if (attr.HasAlignment() && GetAttributes().GetAlignment() == wxTEXT_ALIGNMENT_RIGHT)
+ {
+ int rightIndent = ConvertTenthsMMToPixels(dc, attr.GetRightIndent());
+ pos.x = pos.x + rect.GetWidth() - size.x - rightIndent;
+ line->SetPosition(pos);
+ }
+}
+
+/// Insert text at the given position
+bool wxRichTextParagraph::InsertText(long pos, const wxString& text)
+{
+ wxRichTextObject* childToUse = NULL;
+ wxRichTextObjectList::compatibility_iterator nodeToUse = wxRichTextObjectList::compatibility_iterator();
+
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+ if (child->GetRange().Contains(pos) && child->GetRange().GetLength() > 0)
+ {
+ childToUse = child;
+ nodeToUse = node;
+ break;
+ }
+
+ node = node->GetNext();
+ }
+
+ if (childToUse)
+ {
+ wxRichTextPlainText* textObject = wxDynamicCast(childToUse, wxRichTextPlainText);
+ if (textObject)
+ {
+ int posInString = pos - textObject->GetRange().GetStart();
+
+ wxString newText = textObject->GetText().Mid(0, posInString) +
+ text + textObject->GetText().Mid(posInString);
+ textObject->SetText(newText);
+
+ int textLength = text.length();
+
+ textObject->SetRange(wxRichTextRange(textObject->GetRange().GetStart(),
+ textObject->GetRange().GetEnd() + textLength));
+
+ // Increment the end range of subsequent fragments in this paragraph.
+ // We'll set the paragraph range itself at a higher level.
+
+ wxRichTextObjectList::compatibility_iterator node = nodeToUse->GetNext();
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+ child->SetRange(wxRichTextRange(textObject->GetRange().GetStart() + textLength,
+ textObject->GetRange().GetEnd() + textLength));
+
+ node = node->GetNext();
+ }
+
+ return true;
+ }
+ else
+ {
+ // TODO: if not a text object, insert at closest position, e.g. in front of it
+ }
+ }
+ else
+ {
+ // Add at end.
+ // Don't pass parent initially to suppress auto-setting of parent range.
+ // We'll do that at a higher level.
+ wxRichTextPlainText* textObject = new wxRichTextPlainText(text, this);
+
+ AppendChild(textObject);
+ return true;
+ }
+
+ return false;
+}
+
+void wxRichTextParagraph::Copy(const wxRichTextParagraph& obj)
+{
+ wxRichTextCompositeObject::Copy(obj);
+}
+
+/// Clear the cached lines
+void wxRichTextParagraph::ClearLines()
+{
+ WX_CLEAR_LIST(wxRichTextLineList, m_cachedLines);
+}
+
+/// Get/set the object size for the given range. Returns false if the range
+/// is invalid for this object.
+bool wxRichTextParagraph::GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags, wxPoint position, wxArrayInt* partialExtents) const
+{
+ if (!range.IsWithin(GetRange()))
+ return false;
+
+ if (flags & wxRICHTEXT_UNFORMATTED)
+ {
+ // Just use unformatted data, assume no line breaks
+ // TODO: take into account line breaks
+
+ wxSize sz;
+
+ wxArrayInt childExtents;
+ wxArrayInt* p;
+ if (partialExtents)
+ p = & childExtents;
+ else
+ p = NULL;
+
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+
+ wxRichTextObject* child = node->GetData();
+ if (!child->GetRange().IsOutside(range))
+ {
+ // Floating objects have a zero size within the paragraph.
+ if (child->IsFloating())
+ {
+ if (partialExtents)
+ {
+ int lastSize;
+ if (partialExtents->GetCount() > 0)
+ lastSize = (*partialExtents)[partialExtents->GetCount()-1];
+ else
+ lastSize = 0;
+
+ partialExtents->Add(0 /* zero size */ + lastSize);
+ }
+ }
+ else
+ {
+ wxSize childSize;
+
+ wxRichTextRange rangeToUse = range;
+ rangeToUse.LimitTo(child->GetRange());
+#if 0
+ if (child->IsTopLevel())
+ rangeToUse = child->GetOwnRange();
+#endif
+ int childDescent = 0;
+
+ // At present wxRICHTEXT_HEIGHT_ONLY is only fast if we're already cached the size,
+ // but it's only going to be used after caching has taken place.
+ if ((flags & wxRICHTEXT_HEIGHT_ONLY) && child->GetCachedSize().y != 0)
+ {
+ childDescent = child->GetDescent();
+ childSize = child->GetCachedSize();
+
+ sz.y = wxMax(sz.y, childSize.y);
+ sz.x += childSize.x;
+ descent = wxMax(descent, childDescent);
+ }
+ else if (child->IsTopLevel())
+ {
+ childDescent = child->GetDescent();
+ childSize = child->GetCachedSize();
+
+ sz.y = wxMax(sz.y, childSize.y);
+ sz.x += childSize.x;
+ descent = wxMax(descent, childDescent);
+ if ((flags & wxRICHTEXT_CACHE_SIZE) && (rangeToUse == child->GetRange()))
+ {
+ child->SetCachedSize(childSize);
+ child->SetDescent(childDescent);
+ }
+
+ if (partialExtents)
+ {
+ int lastSize;
+ if (partialExtents->GetCount() > 0)
+ lastSize = (*partialExtents)[partialExtents->GetCount()-1];
+ else
+ lastSize = 0;
+
+ partialExtents->Add(childSize.x + lastSize);
+ }
+ }
+ else if (child->GetRangeSize(rangeToUse, childSize, childDescent, dc, flags, wxPoint(position.x + sz.x, position.y), p))
+ {
+ sz.y = wxMax(sz.y, childSize.y);
+ sz.x += childSize.x;
+ descent = wxMax(descent, childDescent);
+
+ if ((flags & wxRICHTEXT_CACHE_SIZE) && (rangeToUse == child->GetRange()))
+ {
+ child->SetCachedSize(childSize);
+ child->SetDescent(childDescent);
+ }
+
+ if (partialExtents)
+ {
+ int lastSize;
+ if (partialExtents->GetCount() > 0)
+ lastSize = (*partialExtents)[partialExtents->GetCount()-1];
+ else
+ lastSize = 0;
+
+ size_t i;
+ for (i = 0; i < childExtents.GetCount(); i++)
+ {
+ partialExtents->Add(childExtents[i] + lastSize);
+ }
+ }
+ }
+ }
+
+ if (p)
+ p->Clear();
+ }
+
+ node = node->GetNext();
+ }
+ size = sz;
+ }
+ else
+ {
+ // Use formatted data, with line breaks
+ wxSize sz;
+
+ // We're going to loop through each line, and then for each line,
+ // call GetRangeSize for the fragment that comprises that line.
+ // Only we have to do that multiple times within the line, because
+ // the line may be broken into pieces. For now ignore line break commands
+ // (so we can assume that getting the unformatted size for a fragment
+ // within a line is the actual size)
+
+ wxRichTextLineList::compatibility_iterator node = m_cachedLines.GetFirst();
+ while (node)
+ {
+ wxRichTextLine* line = node->GetData();
+ wxRichTextRange lineRange = line->GetAbsoluteRange();
+ if (!lineRange.IsOutside(range))
+ {
+ wxSize lineSize;
+
+ wxRichTextObjectList::compatibility_iterator node2 = m_children.GetFirst();
+ while (node2)
+ {
+ wxRichTextObject* child = node2->GetData();
+
+ if (!child->IsFloating() && !child->GetRange().IsOutside(lineRange))
+ {
+ wxRichTextRange rangeToUse = lineRange;
+ rangeToUse.LimitTo(child->GetRange());
+ if (child->IsTopLevel())
+ rangeToUse = child->GetOwnRange();
+
+ wxSize childSize;
+ int childDescent = 0;
+ if (child->GetRangeSize(rangeToUse, childSize, childDescent, dc, flags, wxPoint(position.x + sz.x, position.y)))
+ {
+ lineSize.y = wxMax(lineSize.y, childSize.y);
+ lineSize.x += childSize.x;
+ }
+ descent = wxMax(descent, childDescent);
+ }
+
+ node2 = node2->GetNext();
+ }
+
+ // Increase size by a line (TODO: paragraph spacing)
+ sz.y += lineSize.y;
+ sz.x = wxMax(sz.x, lineSize.x);
+ }
+ node = node->GetNext();
+ }
+ size = sz;
+ }
+ return true;
+}
+
+/// Finds the absolute position and row height for the given character position
+bool wxRichTextParagraph::FindPosition(wxDC& dc, long index, wxPoint& pt, int* height, bool forceLineStart)
+{
+ if (index == -1)
+ {
+ wxRichTextLine* line = ((wxRichTextParagraphLayoutBox*)GetParent())->GetLineAtPosition(0);
+ if (line)
+ *height = line->GetSize().y;
+ else
+ *height = dc.GetCharHeight();
+
+ // -1 means 'the start of the buffer'.
+ pt = GetPosition();
+ if (line)
+ pt = pt + line->GetPosition();
+
+ return true;
+ }
+
+ // The final position in a paragraph is taken to mean the position
+ // at the start of the next paragraph.
+ if (index == GetRange().GetEnd())
+ {
+ wxRichTextParagraphLayoutBox* parent = wxDynamicCast(GetParent(), wxRichTextParagraphLayoutBox);
+ wxASSERT( parent != NULL );
+
+ // Find the height at the next paragraph, if any
+ wxRichTextLine* line = parent->GetLineAtPosition(index + 1);
+ if (line)
+ {
+ *height = line->GetSize().y;
+ pt = line->GetAbsolutePosition();
+ }
+ else
+ {
+ *height = dc.GetCharHeight();
+ int indent = ConvertTenthsMMToPixels(dc, m_attributes.GetLeftIndent());
+ pt = wxPoint(indent, GetCachedSize().y);
+ }
+
+ return true;
+ }
+
+ if (index < GetRange().GetStart() || index > GetRange().GetEnd())
+ return false;
+
+ wxRichTextLineList::compatibility_iterator node = m_cachedLines.GetFirst();
+ while (node)
+ {
+ wxRichTextLine* line = node->GetData();
+ wxRichTextRange lineRange = line->GetAbsoluteRange();
+ if (index >= lineRange.GetStart() && index <= lineRange.GetEnd())
+ {
+ // If this is the last point in the line, and we're forcing the
+ // returned value to be the start of the next line, do the required
+ // thing.
+ if (index == lineRange.GetEnd() && forceLineStart)
+ {
+ if (node->GetNext())
+ {
+ wxRichTextLine* nextLine = node->GetNext()->GetData();
+ *height = nextLine->GetSize().y;
+ pt = nextLine->GetAbsolutePosition();
+ return true;
+ }
+ }
+
+ pt.y = line->GetPosition().y + GetPosition().y;
+
+ wxRichTextRange r(lineRange.GetStart(), index);
+ wxSize rangeSize;
+ int descent = 0;
+
+ // We find the size of the line up to this point,
+ // then we can add this size to the line start position and
+ // paragraph start position to find the actual position.
+
+ if (GetRangeSize(r, rangeSize, descent, dc, wxRICHTEXT_UNFORMATTED, line->GetPosition()+ GetPosition()))
+ {
+ pt.x = line->GetPosition().x + GetPosition().x + rangeSize.x;
+ *height = line->GetSize().y;
+
+ return true;
+ }
+
+ }
+
+ node = node->GetNext();
+ }
+
+ return false;
+}
+
+/// Hit-testing: returns a flag indicating hit test details, plus
+/// information about position
+int wxRichTextParagraph::HitTest(wxDC& dc, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags)
+{
+ if (!IsShown())
+ return wxRICHTEXT_HITTEST_NONE;
+
+ // If we're in the top-level container, then we can return
+ // a suitable hit test code even if the point is outside the container area,
+ // so that we can position the caret sensibly even if we don't
+ // click on valid content. If we're not at the top-level, and the point
+ // is not within this paragraph object, then we don't want to stop more
+ // precise hit-testing from working prematurely, so return immediately.
+ // NEW STRATEGY: use the parent boundary to test whether we're in the
+ // right region, not the paragraph, since the paragraph may be positioned
+ // some way in from where the user clicks.
+ {
+ long tmpPos;
+ wxRichTextObject* tempObj, *tempContextObj;
+ if (GetParent() && GetParent()->wxRichTextObject::HitTest(dc, pt, tmpPos, & tempObj, & tempContextObj, flags) == wxRICHTEXT_HITTEST_NONE)
+ return wxRICHTEXT_HITTEST_NONE;
+ }
+
+ wxRichTextObjectList::compatibility_iterator objNode = m_children.GetFirst();
+ while (objNode)
+ {
+ wxRichTextObject* child = objNode->GetData();
+ if (child->IsTopLevel() && ((flags & wxRICHTEXT_HITTEST_NO_NESTED_OBJECTS) == 0))
+ {
+ {
+ int hitTest = child->HitTest(dc, pt, textPosition, obj, contextObj);
+ if (hitTest != wxRICHTEXT_HITTEST_NONE)
+ return hitTest;
+ }
+ }
+
+ objNode = objNode->GetNext();
+ }
+
+ wxPoint paraPos = GetPosition();
+
+ wxRichTextLineList::compatibility_iterator node = m_cachedLines.GetFirst();
+ while (node)
+ {
+ wxRichTextLine* line = node->GetData();
+ wxPoint linePos = paraPos + line->GetPosition();
+ wxSize lineSize = line->GetSize();
+ wxRichTextRange lineRange = line->GetAbsoluteRange();
+
+ if (pt.y <= linePos.y + lineSize.y)
+ {
+ if (pt.x < linePos.x)
+ {
+ textPosition = lineRange.GetStart();
+ *obj = FindObjectAtPosition(textPosition);
+ *contextObj = GetContainer();
+ return wxRICHTEXT_HITTEST_BEFORE|wxRICHTEXT_HITTEST_OUTSIDE;
+ }
+ else if (pt.x >= (linePos.x + lineSize.x))
+ {
+ textPosition = lineRange.GetEnd();
+ *obj = FindObjectAtPosition(textPosition);
+ *contextObj = GetContainer();
+ return wxRICHTEXT_HITTEST_AFTER|wxRICHTEXT_HITTEST_OUTSIDE;
+ }
+ else
+ {
+#if wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
+ wxArrayInt partialExtents;
+
+ wxSize paraSize;
+ int paraDescent;
+
+ // This calculates the partial text extents
+ GetRangeSize(lineRange, paraSize, paraDescent, dc, wxRICHTEXT_UNFORMATTED, linePos, & partialExtents);
+
+ int lastX = linePos.x;
+ size_t i;
+ for (i = 0; i < partialExtents.GetCount(); i++)
+ {
+ int nextX = partialExtents[i] + linePos.x;
+
+ if (pt.x >= lastX && pt.x <= nextX)
+ {
+ textPosition = i + lineRange.GetStart(); // minus 1?
+
+ *obj = FindObjectAtPosition(textPosition);
+ *contextObj = GetContainer();
+
+ // So now we know it's between i-1 and i.
+ // Let's see if we can be more precise about
+ // which side of the position it's on.
+
+ int midPoint = (nextX + lastX)/2;
+ if (pt.x >= midPoint)
+ return wxRICHTEXT_HITTEST_AFTER;
+ else
+ return wxRICHTEXT_HITTEST_BEFORE;
+ }
+
+ lastX = nextX;
+ }
+#else
+ long i;
+ int lastX = linePos.x;
+ for (i = lineRange.GetStart(); i <= lineRange.GetEnd(); i++)
+ {
+ wxSize childSize;
+ int descent = 0;
+
+ wxRichTextRange rangeToUse(lineRange.GetStart(), i);
+
+ GetRangeSize(rangeToUse, childSize, descent, dc, wxRICHTEXT_UNFORMATTED, linePos);
+
+ int nextX = childSize.x + linePos.x;
+
+ if (pt.x >= lastX && pt.x <= nextX)
+ {
+ textPosition = i;
+
+ *obj = FindObjectAtPosition(textPosition);
+ *contextObj = GetContainer();
+
+ // So now we know it's between i-1 and i.
+ // Let's see if we can be more precise about
+ // which side of the position it's on.
+
+ int midPoint = (nextX + lastX)/2;
+ if (pt.x >= midPoint)
+ return wxRICHTEXT_HITTEST_AFTER;
+ else
+ return wxRICHTEXT_HITTEST_BEFORE;
+ }
+ else
+ {
+ lastX = nextX;
+ }
+ }
+#endif
+ }
+ }
+
+ node = node->GetNext();
+ }
+
+ return wxRICHTEXT_HITTEST_NONE;
+}
+
+/// Split an object at this position if necessary, and return
+/// the previous object, or NULL if inserting at beginning.
+wxRichTextObject* wxRichTextParagraph::SplitAt(long pos, wxRichTextObject** previousObject)
+{
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+
+ if (pos == child->GetRange().GetStart())
+ {
+ if (previousObject)
+ {
+ if (node->GetPrevious())
+ *previousObject = node->GetPrevious()->GetData();
+ else
+ *previousObject = NULL;
+ }
+
+ return child;
+ }
+
+ if (child->GetRange().Contains(pos))
+ {
+ // This should create a new object, transferring part of
+ // the content to the old object and the rest to the new object.
+ wxRichTextObject* newObject = child->DoSplit(pos);
+
+ // If we couldn't split this object, just insert in front of it.
+ if (!newObject)
+ {
+ // Maybe this is an empty string, try the next one
+ // return child;
+ }
+ else
+ {
+ // Insert the new object after 'child'
+ if (node->GetNext())
+ m_children.Insert(node->GetNext(), newObject);
+ else
+ m_children.Append(newObject);
+ newObject->SetParent(this);
+
+ if (previousObject)
+ *previousObject = child;
+
+ return newObject;
+ }
+ }
+
+ node = node->GetNext();
+ }
+ if (previousObject)
+ *previousObject = NULL;
+ return NULL;
+}
+
+/// Move content to a list from obj on
+void wxRichTextParagraph::MoveToList(wxRichTextObject* obj, wxList& list)
+{
+ wxRichTextObjectList::compatibility_iterator node = m_children.Find(obj);
+ while (node)
+ {
+ wxRichTextObject* child = node->GetData();
+ list.Append(child);
+
+ wxRichTextObjectList::compatibility_iterator oldNode = node;
+
+ node = node->GetNext();
+
+ m_children.DeleteNode(oldNode);
+ }
+}
+
+/// Add content back from list
+void wxRichTextParagraph::MoveFromList(wxList& list)
+{
+ for (wxList::compatibility_iterator node = list.GetFirst(); node; node = node->GetNext())
+ {
+ AppendChild((wxRichTextObject*) node->GetData());
+ }
+}
+
+/// Calculate range
+void wxRichTextParagraph::CalculateRange(long start, long& end)
+{
+ wxRichTextCompositeObject::CalculateRange(start, end);
+
+ // Add one for end of paragraph
+ end ++;
+
+ m_range.SetRange(start, end);
+}
+
+/// Find the object at the given position
+wxRichTextObject* wxRichTextParagraph::FindObjectAtPosition(long position)
+{
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* obj = node->GetData();
+ if (obj->GetRange().Contains(position) ||
+ obj->GetRange().GetStart() == position ||
+ obj->GetRange().GetEnd() == position)
+ return obj;
+
+ node = node->GetNext();
+ }
+ return NULL;
+}
+
+/// Get the plain text searching from the start or end of the range.
+/// The resulting string may be shorter than the range given.
+bool wxRichTextParagraph::GetContiguousPlainText(wxString& text, const wxRichTextRange& range, bool fromStart)
+{
+ text = wxEmptyString;
+
+ if (fromStart)
+ {
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* obj = node->GetData();
+ if (!obj->GetRange().IsOutside(range))
+ {
+ wxRichTextPlainText* textObj = wxDynamicCast(obj, wxRichTextPlainText);
+ if (textObj)
+ {
+ text += textObj->GetTextForRange(range);
+ }
+ else
+ {
+ text += wxT(" ");
+ }
+ }
+
+ node = node->GetNext();
+ }
+ }
+ else
+ {
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetLast();
+ while (node)
+ {
+ wxRichTextObject* obj = node->GetData();
+ if (!obj->GetRange().IsOutside(range))
+ {
+ wxRichTextPlainText* textObj = wxDynamicCast(obj, wxRichTextPlainText);
+ if (textObj)
+ {
+ text = textObj->GetTextForRange(range) + text;
+ }
+ else
+ {
+ text = wxT(" ") + text;
+ }
+ }
+
+ node = node->GetPrevious();
+ }
+ }
+
+ return true;
+}
+
+/// Find a suitable wrap position.
+bool wxRichTextParagraph::FindWrapPosition(const wxRichTextRange& range, wxDC& dc, int availableSpace, long& wrapPosition, wxArrayInt* partialExtents)
+{
+ if (range.GetLength() <= 0)
+ return false;
+
+ // Find the first position where the line exceeds the available space.
+ wxSize sz;
+ long breakPosition = range.GetEnd();
+
+#if wxRICHTEXT_USE_PARTIAL_TEXT_EXTENTS
+ if (partialExtents && partialExtents->GetCount() >= (size_t) (GetRange().GetLength()-1)) // the final position in a paragraph is the newline
+ {
+ int widthBefore;
+
+ if (range.GetStart() > GetRange().GetStart())
+ widthBefore = (*partialExtents)[range.GetStart() - GetRange().GetStart() - 1];
+ else
+ widthBefore = 0;
+
+ size_t i;
+ for (i = (size_t) range.GetStart(); i <= (size_t) range.GetEnd(); i++)
+ {
+ int widthFromStartOfThisRange = (*partialExtents)[i - GetRange().GetStart()] - widthBefore;
+
+ if (widthFromStartOfThisRange > availableSpace)
+ {
+ breakPosition = i-1;
+ break;
+ }
+ }
+ }
+ else
+#endif
+ {
+ // Binary chop for speed
+ long minPos = range.GetStart();
+ long maxPos = range.GetEnd();
+ while (true)
+ {
+ if (minPos == maxPos)
+ {
+ int descent = 0;
+ GetRangeSize(wxRichTextRange(range.GetStart(), minPos), sz, descent, dc, wxRICHTEXT_UNFORMATTED);
+
+ if (sz.x > availableSpace)
+ breakPosition = minPos - 1;
+ break;
+ }
+ else if ((maxPos - minPos) == 1)
+ {
+ int descent = 0;
+ GetRangeSize(wxRichTextRange(range.GetStart(), minPos), sz, descent, dc, wxRICHTEXT_UNFORMATTED);
+
+ if (sz.x > availableSpace)
+ breakPosition = minPos - 1;
+ else
+ {
+ GetRangeSize(wxRichTextRange(range.GetStart(), maxPos), sz, descent, dc, wxRICHTEXT_UNFORMATTED);
+ if (sz.x > availableSpace)
+ breakPosition = maxPos-1;
+ }
+ break;
+ }
+ else
+ {
+ long nextPos = minPos + ((maxPos - minPos) / 2);
+
+ int descent = 0;
+ GetRangeSize(wxRichTextRange(range.GetStart(), nextPos), sz, descent, dc, wxRICHTEXT_UNFORMATTED);
+
+ if (sz.x > availableSpace)
+ {
+ maxPos = nextPos;
+ }
+ else
+ {
+ minPos = nextPos;
+ }
+ }
+ }
+ }
+
+ // Now we know the last position on the line.
+ // Let's try to find a word break.
+
+ wxString plainText;
+ if (GetContiguousPlainText(plainText, wxRichTextRange(range.GetStart(), breakPosition), false))
+ {
+ int newLinePos = plainText.Find(wxRichTextLineBreakChar);
+ if (newLinePos != wxNOT_FOUND)
+ {
+ breakPosition = wxMax(0, range.GetStart() + newLinePos);
+ }
+ else
+ {
+ int spacePos = plainText.Find(wxT(' '), true);
+ int tabPos = plainText.Find(wxT('\t'), true);
+ int pos = wxMax(spacePos, tabPos);
+ if (pos != wxNOT_FOUND)
+ {
+ int positionsFromEndOfString = plainText.length() - pos - 1;
+ breakPosition = breakPosition - positionsFromEndOfString;
+ }
+ }
+ }
+
+ wrapPosition = breakPosition;
+
+ return true;
+}
+
+/// Get the bullet text for this paragraph.
+wxString wxRichTextParagraph::GetBulletText()
+{
+ if (GetAttributes().GetBulletStyle() == wxTEXT_ATTR_BULLET_STYLE_NONE ||
+ (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_BITMAP))
+ return wxEmptyString;
+
+ int number = GetAttributes().GetBulletNumber();
+
+ wxString text;
+ if ((GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ARABIC) || (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_OUTLINE))
+ {
+ text.Printf(wxT("%d"), number);
+ }
+ else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_LETTERS_UPPER)
+ {
+ // TODO: Unicode, and also check if number > 26
+ text.Printf(wxT("%c"), (wxChar) (number+64));
+ }
+ else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_LETTERS_LOWER)
+ {
+ // TODO: Unicode, and also check if number > 26
+ text.Printf(wxT("%c"), (wxChar) (number+96));
+ }
+ else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ROMAN_UPPER)
+ {
+ text = wxRichTextDecimalToRoman(number);
+ }
+ else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ROMAN_LOWER)
+ {
+ text = wxRichTextDecimalToRoman(number);
+ text.MakeLower();
+ }
+ else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_SYMBOL)
+ {
+ text = GetAttributes().GetBulletText();
+ }
+
+ if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_OUTLINE)
+ {
+ // The outline style relies on the text being computed statically,
+ // since it depends on other levels points (e.g. 1.2.1.1). So normally the bullet text
+ // should be stored in the attributes; if not, just use the number for this
+ // level, as previously computed.
+ if (!GetAttributes().GetBulletText().IsEmpty())
+ text = GetAttributes().GetBulletText();
+ }
+
+ if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_PARENTHESES)
+ {
+ text = wxT("(") + text + wxT(")");
+ }
+ else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_RIGHT_PARENTHESIS)
+ {
+ text = text + wxT(")");
+ }
+
+ if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_PERIOD)
+ {
+ text += wxT(".");
+ }
+
+ return text;
+}
+
+/// Allocate or reuse a line object
+wxRichTextLine* wxRichTextParagraph::AllocateLine(int pos)
+{
+ if (pos < (int) m_cachedLines.GetCount())
+ {
+ wxRichTextLine* line = m_cachedLines.Item(pos)->GetData();
+ line->Init(this);
+ return line;
+ }
+ else
+ {
+ wxRichTextLine* line = new wxRichTextLine(this);
+ m_cachedLines.Append(line);
+ return line;
+ }
+}
+
+/// Clear remaining unused line objects, if any
+bool wxRichTextParagraph::ClearUnusedLines(int lineCount)
+{
+ int cachedLineCount = m_cachedLines.GetCount();
+ if ((int) cachedLineCount > lineCount)
+ {
+ for (int i = 0; i < (int) (cachedLineCount - lineCount); i ++)
+ {
+ wxRichTextLineList::compatibility_iterator node = m_cachedLines.GetLast();
+ wxRichTextLine* line = node->GetData();
+ m_cachedLines.Erase(node);
+ delete line;
+ }
+ }
+ return true;
+}
+
+/// Get combined attributes of the base style, paragraph style and character style. We use this to dynamically
+/// retrieve the actual style.
+wxRichTextAttr wxRichTextParagraph::GetCombinedAttributes(const wxRichTextAttr& contentStyle, bool includingBoxAttr) const
+{
+ wxRichTextAttr attr;
+ wxRichTextParagraphLayoutBox* buf = wxDynamicCast(GetParent(), wxRichTextParagraphLayoutBox);
+ if (buf)
+ {
+ attr = buf->GetBasicStyle();
+ if (!includingBoxAttr)
+ {
+ attr.GetTextBoxAttr().Reset();
+ // The background colour will be painted by the container, and we don't
+ // want to unnecessarily overwrite the background when we're drawing text
+ // because this may erase the guideline (which appears just under the text
+ // if there's no padding).
+ attr.SetFlags(attr.GetFlags() & ~wxTEXT_ATTR_BACKGROUND_COLOUR);
+ }
+ wxRichTextApplyStyle(attr, GetAttributes());
+ }
+ else
+ attr = GetAttributes();
+
+ wxRichTextApplyStyle(attr, contentStyle);
+ return attr;
+}
+
+/// Get combined attributes of the base style and paragraph style.
+wxRichTextAttr wxRichTextParagraph::GetCombinedAttributes(bool includingBoxAttr) const
+{
+ wxRichTextAttr attr;
+ wxRichTextParagraphLayoutBox* buf = wxDynamicCast(GetParent(), wxRichTextParagraphLayoutBox);
+ if (buf)
+ {
+ attr = buf->GetBasicStyle();
+ if (!includingBoxAttr)
+ attr.GetTextBoxAttr().Reset();
+ wxRichTextApplyStyle(attr, GetAttributes());
+ }
+ else
+ attr = GetAttributes();
+
+ return attr;
+}
+
+// Create default tabstop array
+void wxRichTextParagraph::InitDefaultTabs()
+{
+ // create a default tab list at 10 mm each.
+ for (int i = 0; i < 20; ++i)
+ {
+ sm_defaultTabs.Add(i*100);
+ }
+}
+
+// Clear default tabstop array
+void wxRichTextParagraph::ClearDefaultTabs()
+{
+ sm_defaultTabs.Clear();
+}
+
+void wxRichTextParagraph::LayoutFloat(wxDC& dc, const wxRect& rect, int style, wxRichTextFloatCollector* floatCollector)
+{
+ wxRichTextObjectList::compatibility_iterator node = GetChildren().GetFirst();
+ while (node)
+ {
+ wxRichTextObject* anchored = node->GetData();
+ if (anchored && anchored->IsFloating() && !floatCollector->HasFloat(anchored))
+ {
+ wxSize size;
+ int descent, x = 0;
+ anchored->GetRangeSize(anchored->GetRange(), size, descent, dc, style);
+
+ int offsetY = 0;
+ if (anchored->GetAttributes().GetTextBoxAttr().GetTop().IsValid())
+ {
+ offsetY = anchored->GetAttributes().GetTextBoxAttr().GetTop().GetValue();
+ if (anchored->GetAttributes().GetTextBoxAttr().GetTop().GetUnits() == wxTEXT_ATTR_UNITS_TENTHS_MM)
+ {
+ offsetY = ConvertTenthsMMToPixels(dc, offsetY);
+ }
+ }
+
+ int pos = floatCollector->GetFitPosition(anchored->GetAttributes().GetTextBoxAttr().GetFloatMode(), rect.y + offsetY, size.y);
+
+ /* Update the offset */
+ int newOffsetY = pos - rect.y;
+ if (newOffsetY != offsetY)
+ {
+ if (anchored->GetAttributes().GetTextBoxAttr().GetTop().GetUnits() == wxTEXT_ATTR_UNITS_TENTHS_MM)
+ newOffsetY = ConvertPixelsToTenthsMM(dc, newOffsetY);
+ anchored->GetAttributes().GetTextBoxAttr().GetTop().SetValue(newOffsetY);
+ }
+
+ if (anchored->GetAttributes().GetTextBoxAttr().GetFloatMode() == wxTEXT_BOX_ATTR_FLOAT_LEFT)
+ x = rect.x;
+ else if (anchored->GetAttributes().GetTextBoxAttr().GetFloatMode() == wxTEXT_BOX_ATTR_FLOAT_RIGHT)
+ x = rect.x + rect.width - size.x;
+
+ anchored->SetPosition(wxPoint(x, pos));
+ anchored->SetCachedSize(size);
+ floatCollector->CollectFloat(this, anchored);
+ }
+
+ node = node->GetNext();
+ }
+}
+
+// Get the first position from pos that has a line break character.
+long wxRichTextParagraph::GetFirstLineBreakPosition(long pos)
+{
+ wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
+ while (node)
+ {
+ wxRichTextObject* obj = node->GetData();
+ if (pos >= obj->GetRange().GetStart() && pos <= obj->GetRange().GetEnd())
+ {
+ wxRichTextPlainText* textObj = wxDynamicCast(obj, wxRichTextPlainText);
+ if (textObj)
+ {
+ long breakPos = textObj->GetFirstLineBreakPosition(pos);
+ if (breakPos > -1)
+ return breakPos;
+ }
+ }
+ node = node->GetNext();
+ }
+ return -1;
+}
+
+/*!
+ * wxRichTextLine
+ * This object represents a line in a paragraph, and stores
+ * offsets from the start of the paragraph representing the
+ * start and end positions of the line.
+ */
+
+wxRichTextLine::wxRichTextLine(wxRichTextParagraph* parent)
+{
+ Init(parent);
+}
+
+/// Initialisation
+void wxRichTextLine::Init(wxRichTextParagraph* parent)
+{
+ m_parent = parent;
+ m_range.SetRange(-1, -1);
+ m_pos = wxPoint(0, 0);
+ m_size = wxSize(0, 0);
+ m_descent = 0;
+#if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING
+ m_objectSizes.Clear();
+#endif
+}
+
+/// Copy
+void wxRichTextLine::Copy(const wxRichTextLine& obj)
+{
+ m_range = obj.m_range;
+#if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING
+ m_objectSizes = obj.m_objectSizes;
+#endif
+}
+
+/// Get the absolute object position
+wxPoint wxRichTextLine::GetAbsolutePosition() const
+{
+ return m_parent->GetPosition() + m_pos;
+}
+
+/// Get the absolute range
+wxRichTextRange wxRichTextLine::GetAbsoluteRange() const
+{
+ wxRichTextRange range(m_range.GetStart() + m_parent->GetRange().GetStart(), 0);
+ range.SetEnd(range.GetStart() + m_range.GetLength()-1);
+ return range;
+}
+
+/*!
+ * wxRichTextPlainText
+ * This object represents a single piece of text.
+ */
+
+IMPLEMENT_DYNAMIC_CLASS(wxRichTextPlainText, wxRichTextObject)
+
+wxRichTextPlainText::wxRichTextPlainText(const wxString& text, wxRichTextObject* parent, wxRichTextAttr* style):
+ wxRichTextObject(parent)
+{
+ if (style)
+ SetAttributes(*style);
+
+ m_text = text;
+}
+
+#define USE_KERNING_FIX 1
+
+// If insufficient tabs are defined, this is the tab width used
+#define WIDTH_FOR_DEFAULT_TABS 50
+
+/// Draw the item
+bool wxRichTextPlainText::Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int WXUNUSED(style))
+{
+ wxRichTextParagraph* para = wxDynamicCast(GetParent(), wxRichTextParagraph);
+ wxASSERT (para != NULL);
+
+ wxRichTextAttr textAttr(para ? para->GetCombinedAttributes(GetAttributes(), false /* no box attributes */) : GetAttributes());
+
+ // Let's make the assumption for now that for content in a paragraph, including
+ // text, we never have a discontinuous selection. So we only deal with a
+ // single range.
+ wxRichTextRange selectionRange;
+ if (selection.IsValid())
+ {
+ wxRichTextRangeArray selectionRanges = selection.GetSelectionForObject(this);
+ if (selectionRanges.GetCount() > 0)
+ selectionRange = selectionRanges[0];
+ else
+ selectionRange = wxRICHTEXT_NO_SELECTION;
+ }
+ else
+ selectionRange = wxRICHTEXT_NO_SELECTION;
+
+ int offset = GetRange().GetStart();
+
+ // Replace line break characters with spaces
+ wxString str = m_text;
+ wxString toRemove = wxRichTextLineBreakChar;
+ str.Replace(toRemove, wxT(" "));
+ if (textAttr.HasTextEffects() && (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_CAPITALS))
+ str.MakeUpper();
+
+ long len = range.GetLength();
+ wxString stringChunk = str.Mid(range.GetStart() - offset, (size_t) len);
+
+ // Test for the optimized situations where all is selected, or none
+ // is selected.
+
+ wxFont textFont(GetBuffer()->GetFontTable().FindFont(textAttr));
+ wxCheckSetFont(dc, textFont);
+ int charHeight = dc.GetCharHeight();
+
+ int x, y;
+ if ( textFont.IsOk() )
+ {
+ if ( textAttr.HasTextEffects() && (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_SUPERSCRIPT) )
+ {
+ double size = static_cast<double>(textFont.GetPointSize()) / wxSCRIPT_MUL_FACTOR;
+ textFont.SetPointSize( static_cast<int>(size) );
+ x = rect.x;
+ y = rect.y;
+ wxCheckSetFont(dc, textFont);
+ }
+ else if ( textAttr.HasTextEffects() && (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_SUBSCRIPT) )
+ {
+ double size = static_cast<double>(textFont.GetPointSize()) / wxSCRIPT_MUL_FACTOR;
+ textFont.SetPointSize( static_cast<int>(size) );
+ x = rect.x;
+ int sub_height = static_cast<int>( static_cast<double>(charHeight) / wxSCRIPT_MUL_FACTOR);
+ y = rect.y + (rect.height - sub_height + (descent - m_descent));
+ wxCheckSetFont(dc, textFont);
+ }
+ else
+ {
+ x = rect.x;
+ y = rect.y + (rect.height - charHeight - (descent - m_descent));
+ }
+ }
+ else
+ {
+ x = rect.x;
+ y = rect.y + (rect.height - charHeight - (descent - m_descent));
+ }
+
+ // TODO: new selection code
+
+ // (a) All selected.
+ if (selectionRange.GetStart() <= range.GetStart() && selectionRange.GetEnd() >= range.GetEnd())
+ {
+ DrawTabbedString(dc, textAttr, rect, stringChunk, x, y, true);
+ }
+ // (b) None selected.
+ else if (selectionRange.GetEnd() < range.GetStart() || selectionRange.GetStart() > range.GetEnd())
+ {
+ // Draw all unselected
+ DrawTabbedString(dc, textAttr, rect, stringChunk, x, y, false);
+ }
+ else
+ {
+ // (c) Part selected, part not
+ // Let's draw unselected chunk, selected chunk, then unselected chunk.
+
+ dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
+
+ // 1. Initial unselected chunk, if any, up until start of selection.
+ if (selectionRange.GetStart() > range.GetStart() && selectionRange.GetStart() <= range.GetEnd())
+ {
+ int r1 = range.GetStart();
+ int s1 = selectionRange.GetStart()-1;
+ int fragmentLen = s1 - r1 + 1;
+ if (fragmentLen < 0)
+ {
+ wxLogDebug(wxT("Mid(%d, %d"), (int)(r1 - offset), (int)fragmentLen);
+ }
+ wxString stringFragment = str.Mid(r1 - offset, fragmentLen);
+
+ DrawTabbedString(dc, textAttr, rect, stringFragment, x, y, false);
+
+#if USE_KERNING_FIX
+ if (stringChunk.Find(wxT("\t")) == wxNOT_FOUND)
+ {
+ // Compensate for kerning difference
+ wxString stringFragment2(str.Mid(r1 - offset, fragmentLen+1));
+ wxString stringFragment3(str.Mid(r1 - offset + fragmentLen, 1));
+
+ wxCoord w1, h1, w2, h2, w3, h3;
+ dc.GetTextExtent(stringFragment, & w1, & h1);
+ dc.GetTextExtent(stringFragment2, & w2, & h2);
+ dc.GetTextExtent(stringFragment3, & w3, & h3);
+
+ int kerningDiff = (w1 + w3) - w2;
+ x = x - kerningDiff;
+ }
+#endif
+ }
+
+ // 2. Selected chunk, if any.
+ if (selectionRange.GetEnd() >= range.GetStart())
+ {
+ int s1 = wxMax(selectionRange.GetStart(), range.GetStart());
+ int s2 = wxMin(selectionRange.GetEnd(), range.GetEnd());
+
+ int fragmentLen = s2 - s1 + 1;
+ if (fragmentLen < 0)
+ {
+ wxLogDebug(wxT("Mid(%d, %d"), (int)(s1 - offset), (int)fragmentLen);
+ }
+ wxString stringFragment = str.Mid(s1 - offset, fragmentLen);
+
+ DrawTabbedString(dc, textAttr, rect, stringFragment, x, y, true);
+
+#if USE_KERNING_FIX
+ if (stringChunk.Find(wxT("\t")) == wxNOT_FOUND)
+ {
+ // Compensate for kerning difference
+ wxString stringFragment2(str.Mid(s1 - offset, fragmentLen+1));
+ wxString stringFragment3(str.Mid(s1 - offset + fragmentLen, 1));
+
+ wxCoord w1, h1, w2, h2, w3, h3;
+ dc.GetTextExtent(stringFragment, & w1, & h1);
+ dc.GetTextExtent(stringFragment2, & w2, & h2);
+ dc.GetTextExtent(stringFragment3, & w3, & h3);
+
+ int kerningDiff = (w1 + w3) - w2;
+ x = x - kerningDiff;
+ }
+#endif
+ }
+
+ // 3. Remaining unselected chunk, if any
+ if (selectionRange.GetEnd() < range.GetEnd())
+ {
+ int s2 = wxMin(selectionRange.GetEnd()+1, range.GetEnd());
+ int r2 = range.GetEnd();
+
+ int fragmentLen = r2 - s2 + 1;
+ if (fragmentLen < 0)
+ {
+ wxLogDebug(wxT("Mid(%d, %d"), (int)(s2 - offset), (int)fragmentLen);
+ }
+ wxString stringFragment = str.Mid(s2 - offset, fragmentLen);
+
+ DrawTabbedString(dc, textAttr, rect, stringFragment, x, y, false);
+ }
+ }
+
+ return true;
+}
+
+bool wxRichTextPlainText::DrawTabbedString(wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect,wxString& str, wxCoord& x, wxCoord& y, bool selected)
+{
+ bool hasTabs = (str.Find(wxT('\t')) != wxNOT_FOUND);
+
+ wxArrayInt tabArray;
+ int tabCount;
+ if (hasTabs)
+ {
+ if (attr.GetTabs().IsEmpty())
+ tabArray = wxRichTextParagraph::GetDefaultTabs();
+ else
+ tabArray = attr.GetTabs();
+ tabCount = tabArray.GetCount();
+
+ for (int i = 0; i < tabCount; ++i)
+ {
+ int pos = tabArray[i];
+ pos = ConvertTenthsMMToPixels(dc, pos);
+ tabArray[i] = pos;
+ }
+ }
+ else
+ tabCount = 0;
+
+ int nextTabPos = -1;
+ int tabPos = -1;
+ wxCoord w, h;
+
+ if (selected)
+ {
+ wxColour highlightColour(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT));
+ wxColour highlightTextColour(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT));
+
+ wxCheckSetBrush(dc, wxBrush(highlightColour));
+ wxCheckSetPen(dc, wxPen(highlightColour));
+ dc.SetTextForeground(highlightTextColour);
+ dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
+ }
+ else
+ {
+ dc.SetTextForeground(attr.GetTextColour());
+
+ if (attr.HasFlag(wxTEXT_ATTR_BACKGROUND_COLOUR) && attr.GetBackgroundColour().IsOk())
+ {
+ dc.SetBackgroundMode(wxBRUSHSTYLE_SOLID);
+ dc.SetTextBackground(attr.GetBackgroundColour());
+ }
+ else
+ dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
+ }
+
+ wxCoord x_orig = GetParent()->GetPosition().x;
+ while (hasTabs)
+ {
+ // the string has a tab
+ // break up the string at the Tab
+ wxString stringChunk = str.BeforeFirst(wxT('\t'));
+ str = str.AfterFirst(wxT('\t'));
+ dc.GetTextExtent(stringChunk, & w, & h);
+ tabPos = x + w;
+ bool not_found = true;
+ for (int i = 0; i < tabCount && not_found; ++i)
+ {
+ nextTabPos = tabArray.Item(i) + x_orig;
+
+ // Find the next tab position.
+ // Even if we're at the end of the tab array, we must still draw the chunk.
+
+ if (nextTabPos > tabPos || (i == (tabCount - 1)))
+ {
+ if (nextTabPos <= tabPos)
+ {
+ int defaultTabWidth = ConvertTenthsMMToPixels(dc, WIDTH_FOR_DEFAULT_TABS);
+ nextTabPos = tabPos + defaultTabWidth;
+ }
+
+ not_found = false;
+ if (selected)
+ {
+ w = nextTabPos - x;
+ wxRect selRect(x, rect.y, w, rect.GetHeight());
+ dc.DrawRectangle(selRect);
+ }
+ dc.DrawText(stringChunk, x, y);
+
+ if (attr.HasTextEffects() && (attr.GetTextEffects() & wxTEXT_ATTR_EFFECT_STRIKETHROUGH))
+ {
+ wxPen oldPen = dc.GetPen();
+ wxCheckSetPen(dc, wxPen(attr.GetTextColour(), 1));
+ dc.DrawLine(x, (int) (y+(h/2)+0.5), x+w, (int) (y+(h/2)+0.5));
+ wxCheckSetPen(dc, oldPen);
+ }
+
+ x = nextTabPos;
+ }
+ }
+ hasTabs = (str.Find(wxT('\t')) != wxNOT_FOUND);
+ }
+
+ if (!str.IsEmpty())
+ {
+ dc.GetTextExtent(str, & w, & h);
+ if (selected)
+ {
+ wxRect selRect(x, rect.y, w, rect.GetHeight());
+ dc.DrawRectangle(selRect);
+ }
+ dc.DrawText(str, x, y);
+
+ if (attr.HasTextEffects() && (attr.GetTextEffects() & wxTEXT_ATTR_EFFECT_STRIKETHROUGH))
+ {
+ wxPen oldPen = dc.GetPen();
+ wxCheckSetPen(dc, wxPen(attr.GetTextColour(), 1));
+ dc.DrawLine(x, (int) (y+(h/2)+0.5), x+w, (int) (y+(h/2)+0.5));
+ wxCheckSetPen(dc, oldPen);
+ }
+
+ x += w;
+ }
+ return true;
+
+}
+
+/// Lay the item out
+bool wxRichTextPlainText::Layout(wxDC& dc, const wxRect& WXUNUSED(rect), int WXUNUSED(style))
+{
+ // Only lay out if we haven't already cached the size
+ if (m_size.x == -1)
+ GetRangeSize(GetRange(), m_size, m_descent, dc, 0, wxPoint(0, 0));
+ m_maxSize = m_size;
+ // Eventually we want to have a reasonable estimate of minimum size.
+ m_minSize = wxSize(0, 0);
+ return true;
+}
+
+/// Copy
+void wxRichTextPlainText::Copy(const wxRichTextPlainText& obj)
+{
+ wxRichTextObject::Copy(obj);
+
+ m_text = obj.m_text;
+}
+
+/// Get/set the object size for the given range. Returns false if the range
+/// is invalid for this object.
+bool wxRichTextPlainText::GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int WXUNUSED(flags), wxPoint position, wxArrayInt* partialExtents) const
+{
+ if (!range.IsWithin(GetRange()))
+ return false;
+
+ wxRichTextParagraph* para = wxDynamicCast(GetParent(), wxRichTextParagraph);
+ wxASSERT (para != NULL);
+
+ int relativeX = position.x - GetParent()->GetPosition().x;
+
+ wxRichTextAttr textAttr(para ? para->GetCombinedAttributes(GetAttributes()) : GetAttributes());
+
+ // Always assume unformatted text, since at this level we have no knowledge
+ // of line breaks - and we don't need it, since we'll calculate size within
+ // formatted text by doing it in chunks according to the line ranges
+
+ bool bScript(false);
+ wxFont font(GetBuffer()->GetFontTable().FindFont(textAttr));
+ if (font.IsOk())
+ {
+ if ( textAttr.HasTextEffects() && ( (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_SUPERSCRIPT)
+ || (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_SUBSCRIPT) ) )
+ {
+ wxFont textFont = font;
+ double size = static_cast<double>(textFont.GetPointSize()) / wxSCRIPT_MUL_FACTOR;
+ textFont.SetPointSize( static_cast<int>(size) );
+ wxCheckSetFont(dc, textFont);
+ bScript = true;
+ }
+ else
+ {
+ wxCheckSetFont(dc, font);
+ }
+ }
+
+ bool haveDescent = false;
+ int startPos = range.GetStart() - GetRange().GetStart();
+ long len = range.GetLength();
+
+ wxString str(m_text);
+ wxString toReplace = wxRichTextLineBreakChar;
+ str.Replace(toReplace, wxT(" "));
+
+ wxString stringChunk = str.Mid(startPos, (size_t) len);
+
+ if (textAttr.HasTextEffects() && (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_CAPITALS))
+ stringChunk.MakeUpper();
+
+ wxCoord w, h;
+ int width = 0;
+ if (stringChunk.Find(wxT('\t')) != wxNOT_FOUND)
+ {
+ // the string has a tab
+ wxArrayInt tabArray;
+ if (textAttr.GetTabs().IsEmpty())
+ tabArray = wxRichTextParagraph::GetDefaultTabs();
+ else
+ tabArray = textAttr.GetTabs();
+
+ int tabCount = tabArray.GetCount();
+
+ for (int i = 0; i < tabCount; ++i)
+ {
+ int pos = tabArray[i];
+ pos = ((wxRichTextPlainText*) this)->ConvertTenthsMMToPixels(dc, pos);
+ tabArray[i] = pos;
+ }
+
+ int nextTabPos = -1;
+
+ while (stringChunk.Find(wxT('\t')) >= 0)
+ {
+ int absoluteWidth = 0;
+
+ // the string has a tab
+ // break up the string at the Tab
+ wxString stringFragment = stringChunk.BeforeFirst(wxT('\t'));
+ stringChunk = stringChunk.AfterFirst(wxT('\t'));
+
+ if (partialExtents)
+ {
+ int oldWidth;
+ if (partialExtents->GetCount() > 0)
+ oldWidth = (*partialExtents)[partialExtents->GetCount()-1];
+ else
+ oldWidth = 0;
+
+ // Add these partial extents
+ wxArrayInt p;
+ dc.GetPartialTextExtents(stringFragment, p);
+ size_t j;
+ for (j = 0; j < p.GetCount(); j++)
+ partialExtents->Add(oldWidth + p[j]);
+
+ if (partialExtents->GetCount() > 0)
+ absoluteWidth = (*partialExtents)[(*partialExtents).GetCount()-1] + relativeX;
+ else
+ absoluteWidth = relativeX;
+ }
+ else
+ {
+ dc.GetTextExtent(stringFragment, & w, & h);
+ width += w;
+ absoluteWidth = width + relativeX;
+ haveDescent = true;
+ }
+
+ bool notFound = true;
+ for (int i = 0; i < tabCount && notFound; ++i)
+ {
+ nextTabPos = tabArray.Item(i);
+
+ // Find the next tab position.
+ // Even if we're at the end of the tab array, we must still process the chunk.
+
+ if (nextTabPos > absoluteWidth || (i == (tabCount - 1)))
+ {
+ if (nextTabPos <= absoluteWidth)
+ {
+ int defaultTabWidth = ((wxRichTextPlainText*) this)->ConvertTenthsMMToPixels(dc, WIDTH_FOR_DEFAULT_TABS);
+ nextTabPos = absoluteWidth + defaultTabWidth;
+ }
+
+ notFound = false;
+ width = nextTabPos - relativeX;
+
+ if (partialExtents)
+ partialExtents->Add(width);
+ }
+ }
+ }
+ }
+
+ if (!stringChunk.IsEmpty())
+ {
+ if (partialExtents)
+ {
+ int oldWidth;
+ if (partialExtents->GetCount() > 0)
+ oldWidth = (*partialExtents)[partialExtents->GetCount()-1];
+ else
+ oldWidth = 0;
+
+ // Add these partial extents
+ wxArrayInt p;
+ dc.GetPartialTextExtents(stringChunk, p);
+ size_t j;
+ for (j = 0; j < p.GetCount(); j++)
+ partialExtents->Add(oldWidth + p[j]);
+ }
+ else
+ {
+ dc.GetTextExtent(stringChunk, & w, & h, & descent);
+ width += w;
+ haveDescent = true;
+ }
+ }
+
+ if (partialExtents)
+ {
+ int charHeight = dc.GetCharHeight();
+ if ((*partialExtents).GetCount() > 0)
+ w = (*partialExtents)[partialExtents->GetCount()-1];
+ else
+ w = 0;
+ size = wxSize(w, charHeight);
+ }
+ else
+ {
+ size = wxSize(width, dc.GetCharHeight());
+ }
+
+ if (!haveDescent)
+ dc.GetTextExtent(wxT("X"), & w, & h, & descent);
+
+ if ( bScript )
+ dc.SetFont(font);
+
+ return true;
+}
+
+/// Do a split, returning an object containing the second part, and setting
+/// the first part in 'this'.
+wxRichTextObject* wxRichTextPlainText::DoSplit(long pos)
+{
+ long index = pos - GetRange().GetStart();
+
+ if (index < 0 || index >= (int) m_text.length())
+ return NULL;
+
+ wxString firstPart = m_text.Mid(0, index);
+ wxString secondPart = m_text.Mid(index);
+
+ m_text = firstPart;
+
+ wxRichTextPlainText* newObject = new wxRichTextPlainText(secondPart);
+ newObject->SetAttributes(GetAttributes());
+
+ newObject->SetRange(wxRichTextRange(pos, GetRange().GetEnd()));
+ GetRange().SetEnd(pos-1);
+
+ return newObject;
+}
+
+/// Calculate range
+void wxRichTextPlainText::CalculateRange(long start, long& end)
+{
+ end = start + m_text.length() - 1;
+ m_range.SetRange(start, end);
+}
+
+/// Delete range
+bool wxRichTextPlainText::DeleteRange(const wxRichTextRange& range)
+{
+ wxRichTextRange r = range;
+
+ r.LimitTo(GetRange());
+
+ if (r.GetStart() == GetRange().GetStart() && r.GetEnd() == GetRange().GetEnd())
+ {
+ m_text.Empty();
+ return true;
+ }
+
+ long startIndex = r.GetStart() - GetRange().GetStart();
+ long len = r.GetLength();
+
+ m_text = m_text.Mid(0, startIndex) + m_text.Mid(startIndex+len);
+ return true;
+}
+
+/// Get text for the given range.
+wxString wxRichTextPlainText::GetTextForRange(const wxRichTextRange& range) const
+{
+ wxRichTextRange r = range;
+
+ r.LimitTo(GetRange());
+
+ long startIndex = r.GetStart() - GetRange().GetStart();
+ long len = r.GetLength();
+
+ return m_text.Mid(startIndex, len);
+}
+
+/// Returns true if this object can merge itself with the given one.
+bool wxRichTextPlainText::CanMerge(wxRichTextObject* object) const
+{
+ return object->GetClassInfo() == CLASSINFO(wxRichTextPlainText) &&
+ (m_text.empty() || wxTextAttrEq(GetAttributes(), object->GetAttributes()));
+}
+
+/// Returns true if this object merged itself with the given one.
+/// The calling code will then delete the given object.
+bool wxRichTextPlainText::Merge(wxRichTextObject* object)
+{
+ wxRichTextPlainText* textObject = wxDynamicCast(object, wxRichTextPlainText);
+ wxASSERT( textObject != NULL );
+
+ if (textObject)
+ {
+ m_text += textObject->GetText();
+ wxRichTextApplyStyle(m_attributes, textObject->GetAttributes());
+ return true;
+ }
+ else
+ return false;
+}
+
+/// Dump to output stream for debugging
+void wxRichTextPlainText::Dump(wxTextOutputStream& stream)
+{
+ wxRichTextObject::Dump(stream);
+ stream << m_text << wxT("\n");
+}
+
+/// Get the first position from pos that has a line break character.
+long wxRichTextPlainText::GetFirstLineBreakPosition(long pos)
+{
+ int i;
+ int len = m_text.length();
+ int startPos = pos - m_range.GetStart();
+ for (i = startPos; i < len; i++)
+ {
+ wxChar ch = m_text[i];
+ if (ch == wxRichTextLineBreakChar)
+ {
+ return i + m_range.GetStart();
+ }
+ }
+ return -1;
+}
+
+/*!
+ * wxRichTextBuffer
+ * This is a kind of box, used to represent the whole buffer
+ */
+
+IMPLEMENT_DYNAMIC_CLASS(wxRichTextBuffer, wxRichTextParagraphLayoutBox)
+
+wxList wxRichTextBuffer::sm_handlers;
+wxRichTextRenderer* wxRichTextBuffer::sm_renderer = NULL;
+int wxRichTextBuffer::sm_bulletRightMargin = 20;
+float wxRichTextBuffer::sm_bulletProportion = (float) 0.3;
+
+/// Initialisation
+void wxRichTextBuffer::Init()
+{
+ m_commandProcessor = new wxCommandProcessor;
+ m_styleSheet = NULL;
+ m_modified = false;
+ m_batchedCommandDepth = 0;
+ m_batchedCommand = NULL;
+ m_suppressUndo = 0;
+ m_handlerFlags = 0;
+ m_scale = 1.0;
+}
+
+/// Initialisation
+wxRichTextBuffer::~wxRichTextBuffer()
+{
+ delete m_commandProcessor;
+ delete m_batchedCommand;
+
+ ClearStyleStack();
+ ClearEventHandlers();
+}
+
+void wxRichTextBuffer::ResetAndClearCommands()
+{
+ Reset();
+
+ GetCommandProcessor()->ClearCommands();
+
+ Modify(false);
+ Invalidate(wxRICHTEXT_ALL);
+}
+
+void wxRichTextBuffer::Copy(const wxRichTextBuffer& obj)
+{
+ wxRichTextParagraphLayoutBox::Copy(obj);
+
+ m_styleSheet = obj.m_styleSheet;
+ m_modified = obj.m_modified;
+ m_batchedCommandDepth = 0;
+ if (m_batchedCommand)
+ delete m_batchedCommand;
+ m_batchedCommand = NULL;
+ m_suppressUndo = obj.m_suppressUndo;
+ m_invalidRange = obj.m_invalidRange;
+}
+
+/// Push style sheet to top of stack
+bool wxRichTextBuffer::PushStyleSheet(wxRichTextStyleSheet* styleSheet)
+{
+ if (m_styleSheet)
+ styleSheet->InsertSheet(m_styleSheet);
+
+ SetStyleSheet(styleSheet);
+
+ return true;
+}
+
+/// Pop style sheet from top of stack
+wxRichTextStyleSheet* wxRichTextBuffer::PopStyleSheet()
+{
+ if (m_styleSheet)
+ {
+ wxRichTextStyleSheet* oldSheet = m_styleSheet;
+ m_styleSheet = oldSheet->GetNextSheet();
+ oldSheet->Unlink();
+
+ return oldSheet;
+ }
+ else
+ return NULL;
+}
+
+/// Submit command to insert paragraphs
+bool wxRichTextBuffer::InsertParagraphsWithUndo(long pos, const wxRichTextParagraphLayoutBox& paragraphs, wxRichTextCtrl* ctrl, int flags)
+{
+ return ctrl->GetFocusObject()->InsertParagraphsWithUndo(pos, paragraphs, ctrl, this, flags);
+}
+
+/// Submit command to insert paragraphs
+bool wxRichTextParagraphLayoutBox::InsertParagraphsWithUndo(long pos, const wxRichTextParagraphLayoutBox& paragraphs, wxRichTextCtrl* ctrl, wxRichTextBuffer* buffer, int WXUNUSED(flags))
+{
+ wxRichTextAction* action = new wxRichTextAction(NULL, _("Insert Text"), wxRICHTEXT_INSERT, buffer, this, ctrl, false);
+
+ action->GetNewParagraphs() = paragraphs;
+
+ action->SetPosition(pos);
+
+ wxRichTextRange range = wxRichTextRange(pos, pos + paragraphs.GetOwnRange().GetEnd() - 1);
+ if (!paragraphs.GetPartialParagraph())
+ range.SetEnd(range.GetEnd()+1);
+
+ // Set the range we'll need to delete in Undo
+ action->SetRange(range);
+
+ buffer->SubmitAction(action);
+
+ return true;
+}
+
+/// Submit command to insert the given text
+bool wxRichTextBuffer::InsertTextWithUndo(long pos, const wxString& text, wxRichTextCtrl* ctrl, int flags)
+{
+ return ctrl->GetFocusObject()->InsertTextWithUndo(pos, text, ctrl, this, flags);
+}
+
+/// Submit command to insert the given text
+bool wxRichTextParagraphLayoutBox::InsertTextWithUndo(long pos, const wxString& text, wxRichTextCtrl* ctrl, wxRichTextBuffer* buffer, int flags)
+{
+ wxRichTextAction* action = new wxRichTextAction(NULL, _("Insert Text"), wxRICHTEXT_INSERT, buffer, this, ctrl, false);
+
+ wxRichTextAttr* p = NULL;
+ wxRichTextAttr paraAttr;
+ if (flags & wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE)
+ {
+ // Get appropriate paragraph style
+ paraAttr = GetStyleForNewParagraph(buffer, pos, false, false);
+ if (!paraAttr.IsDefault())
+ p = & paraAttr;
+ }
+
+ action->GetNewParagraphs().AddParagraphs(text, p);
+
+ int length = action->GetNewParagraphs().GetOwnRange().GetLength();
+
+ if (!text.empty() && text.Last() != wxT('\n'))
+ {
+ // Don't count the newline when undoing
+ length --;
+ action->GetNewParagraphs().SetPartialParagraph(true);
+ }
+ else if (!text.empty() && text.Last() == wxT('\n'))
+ length --;
projects / wxWidgets.git / blobdiff