1 /////////////////////////////////////////////////////////////////////////////
2 // Name: richtext/richtextbuffer.cpp
3 // Purpose: Buffer for wxRichTextCtrl
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
21 #include "wx/richtext/richtextbuffer.h"
27 #include "wx/filename.h"
28 #include "wx/clipbrd.h"
29 #include "wx/dataobj.h"
30 #include "wx/wfstream.h"
31 #include "wx/module.h"
32 #include "wx/mstream.h"
33 #include "wx/sstream.h"
35 #include "wx/richtext/richtextctrl.h"
36 #include "wx/richtext/richtextstyles.h"
38 #include "wx/listimpl.cpp"
40 WX_DEFINE_LIST(wxRichTextObjectList
)
41 WX_DEFINE_LIST(wxRichTextLineList
)
45 * This is the base for drawable objects.
48 IMPLEMENT_CLASS(wxRichTextObject
, wxObject
)
50 wxRichTextObject::wxRichTextObject(wxRichTextObject
* parent
)
62 wxRichTextObject::~wxRichTextObject()
66 void wxRichTextObject::Dereference()
74 void wxRichTextObject::Copy(const wxRichTextObject
& obj
)
78 m_dirty
= obj
.m_dirty
;
79 m_range
= obj
.m_range
;
80 m_attributes
= obj
.m_attributes
;
81 m_descent
= obj
.m_descent
;
83 if (!m_attributes
.GetFont().Ok())
84 wxLogDebug(wxT("No font!"));
85 if (!obj
.m_attributes
.GetFont().Ok())
86 wxLogDebug(wxT("Parent has no font!"));
89 void wxRichTextObject::SetMargins(int margin
)
91 m_leftMargin
= m_rightMargin
= m_topMargin
= m_bottomMargin
= margin
;
94 void wxRichTextObject::SetMargins(int leftMargin
, int rightMargin
, int topMargin
, int bottomMargin
)
96 m_leftMargin
= leftMargin
;
97 m_rightMargin
= rightMargin
;
98 m_topMargin
= topMargin
;
99 m_bottomMargin
= bottomMargin
;
102 // Convert units in tends of a millimetre to device units
103 int wxRichTextObject::ConvertTenthsMMToPixels(wxDC
& dc
, int units
)
105 int ppi
= dc
.GetPPI().x
;
107 // There are ppi pixels in 254.1 "1/10 mm"
109 double pixels
= ((double) units
* (double)ppi
) / 254.1;
114 /// Dump to output stream for debugging
115 void wxRichTextObject::Dump(wxTextOutputStream
& stream
)
117 stream
<< GetClassInfo()->GetClassName() << wxT("\n");
118 stream
<< wxString::Format(wxT("Size: %d,%d. Position: %d,%d, Range: %ld,%ld"), m_size
.x
, m_size
.y
, m_pos
.x
, m_pos
.y
, m_range
.GetStart(), m_range
.GetEnd()) << wxT("\n");
119 stream
<< wxString::Format(wxT("Text colour: %d,%d,%d."), (int) m_attributes
.GetTextColour().Red(), (int) m_attributes
.GetTextColour().Green(), (int) m_attributes
.GetTextColour().Blue()) << wxT("\n");
124 * wxRichTextCompositeObject
125 * This is the base for drawable objects.
128 IMPLEMENT_CLASS(wxRichTextCompositeObject
, wxRichTextObject
)
130 wxRichTextCompositeObject::wxRichTextCompositeObject(wxRichTextObject
* parent
):
131 wxRichTextObject(parent
)
135 wxRichTextCompositeObject::~wxRichTextCompositeObject()
140 /// Get the nth child
141 wxRichTextObject
* wxRichTextCompositeObject::GetChild(size_t n
) const
143 wxASSERT ( n
< m_children
.GetCount() );
145 return m_children
.Item(n
)->GetData();
148 /// Append a child, returning the position
149 size_t wxRichTextCompositeObject::AppendChild(wxRichTextObject
* child
)
151 m_children
.Append(child
);
152 child
->SetParent(this);
153 return m_children
.GetCount() - 1;
156 /// Insert the child in front of the given object, or at the beginning
157 bool wxRichTextCompositeObject::InsertChild(wxRichTextObject
* child
, wxRichTextObject
* inFrontOf
)
161 wxRichTextObjectList::compatibility_iterator node
= m_children
.Find(inFrontOf
);
162 m_children
.Insert(node
, child
);
165 m_children
.Insert(child
);
166 child
->SetParent(this);
172 bool wxRichTextCompositeObject::RemoveChild(wxRichTextObject
* child
, bool deleteChild
)
174 wxRichTextObjectList::compatibility_iterator node
= m_children
.Find(child
);
177 wxRichTextObject
* obj
= node
->GetData();
178 m_children
.Erase(node
);
187 /// Delete all children
188 bool wxRichTextCompositeObject::DeleteChildren()
190 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
193 wxRichTextObjectList::compatibility_iterator oldNode
= node
;
195 wxRichTextObject
* child
= node
->GetData();
196 child
->Dereference(); // Only delete if reference count is zero
198 node
= node
->GetNext();
199 m_children
.Erase(oldNode
);
205 /// Get the child count
206 size_t wxRichTextCompositeObject::GetChildCount() const
208 return m_children
.GetCount();
212 void wxRichTextCompositeObject::Copy(const wxRichTextCompositeObject
& obj
)
214 wxRichTextObject::Copy(obj
);
218 wxRichTextObjectList::compatibility_iterator node
= obj
.m_children
.GetFirst();
221 wxRichTextObject
* child
= node
->GetData();
222 m_children
.Append(child
->Clone());
224 node
= node
->GetNext();
228 /// Hit-testing: returns a flag indicating hit test details, plus
229 /// information about position
230 int wxRichTextCompositeObject::HitTest(wxDC
& dc
, const wxPoint
& pt
, long& textPosition
)
232 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
235 wxRichTextObject
* child
= node
->GetData();
237 int ret
= child
->HitTest(dc
, pt
, textPosition
);
238 if (ret
!= wxRICHTEXT_HITTEST_NONE
)
241 node
= node
->GetNext();
244 return wxRICHTEXT_HITTEST_NONE
;
247 /// Finds the absolute position and row height for the given character position
248 bool wxRichTextCompositeObject::FindPosition(wxDC
& dc
, long index
, wxPoint
& pt
, int* height
, bool forceLineStart
)
250 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
253 wxRichTextObject
* child
= node
->GetData();
255 if (child
->FindPosition(dc
, index
, pt
, height
, forceLineStart
))
258 node
= node
->GetNext();
265 void wxRichTextCompositeObject::CalculateRange(long start
, long& end
)
267 long current
= start
;
268 long lastEnd
= current
;
270 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
273 wxRichTextObject
* child
= node
->GetData();
276 child
->CalculateRange(current
, childEnd
);
279 current
= childEnd
+ 1;
281 node
= node
->GetNext();
286 // An object with no children has zero length
287 if (m_children
.GetCount() == 0)
290 m_range
.SetRange(start
, end
);
293 /// Delete range from layout.
294 bool wxRichTextCompositeObject::DeleteRange(const wxRichTextRange
& range
)
296 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
300 wxRichTextObject
* obj
= (wxRichTextObject
*) node
->GetData();
301 wxRichTextObjectList::compatibility_iterator next
= node
->GetNext();
303 // Delete the range in each paragraph
305 // When a chunk has been deleted, internally the content does not
306 // now match the ranges.
307 // However, so long as deletion is not done on the same object twice this is OK.
308 // If you may delete content from the same object twice, recalculate
309 // the ranges inbetween DeleteRange calls by calling CalculateRanges, and
310 // adjust the range you're deleting accordingly.
312 if (!obj
->GetRange().IsOutside(range
))
314 obj
->DeleteRange(range
);
316 // Delete an empty object, or paragraph within this range.
317 if (obj
->IsEmpty() ||
318 (range
.GetStart() <= obj
->GetRange().GetStart() && range
.GetEnd() >= obj
->GetRange().GetEnd()))
320 // An empty paragraph has length 1, so won't be deleted unless the
321 // whole range is deleted.
322 RemoveChild(obj
, true);
332 /// Get any text in this object for the given range
333 wxString
wxRichTextCompositeObject::GetTextForRange(const wxRichTextRange
& range
) const
336 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
339 wxRichTextObject
* child
= node
->GetData();
340 wxRichTextRange childRange
= range
;
341 if (!child
->GetRange().IsOutside(range
))
343 childRange
.LimitTo(child
->GetRange());
345 wxString childText
= child
->GetTextForRange(childRange
);
349 node
= node
->GetNext();
355 /// Recursively merge all pieces that can be merged.
356 bool wxRichTextCompositeObject::Defragment()
358 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
361 wxRichTextObject
* child
= node
->GetData();
362 wxRichTextCompositeObject
* composite
= wxDynamicCast(child
, wxRichTextCompositeObject
);
364 composite
->Defragment();
368 wxRichTextObject
* nextChild
= node
->GetNext()->GetData();
369 if (child
->CanMerge(nextChild
) && child
->Merge(nextChild
))
371 nextChild
->Dereference();
372 m_children
.Erase(node
->GetNext());
374 // Don't set node -- we'll see if we can merge again with the next
378 node
= node
->GetNext();
381 node
= node
->GetNext();
387 /// Dump to output stream for debugging
388 void wxRichTextCompositeObject::Dump(wxTextOutputStream
& stream
)
390 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
393 wxRichTextObject
* child
= node
->GetData();
395 node
= node
->GetNext();
402 * This defines a 2D space to lay out objects
405 IMPLEMENT_DYNAMIC_CLASS(wxRichTextBox
, wxRichTextCompositeObject
)
407 wxRichTextBox::wxRichTextBox(wxRichTextObject
* parent
):
408 wxRichTextCompositeObject(parent
)
413 bool wxRichTextBox::Draw(wxDC
& dc
, const wxRichTextRange
& range
, const wxRichTextRange
& selectionRange
, const wxRect
& WXUNUSED(rect
), int descent
, int style
)
415 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
418 wxRichTextObject
* child
= node
->GetData();
420 wxRect childRect
= wxRect(child
->GetPosition(), child
->GetCachedSize());
421 child
->Draw(dc
, range
, selectionRange
, childRect
, descent
, style
);
423 node
= node
->GetNext();
429 bool wxRichTextBox::Layout(wxDC
& dc
, const wxRect
& rect
, int style
)
431 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
434 wxRichTextObject
* child
= node
->GetData();
435 child
->Layout(dc
, rect
, style
);
437 node
= node
->GetNext();
443 /// Get/set the size for the given range. Assume only has one child.
444 bool wxRichTextBox::GetRangeSize(const wxRichTextRange
& range
, wxSize
& size
, int& descent
, wxDC
& dc
, int flags
, wxPoint position
) const
446 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
449 wxRichTextObject
* child
= node
->GetData();
450 return child
->GetRangeSize(range
, size
, descent
, dc
, flags
, position
);
457 void wxRichTextBox::Copy(const wxRichTextBox
& obj
)
459 wxRichTextCompositeObject::Copy(obj
);
464 * wxRichTextParagraphLayoutBox
465 * This box knows how to lay out paragraphs.
468 IMPLEMENT_DYNAMIC_CLASS(wxRichTextParagraphLayoutBox
, wxRichTextBox
)
470 wxRichTextParagraphLayoutBox::wxRichTextParagraphLayoutBox(wxRichTextObject
* parent
):
471 wxRichTextBox(parent
)
476 /// Initialize the object.
477 void wxRichTextParagraphLayoutBox::Init()
481 // For now, assume is the only box and has no initial size.
482 m_range
= wxRichTextRange(0, -1);
484 m_invalidRange
.SetRange(-1, -1);
492 bool wxRichTextParagraphLayoutBox::Draw(wxDC
& dc
, const wxRichTextRange
& range
, const wxRichTextRange
& selectionRange
, const wxRect
& rect
, int descent
, int style
)
494 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
497 wxRichTextParagraph
* child
= wxDynamicCast(node
->GetData(), wxRichTextParagraph
);
498 wxASSERT (child
!= NULL
);
500 if (child
&& !child
->GetRange().IsOutside(range
))
502 wxRect
childRect(child
->GetPosition(), child
->GetCachedSize());
504 if (childRect
.GetTop() > rect
.GetBottom() || childRect
.GetBottom() < rect
.GetTop())
509 child
->Draw(dc
, child
->GetRange(), selectionRange
, childRect
, descent
, style
);
512 node
= node
->GetNext();
518 bool wxRichTextParagraphLayoutBox::Layout(wxDC
& dc
, const wxRect
& rect
, int style
)
520 wxRect availableSpace
;
521 bool formatRect
= (style
& wxRICHTEXT_LAYOUT_SPECIFIED_RECT
) == wxRICHTEXT_LAYOUT_SPECIFIED_RECT
;
523 // If only laying out a specific area, the passed rect has a different meaning:
524 // the visible part of the buffer.
527 availableSpace
= wxRect(0 + m_leftMargin
,
529 rect
.width
- m_leftMargin
- m_rightMargin
,
532 // Invalidate the part of the buffer from the first visible line
533 // to the end. If other parts of the buffer are currently invalid,
534 // then they too will be taken into account if they are above
535 // the visible point.
537 wxRichTextLine
* line
= GetLineAtYPosition(rect
.y
);
539 startPos
= line
->GetAbsoluteRange().GetStart();
541 Invalidate(wxRichTextRange(startPos
, GetRange().GetEnd()));
544 availableSpace
= wxRect(rect
.x
+ m_leftMargin
,
545 rect
.y
+ m_topMargin
,
546 rect
.width
- m_leftMargin
- m_rightMargin
,
547 rect
.height
- m_topMargin
- m_bottomMargin
);
551 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
553 bool layoutAll
= true;
555 // Get invalid range, rounding to paragraph start/end.
556 wxRichTextRange invalidRange
= GetInvalidRange(true);
558 if (invalidRange
== wxRICHTEXT_NONE
&& !formatRect
)
561 if (invalidRange
== wxRICHTEXT_ALL
)
563 else // If we know what range is affected, start laying out from that point on.
564 if (invalidRange
.GetStart() > GetRange().GetStart())
566 wxRichTextParagraph
* firstParagraph
= GetParagraphAtPosition(invalidRange
.GetStart());
569 wxRichTextObjectList::compatibility_iterator firstNode
= m_children
.Find(firstParagraph
);
570 wxRichTextObjectList::compatibility_iterator previousNode
;
572 previousNode
= firstNode
->GetPrevious();
573 if (firstNode
&& previousNode
)
575 wxRichTextParagraph
* previousParagraph
= wxDynamicCast(previousNode
->GetData(), wxRichTextParagraph
);
576 availableSpace
.y
= previousParagraph
->GetPosition().y
+ previousParagraph
->GetCachedSize().y
;
578 // Now we're going to start iterating from the first affected paragraph.
586 // A way to force speedy rest-of-buffer layout (the 'else' below)
587 bool forceQuickLayout
= false;
591 // Assume this box only contains paragraphs
593 wxRichTextParagraph
* child
= wxDynamicCast(node
->GetData(), wxRichTextParagraph
);
594 wxCHECK_MSG( child
, false, _T("Unknown object in layout") );
596 // TODO: what if the child hasn't been laid out (e.g. involved in Undo) but still has 'old' lines
597 if ( !forceQuickLayout
&&
599 child
->GetLines().IsEmpty() ||
600 !child
->GetRange().IsOutside(invalidRange
)) )
602 child
->Layout(dc
, availableSpace
, style
);
604 // Layout must set the cached size
605 availableSpace
.y
+= child
->GetCachedSize().y
;
606 maxWidth
= wxMax(maxWidth
, child
->GetCachedSize().x
);
608 // If we're just formatting the visible part of the buffer,
609 // and we're now past the bottom of the window, start quick
611 if (formatRect
&& child
->GetPosition().y
> rect
.GetBottom())
612 forceQuickLayout
= true;
616 // We're outside the immediately affected range, so now let's just
617 // move everything up or down. This assumes that all the children have previously
618 // been laid out and have wrapped line lists associated with them.
619 // TODO: check all paragraphs before the affected range.
621 int inc
= availableSpace
.y
- child
->GetPosition().y
;
625 wxRichTextParagraph
* child
= wxDynamicCast(node
->GetData(), wxRichTextParagraph
);
628 if (child
->GetLines().GetCount() == 0)
629 child
->Layout(dc
, availableSpace
, style
);
631 child
->SetPosition(wxPoint(child
->GetPosition().x
, child
->GetPosition().y
+ inc
));
633 availableSpace
.y
+= child
->GetCachedSize().y
;
634 maxWidth
= wxMax(maxWidth
, child
->GetCachedSize().x
);
637 node
= node
->GetNext();
642 node
= node
->GetNext();
645 SetCachedSize(wxSize(maxWidth
, availableSpace
.y
));
648 m_invalidRange
= wxRICHTEXT_NONE
;
654 void wxRichTextParagraphLayoutBox::Copy(const wxRichTextParagraphLayoutBox
& obj
)
656 wxRichTextBox::Copy(obj
);
659 /// Get/set the size for the given range.
660 bool wxRichTextParagraphLayoutBox::GetRangeSize(const wxRichTextRange
& range
, wxSize
& size
, int& descent
, wxDC
& dc
, int flags
, wxPoint position
) const
664 wxRichTextObjectList::compatibility_iterator startPara
= wxRichTextObjectList::compatibility_iterator();
665 wxRichTextObjectList::compatibility_iterator endPara
= wxRichTextObjectList::compatibility_iterator();
667 // First find the first paragraph whose starting position is within the range.
668 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
671 // child is a paragraph
672 wxRichTextObject
* child
= node
->GetData();
673 const wxRichTextRange
& r
= child
->GetRange();
675 if (r
.GetStart() <= range
.GetStart() && r
.GetEnd() >= range
.GetStart())
681 node
= node
->GetNext();
684 // Next find the last paragraph containing part of the range
685 node
= m_children
.GetFirst();
688 // child is a paragraph
689 wxRichTextObject
* child
= node
->GetData();
690 const wxRichTextRange
& r
= child
->GetRange();
692 if (r
.GetStart() <= range
.GetEnd() && r
.GetEnd() >= range
.GetEnd())
698 node
= node
->GetNext();
701 if (!startPara
|| !endPara
)
704 // Now we can add up the sizes
705 for (node
= startPara
; node
; node
= node
->GetNext())
707 // child is a paragraph
708 wxRichTextObject
* child
= node
->GetData();
709 const wxRichTextRange
& childRange
= child
->GetRange();
710 wxRichTextRange rangeToFind
= range
;
711 rangeToFind
.LimitTo(childRange
);
715 int childDescent
= 0;
716 child
->GetRangeSize(rangeToFind
, childSize
, childDescent
, dc
, flags
, position
);
718 descent
= wxMax(childDescent
, descent
);
720 sz
.x
= wxMax(sz
.x
, childSize
.x
);
732 /// Get the paragraph at the given position
733 wxRichTextParagraph
* wxRichTextParagraphLayoutBox::GetParagraphAtPosition(long pos
, bool caretPosition
) const
738 // First find the first paragraph whose starting position is within the range.
739 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
742 // child is a paragraph
743 wxRichTextParagraph
* child
= wxDynamicCast(node
->GetData(), wxRichTextParagraph
);
744 wxASSERT (child
!= NULL
);
746 // Return first child in buffer if position is -1
750 if (child
->GetRange().Contains(pos
))
753 node
= node
->GetNext();
758 /// Get the line at the given position
759 wxRichTextLine
* wxRichTextParagraphLayoutBox::GetLineAtPosition(long pos
, bool caretPosition
) const
764 // First find the first paragraph whose starting position is within the range.
765 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
768 // child is a paragraph
769 wxRichTextParagraph
* child
= wxDynamicCast(node
->GetData(), wxRichTextParagraph
);
770 wxASSERT (child
!= NULL
);
772 wxRichTextLineList::compatibility_iterator node2
= child
->GetLines().GetFirst();
775 wxRichTextLine
* line
= node2
->GetData();
777 wxRichTextRange range
= line
->GetAbsoluteRange();
779 if (range
.Contains(pos
) ||
781 // If the position is end-of-paragraph, then return the last line of
783 (range
.GetEnd() == child
->GetRange().GetEnd()-1) && (pos
== child
->GetRange().GetEnd()))
786 node2
= node2
->GetNext();
789 node
= node
->GetNext();
792 int lineCount
= GetLineCount();
794 return GetLineForVisibleLineNumber(lineCount
-1);
799 /// Get the line at the given y pixel position, or the last line.
800 wxRichTextLine
* wxRichTextParagraphLayoutBox::GetLineAtYPosition(int y
) const
802 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
805 wxRichTextParagraph
* child
= wxDynamicCast(node
->GetData(), wxRichTextParagraph
);
806 wxASSERT (child
!= NULL
);
808 wxRichTextLineList::compatibility_iterator node2
= child
->GetLines().GetFirst();
811 wxRichTextLine
* line
= node2
->GetData();
813 wxRect
rect(line
->GetRect());
815 if (y
<= rect
.GetBottom())
818 node2
= node2
->GetNext();
821 node
= node
->GetNext();
825 int lineCount
= GetLineCount();
827 return GetLineForVisibleLineNumber(lineCount
-1);
832 /// Get the number of visible lines
833 int wxRichTextParagraphLayoutBox::GetLineCount() const
837 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
840 wxRichTextParagraph
* child
= wxDynamicCast(node
->GetData(), wxRichTextParagraph
);
841 wxASSERT (child
!= NULL
);
843 count
+= child
->GetLines().GetCount();
844 node
= node
->GetNext();
850 /// Get the paragraph for a given line
851 wxRichTextParagraph
* wxRichTextParagraphLayoutBox::GetParagraphForLine(wxRichTextLine
* line
) const
853 return GetParagraphAtPosition(line
->GetAbsoluteRange().GetStart());
856 /// Get the line size at the given position
857 wxSize
wxRichTextParagraphLayoutBox::GetLineSizeAtPosition(long pos
, bool caretPosition
) const
859 wxRichTextLine
* line
= GetLineAtPosition(pos
, caretPosition
);
862 return line
->GetSize();
869 /// Convenience function to add a paragraph of text
870 wxRichTextRange
wxRichTextParagraphLayoutBox::AddParagraph(const wxString
& text
)
872 wxTextAttrEx
style(GetAttributes());
874 // Apply default style. If the style has no attributes set,
875 // then the attributes will remain the 'basic style' (i.e. the
876 // layout box's style).
877 wxRichTextApplyStyle(style
, GetDefaultStyle());
879 wxRichTextParagraph
* para
= new wxRichTextParagraph(text
, this, & style
);
886 return para
->GetRange();
889 /// Adds multiple paragraphs, based on newlines.
890 wxRichTextRange
wxRichTextParagraphLayoutBox::AddParagraphs(const wxString
& text
)
892 wxTextAttrEx
style(GetAttributes());
893 //wxLogDebug("Initial style = %s", style.GetFont().GetFaceName());
894 //wxLogDebug("Initial size = %d", style.GetFont().GetPointSize());
896 // Apply default style. If the style has no attributes set,
897 // then the attributes will remain the 'basic style' (i.e. the
898 // layout box's style).
899 wxRichTextApplyStyle(style
, GetDefaultStyle());
901 //wxLogDebug("Style after applying default style = %s", style.GetFont().GetFaceName());
902 //wxLogDebug("Size after applying default style = %d", style.GetFont().GetPointSize());
904 wxRichTextParagraph
* firstPara
= NULL
;
905 wxRichTextParagraph
* lastPara
= NULL
;
907 wxRichTextRange
range(-1, -1);
909 size_t len
= text
.Length();
914 if (ch
== wxT('\n') || ch
== wxT('\r'))
916 wxRichTextParagraph
* para
= new wxRichTextParagraph(line
, this, & style
);
922 line
= wxEmptyString
;
931 lastPara
= new wxRichTextParagraph(line
, this, & style
);
932 //wxLogDebug("Para Face = %s", lastPara->GetAttributes().GetFont().GetFaceName());
933 AppendChild(lastPara
);
937 range
.SetStart(firstPara
->GetRange().GetStart());
939 range
.SetStart(lastPara
->GetRange().GetStart());
942 range
.SetEnd(lastPara
->GetRange().GetEnd());
944 range
.SetEnd(firstPara
->GetRange().GetEnd());
952 /// Convenience function to add an image
953 wxRichTextRange
wxRichTextParagraphLayoutBox::AddImage(const wxImage
& image
)
955 wxTextAttrEx
style(GetAttributes());
957 // Apply default style. If the style has no attributes set,
958 // then the attributes will remain the 'basic style' (i.e. the
959 // layout box's style).
960 wxRichTextApplyStyle(style
, GetDefaultStyle());
962 wxRichTextParagraph
* para
= new wxRichTextParagraph(this, & style
);
964 para
->AppendChild(new wxRichTextImage(image
, this));
969 return para
->GetRange();
973 /// Insert fragment into this box at the given position. If partialParagraph is true,
974 /// it is assumed that the last (or only) paragraph is just a piece of data with no paragraph
976 /// TODO: if fragment is inserted inside styled fragment, must apply that style to
977 /// to the data (if it has a default style, anyway).
979 bool wxRichTextParagraphLayoutBox::InsertFragment(long position
, wxRichTextFragment
& fragment
)
983 // First, find the first paragraph whose starting position is within the range.
984 wxRichTextParagraph
* para
= GetParagraphAtPosition(position
);
987 wxRichTextObjectList::compatibility_iterator node
= m_children
.Find(para
);
989 // Now split at this position, returning the object to insert the new
991 wxRichTextObject
* nextObject
= para
->SplitAt(position
);
993 // Special case: partial paragraph, just one paragraph. Might be a small amount of
994 // text, for example, so let's optimize.
996 if (fragment
.GetPartialParagraph() && fragment
.GetChildren().GetCount() == 1)
998 // Add the first para to this para...
999 wxRichTextObjectList::compatibility_iterator firstParaNode
= fragment
.GetChildren().GetFirst();
1003 // Iterate through the fragment paragraph inserting the content into this paragraph.
1004 wxRichTextParagraph
* firstPara
= wxDynamicCast(firstParaNode
->GetData(), wxRichTextParagraph
);
1005 wxASSERT (firstPara
!= NULL
);
1007 wxRichTextObjectList::compatibility_iterator objectNode
= firstPara
->GetChildren().GetFirst();
1010 wxRichTextObject
* newObj
= objectNode
->GetData()->Clone();
1015 para
->AppendChild(newObj
);
1019 // Insert before nextObject
1020 para
->InsertChild(newObj
, nextObject
);
1023 objectNode
= objectNode
->GetNext();
1030 // Procedure for inserting a fragment consisting of a number of
1033 // 1. Remove and save the content that's after the insertion point, for adding
1034 // back once we've added the fragment.
1035 // 2. Add the content from the first fragment paragraph to the current
1037 // 3. Add remaining fragment paragraphs after the current paragraph.
1038 // 4. Add back the saved content from the first paragraph. If partialParagraph
1039 // is true, add it to the last paragraph added and not a new one.
1041 // 1. Remove and save objects after split point.
1042 wxList savedObjects
;
1044 para
->MoveToList(nextObject
, savedObjects
);
1046 // 2. Add the content from the 1st fragment paragraph.
1047 wxRichTextObjectList::compatibility_iterator firstParaNode
= fragment
.GetChildren().GetFirst();
1051 wxRichTextParagraph
* firstPara
= wxDynamicCast(firstParaNode
->GetData(), wxRichTextParagraph
);
1052 wxASSERT(firstPara
!= NULL
);
1054 wxRichTextObjectList::compatibility_iterator objectNode
= firstPara
->GetChildren().GetFirst();
1057 wxRichTextObject
* newObj
= objectNode
->GetData()->Clone();
1060 para
->AppendChild(newObj
);
1062 objectNode
= objectNode
->GetNext();
1065 // 3. Add remaining fragment paragraphs after the current paragraph.
1066 wxRichTextObjectList::compatibility_iterator nextParagraphNode
= node
->GetNext();
1067 wxRichTextObject
* nextParagraph
= NULL
;
1068 if (nextParagraphNode
)
1069 nextParagraph
= nextParagraphNode
->GetData();
1071 wxRichTextObjectList::compatibility_iterator i
= fragment
.GetChildren().GetFirst()->GetNext();
1072 wxRichTextParagraph
* finalPara
= para
;
1074 // If there was only one paragraph, we need to insert a new one.
1077 finalPara
= new wxRichTextParagraph
;
1079 // TODO: These attributes should come from the subsequent paragraph
1080 // when originally deleted, since the subsequent para takes on
1081 // the previous para's attributes.
1082 finalPara
->SetAttributes(firstPara
->GetAttributes());
1085 InsertChild(finalPara
, nextParagraph
);
1087 AppendChild(finalPara
);
1091 wxRichTextParagraph
* para
= wxDynamicCast(i
->GetData(), wxRichTextParagraph
);
1092 wxASSERT( para
!= NULL
);
1094 finalPara
= (wxRichTextParagraph
*) para
->Clone();
1097 InsertChild(finalPara
, nextParagraph
);
1099 AppendChild(finalPara
);
1104 // 4. Add back the remaining content.
1107 finalPara
->MoveFromList(savedObjects
);
1109 // Ensure there's at least one object
1110 if (finalPara
->GetChildCount() == 0)
1112 wxRichTextPlainText
* text
= new wxRichTextPlainText(wxEmptyString
);
1113 text
->SetAttributes(finalPara
->GetAttributes());
1115 finalPara
->AppendChild(text
);
1125 wxRichTextObjectList::compatibility_iterator i
= fragment
.GetChildren().GetFirst();
1128 wxRichTextParagraph
* para
= wxDynamicCast(i
->GetData(), wxRichTextParagraph
);
1129 wxASSERT( para
!= NULL
);
1131 AppendChild(para
->Clone());
1140 /// Make a copy of the fragment corresponding to the given range, putting it in 'fragment'.
1141 /// If there was an incomplete paragraph at the end, partialParagraph is set to true.
1142 bool wxRichTextParagraphLayoutBox::CopyFragment(const wxRichTextRange
& range
, wxRichTextFragment
& fragment
)
1144 wxRichTextObjectList::compatibility_iterator i
= GetChildren().GetFirst();
1147 wxRichTextParagraph
* para
= wxDynamicCast(i
->GetData(), wxRichTextParagraph
);
1148 wxASSERT( para
!= NULL
);
1150 if (!para
->GetRange().IsOutside(range
))
1152 fragment
.AppendChild(para
->Clone());
1157 // Now top and tail the first and last paragraphs in our new fragment (which might be the same).
1158 if (!fragment
.IsEmpty())
1160 wxRichTextRange
topTailRange(range
);
1162 wxRichTextParagraph
* firstPara
= wxDynamicCast(fragment
.GetChildren().GetFirst()->GetData(), wxRichTextParagraph
);
1163 wxASSERT( firstPara
!= NULL
);
1165 // Chop off the start of the paragraph
1166 if (topTailRange
.GetStart() > firstPara
->GetRange().GetStart())
1168 wxRichTextRange
r(firstPara
->GetRange().GetStart(), topTailRange
.GetStart()-1);
1169 firstPara
->DeleteRange(r
);
1171 // Make sure the numbering is correct
1173 fragment
.CalculateRange(firstPara
->GetRange().GetStart(), end
);
1175 // Now, we've deleted some positions, so adjust the range
1177 topTailRange
.SetEnd(topTailRange
.GetEnd() - r
.GetLength());
1180 wxRichTextParagraph
* lastPara
= wxDynamicCast(fragment
.GetChildren().GetLast()->GetData(), wxRichTextParagraph
);
1181 wxASSERT( lastPara
!= NULL
);
1183 if (topTailRange
.GetEnd() < (lastPara
->GetRange().GetEnd()-1))
1185 wxRichTextRange
r(topTailRange
.GetEnd()+1, lastPara
->GetRange().GetEnd()-1); /* -1 since actual text ends 1 position before end of para marker */
1186 lastPara
->DeleteRange(r
);
1188 // Make sure the numbering is correct
1190 fragment
.CalculateRange(firstPara
->GetRange().GetStart(), end
);
1192 // We only have part of a paragraph at the end
1193 fragment
.SetPartialParagraph(true);
1197 if (topTailRange
.GetEnd() == (lastPara
->GetRange().GetEnd() - 1))
1198 // We have a partial paragraph (don't save last new paragraph marker)
1199 fragment
.SetPartialParagraph(true);
1201 // We have a complete paragraph
1202 fragment
.SetPartialParagraph(false);
1209 /// Given a position, get the number of the visible line (potentially many to a paragraph),
1210 /// starting from zero at the start of the buffer.
1211 long wxRichTextParagraphLayoutBox::GetVisibleLineNumber(long pos
, bool caretPosition
, bool startOfLine
) const
1218 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
1221 wxRichTextParagraph
* child
= wxDynamicCast(node
->GetData(), wxRichTextParagraph
);
1222 wxASSERT( child
!= NULL
);
1224 if (child
->GetRange().Contains(pos
))
1226 wxRichTextLineList::compatibility_iterator node2
= child
->GetLines().GetFirst();
1229 wxRichTextLine
* line
= node2
->GetData();
1230 wxRichTextRange lineRange
= line
->GetAbsoluteRange();
1232 if (lineRange
.Contains(pos
))
1234 // If the caret is displayed at the end of the previous wrapped line,
1235 // we want to return the line it's _displayed_ at (not the actual line
1236 // containing the position).
1237 if (lineRange
.GetStart() == pos
&& !startOfLine
&& child
->GetRange().GetStart() != pos
)
1238 return lineCount
- 1;
1245 node2
= node2
->GetNext();
1247 // If we didn't find it in the lines, it must be
1248 // the last position of the paragraph. So return the last line.
1252 lineCount
+= child
->GetLines().GetCount();
1254 node
= node
->GetNext();
1261 /// Given a line number, get the corresponding wxRichTextLine object.
1262 wxRichTextLine
* wxRichTextParagraphLayoutBox::GetLineForVisibleLineNumber(long lineNumber
) const
1266 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
1269 wxRichTextParagraph
* child
= wxDynamicCast(node
->GetData(), wxRichTextParagraph
);
1270 wxASSERT(child
!= NULL
);
1272 if (lineNumber
< (int) (child
->GetLines().GetCount() + lineCount
))
1274 wxRichTextLineList::compatibility_iterator node2
= child
->GetLines().GetFirst();
1277 wxRichTextLine
* line
= node2
->GetData();
1279 if (lineCount
== lineNumber
)
1284 node2
= node2
->GetNext();
1288 lineCount
+= child
->GetLines().GetCount();
1290 node
= node
->GetNext();
1297 /// Delete range from layout.
1298 bool wxRichTextParagraphLayoutBox::DeleteRange(const wxRichTextRange
& range
)
1300 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
1304 wxRichTextParagraph
* obj
= wxDynamicCast(node
->GetData(), wxRichTextParagraph
);
1305 wxASSERT (obj
!= NULL
);
1307 wxRichTextObjectList::compatibility_iterator next
= node
->GetNext();
1309 // Delete the range in each paragraph
1311 if (!obj
->GetRange().IsOutside(range
))
1313 // Deletes the content of this object within the given range
1314 obj
->DeleteRange(range
);
1316 // If the whole paragraph is within the range to delete,
1317 // delete the whole thing.
1318 if (range
.GetStart() <= obj
->GetRange().GetStart() && range
.GetEnd() >= obj
->GetRange().GetEnd())
1320 // Delete the whole object
1321 RemoveChild(obj
, true);
1323 // If the range includes the paragraph end, we need to join this
1324 // and the next paragraph.
1325 else if (range
.Contains(obj
->GetRange().GetEnd()))
1327 // We need to move the objects from the next paragraph
1328 // to this paragraph
1332 wxRichTextParagraph
* nextParagraph
= wxDynamicCast(next
->GetData(), wxRichTextParagraph
);
1333 next
= next
->GetNext();
1336 // Delete the stuff we need to delete
1337 nextParagraph
->DeleteRange(range
);
1339 // Move the objects to the previous para
1340 wxRichTextObjectList::compatibility_iterator node1
= nextParagraph
->GetChildren().GetFirst();
1344 wxRichTextObject
* obj1
= node1
->GetData();
1346 // If the object is empty, optimise it out
1347 if (obj1
->IsEmpty())
1353 obj
->AppendChild(obj1
);
1356 wxRichTextObjectList::compatibility_iterator next1
= node1
->GetNext();
1357 nextParagraph
->GetChildren().Erase(node1
);
1362 // Delete the paragraph
1363 RemoveChild(nextParagraph
, true);
1377 /// Get any text in this object for the given range
1378 wxString
wxRichTextParagraphLayoutBox::GetTextForRange(const wxRichTextRange
& range
) const
1382 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
1385 wxRichTextObject
* child
= node
->GetData();
1386 if (!child
->GetRange().IsOutside(range
))
1390 wxRichTextRange childRange
= range
;
1391 childRange
.LimitTo(child
->GetRange());
1393 wxString childText
= child
->GetTextForRange(childRange
);
1399 node
= node
->GetNext();
1405 /// Get all the text
1406 wxString
wxRichTextParagraphLayoutBox::GetText() const
1408 return GetTextForRange(GetRange());
1411 /// Get the paragraph by number
1412 wxRichTextParagraph
* wxRichTextParagraphLayoutBox::GetParagraphAtLine(long paragraphNumber
) const
1414 if ((size_t) paragraphNumber
<= GetChildCount())
1417 return (wxRichTextParagraph
*) GetChild((size_t) paragraphNumber
);
1420 /// Get the length of the paragraph
1421 int wxRichTextParagraphLayoutBox::GetParagraphLength(long paragraphNumber
) const
1423 wxRichTextParagraph
* para
= GetParagraphAtLine(paragraphNumber
);
1425 return para
->GetRange().GetLength() - 1; // don't include newline
1430 /// Get the text of the paragraph
1431 wxString
wxRichTextParagraphLayoutBox::GetParagraphText(long paragraphNumber
) const
1433 wxRichTextParagraph
* para
= GetParagraphAtLine(paragraphNumber
);
1435 return para
->GetTextForRange(para
->GetRange());
1437 return wxEmptyString
;
1440 /// Convert zero-based line column and paragraph number to a position.
1441 long wxRichTextParagraphLayoutBox::XYToPosition(long x
, long y
) const
1443 wxRichTextParagraph
* para
= GetParagraphAtLine(y
);
1446 return para
->GetRange().GetStart() + x
;
1452 /// Convert zero-based position to line column and paragraph number
1453 bool wxRichTextParagraphLayoutBox::PositionToXY(long pos
, long* x
, long* y
) const
1455 wxRichTextParagraph
* para
= GetParagraphAtPosition(pos
);
1459 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
1462 wxRichTextObject
* child
= node
->GetData();
1466 node
= node
->GetNext();
1470 *x
= pos
- para
->GetRange().GetStart();
1478 /// Get the leaf object in a paragraph at this position.
1479 /// Given a line number, get the corresponding wxRichTextLine object.
1480 wxRichTextObject
* wxRichTextParagraphLayoutBox::GetLeafObjectAtPosition(long position
) const
1482 wxRichTextParagraph
* para
= GetParagraphAtPosition(position
);
1485 wxRichTextObjectList::compatibility_iterator node
= para
->GetChildren().GetFirst();
1489 wxRichTextObject
* child
= node
->GetData();
1490 if (child
->GetRange().Contains(position
))
1493 node
= node
->GetNext();
1495 if (position
== para
->GetRange().GetEnd() && para
->GetChildCount() > 0)
1496 return para
->GetChildren().GetLast()->GetData();
1501 /// Set character or paragraph text attributes: apply character styles only to immediate text nodes
1502 bool wxRichTextParagraphLayoutBox::SetStyle(const wxRichTextRange
& range
, const wxRichTextAttr
& style
, bool withUndo
)
1504 bool characterStyle
= false;
1505 bool paragraphStyle
= false;
1507 if (style
.IsCharacterStyle())
1508 characterStyle
= true;
1509 if (style
.IsParagraphStyle())
1510 paragraphStyle
= true;
1512 // If we are associated with a control, make undoable; otherwise, apply immediately
1515 bool haveControl
= (GetRichTextCtrl() != NULL
);
1517 wxRichTextAction
* action
= NULL
;
1519 if (haveControl
&& withUndo
)
1521 action
= new wxRichTextAction(NULL
, _("Change Style"), wxRICHTEXT_CHANGE_STYLE
, & GetRichTextCtrl()->GetBuffer(), GetRichTextCtrl());
1522 action
->SetRange(range
);
1523 action
->SetPosition(GetRichTextCtrl()->GetCaretPosition());
1526 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
1529 wxRichTextParagraph
* para
= wxDynamicCast(node
->GetData(), wxRichTextParagraph
);
1530 wxASSERT (para
!= NULL
);
1532 if (para
&& para
->GetChildCount() > 0)
1534 // Stop searching if we're beyond the range of interest
1535 if (para
->GetRange().GetStart() > range
.GetEnd())
1538 if (!para
->GetRange().IsOutside(range
))
1540 // We'll be using a copy of the paragraph to make style changes,
1541 // not updating the buffer directly.
1542 wxRichTextParagraph
* newPara
wxDUMMY_INITIALIZE(NULL
);
1544 if (haveControl
&& withUndo
)
1546 newPara
= new wxRichTextParagraph(*para
);
1547 action
->GetNewParagraphs().AppendChild(newPara
);
1549 // Also store the old ones for Undo
1550 action
->GetOldParagraphs().AppendChild(new wxRichTextParagraph(*para
));
1556 wxRichTextApplyStyle(newPara
->GetAttributes(), style
);
1558 if (characterStyle
&& range
.GetStart() != newPara
->GetRange().GetEnd())
1560 wxRichTextRange
childRange(range
);
1561 childRange
.LimitTo(newPara
->GetRange());
1563 // Find the starting position and if necessary split it so
1564 // we can start applying a different style.
1565 // TODO: check that the style actually changes or is different
1566 // from style outside of range
1567 wxRichTextObject
* firstObject
wxDUMMY_INITIALIZE(NULL
);
1568 wxRichTextObject
* lastObject
wxDUMMY_INITIALIZE(NULL
);
1570 if (childRange
.GetStart() == newPara
->GetRange().GetStart())
1571 firstObject
= newPara
->GetChildren().GetFirst()->GetData();
1573 firstObject
= newPara
->SplitAt(range
.GetStart());
1575 // Increment by 1 because we're apply the style one _after_ the split point
1576 long splitPoint
= childRange
.GetEnd();
1577 if (splitPoint
!= newPara
->GetRange().GetEnd())
1581 if (splitPoint
== newPara
->GetRange().GetEnd() || splitPoint
== (newPara
->GetRange().GetEnd() - 1))
1582 lastObject
= newPara
->GetChildren().GetLast()->GetData();
1584 // lastObject is set as a side-effect of splitting. It's
1585 // returned as the object before the new object.
1586 (void) newPara
->SplitAt(splitPoint
, & lastObject
);
1588 wxASSERT(firstObject
!= NULL
);
1589 wxASSERT(lastObject
!= NULL
);
1591 if (!firstObject
|| !lastObject
)
1594 wxRichTextObjectList::compatibility_iterator firstNode
= newPara
->GetChildren().Find(firstObject
);
1595 wxRichTextObjectList::compatibility_iterator lastNode
= newPara
->GetChildren().Find(lastObject
);
1597 wxASSERT(firstNode
);
1600 wxRichTextObjectList::compatibility_iterator node2
= firstNode
;
1604 wxRichTextObject
* child
= node2
->GetData();
1606 wxRichTextApplyStyle(child
->GetAttributes(), style
);
1607 if (node2
== lastNode
)
1610 node2
= node2
->GetNext();
1616 node
= node
->GetNext();
1619 // Do action, or delay it until end of batch.
1620 if (haveControl
&& withUndo
)
1621 GetRichTextCtrl()->GetBuffer().SubmitAction(action
);
1626 /// Set text attributes
1627 bool wxRichTextParagraphLayoutBox::SetStyle(const wxRichTextRange
& range
, const wxTextAttrEx
& style
, bool withUndo
)
1629 wxRichTextAttr richStyle
= style
;
1630 return SetStyle(range
, richStyle
, withUndo
);
1633 /// Get the text attributes for this position.
1634 bool wxRichTextParagraphLayoutBox::GetStyle(long position
, wxTextAttrEx
& style
) const
1636 wxRichTextObject
* obj
wxDUMMY_INITIALIZE(NULL
);
1638 if (style
.IsParagraphStyle())
1639 obj
= GetParagraphAtPosition(position
);
1641 obj
= GetLeafObjectAtPosition(position
);
1645 style
= obj
->GetAttributes();
1652 /// Get the text attributes for this position.
1653 bool wxRichTextParagraphLayoutBox::GetStyle(long position
, wxRichTextAttr
& style
) const
1655 wxRichTextObject
* obj
wxDUMMY_INITIALIZE(NULL
);
1657 if (style
.IsParagraphStyle())
1658 obj
= GetParagraphAtPosition(position
);
1660 obj
= GetLeafObjectAtPosition(position
);
1664 style
= obj
->GetAttributes();
1671 /// Set default style
1672 bool wxRichTextParagraphLayoutBox::SetDefaultStyle(const wxTextAttrEx
& style
)
1674 // keep the old attributes if the new style doesn't specify them unless the
1675 // new style is empty - then reset m_defaultStyle (as there is no other way
1677 if ( style
.IsDefault() )
1678 m_defaultAttributes
= style
;
1680 m_defaultAttributes
= wxTextAttrEx::CombineEx(style
, m_defaultAttributes
, NULL
);
1685 /// Test if this whole range has character attributes of the specified kind. If any
1686 /// of the attributes are different within the range, the test fails. You
1687 /// can use this to implement, for example, bold button updating. style must have
1688 /// flags indicating which attributes are of interest.
1689 bool wxRichTextParagraphLayoutBox::HasCharacterAttributes(const wxRichTextRange
& range
, const wxRichTextAttr
& style
) const
1692 int matchingCount
= 0;
1694 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
1697 wxRichTextParagraph
* para
= wxDynamicCast(node
->GetData(), wxRichTextParagraph
);
1698 wxASSERT (para
!= NULL
);
1702 // Stop searching if we're beyond the range of interest
1703 if (para
->GetRange().GetStart() > range
.GetEnd())
1704 return foundCount
== matchingCount
;
1706 if (!para
->GetRange().IsOutside(range
))
1708 wxRichTextObjectList::compatibility_iterator node2
= para
->GetChildren().GetFirst();
1712 wxRichTextObject
* child
= node2
->GetData();
1713 if (!child
->GetRange().IsOutside(range
) && child
->IsKindOf(CLASSINFO(wxRichTextPlainText
)))
1716 if (wxTextAttrEqPartial(child
->GetAttributes(), style
, style
.GetFlags()))
1720 node2
= node2
->GetNext();
1725 node
= node
->GetNext();
1728 return foundCount
== matchingCount
;
1731 bool wxRichTextParagraphLayoutBox::HasCharacterAttributes(const wxRichTextRange
& range
, const wxTextAttrEx
& style
) const
1733 wxRichTextAttr richStyle
= style
;
1734 return HasCharacterAttributes(range
, richStyle
);
1737 /// Test if this whole range has paragraph attributes of the specified kind. If any
1738 /// of the attributes are different within the range, the test fails. You
1739 /// can use this to implement, for example, centering button updating. style must have
1740 /// flags indicating which attributes are of interest.
1741 bool wxRichTextParagraphLayoutBox::HasParagraphAttributes(const wxRichTextRange
& range
, const wxRichTextAttr
& style
) const
1744 int matchingCount
= 0;
1746 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
1749 wxRichTextParagraph
* para
= wxDynamicCast(node
->GetData(), wxRichTextParagraph
);
1750 wxASSERT (para
!= NULL
);
1754 // Stop searching if we're beyond the range of interest
1755 if (para
->GetRange().GetStart() > range
.GetEnd())
1756 return foundCount
== matchingCount
;
1758 if (!para
->GetRange().IsOutside(range
))
1761 if (wxTextAttrEqPartial(para
->GetAttributes(), style
, style
.GetFlags()))
1766 node
= node
->GetNext();
1768 return foundCount
== matchingCount
;
1771 bool wxRichTextParagraphLayoutBox::HasParagraphAttributes(const wxRichTextRange
& range
, const wxTextAttrEx
& style
) const
1773 wxRichTextAttr richStyle
= style
;
1774 return HasParagraphAttributes(range
, richStyle
);
1777 void wxRichTextParagraphLayoutBox::Clear()
1782 void wxRichTextParagraphLayoutBox::Reset()
1786 AddParagraph(wxEmptyString
);
1789 /// Invalidate the buffer. With no argument, invalidates whole buffer.
1790 void wxRichTextParagraphLayoutBox::Invalidate(const wxRichTextRange
& invalidRange
)
1794 if (invalidRange
== wxRICHTEXT_ALL
)
1796 m_invalidRange
= wxRICHTEXT_ALL
;
1800 // Already invalidating everything
1801 if (m_invalidRange
== wxRICHTEXT_ALL
)
1804 if ((invalidRange
.GetStart() < m_invalidRange
.GetStart()) || m_invalidRange
.GetStart() == -1)
1805 m_invalidRange
.SetStart(invalidRange
.GetStart());
1806 if (invalidRange
.GetEnd() > m_invalidRange
.GetEnd())
1807 m_invalidRange
.SetEnd(invalidRange
.GetEnd());
1810 /// Get invalid range, rounding to entire paragraphs if argument is true.
1811 wxRichTextRange
wxRichTextParagraphLayoutBox::GetInvalidRange(bool wholeParagraphs
) const
1813 if (m_invalidRange
== wxRICHTEXT_ALL
|| m_invalidRange
== wxRICHTEXT_NONE
)
1814 return m_invalidRange
;
1816 wxRichTextRange range
= m_invalidRange
;
1818 if (wholeParagraphs
)
1820 wxRichTextParagraph
* para1
= GetParagraphAtPosition(range
.GetStart());
1821 wxRichTextParagraph
* para2
= GetParagraphAtPosition(range
.GetEnd());
1823 range
.SetStart(para1
->GetRange().GetStart());
1825 range
.SetEnd(para2
->GetRange().GetEnd());
1831 * wxRichTextFragment class declaration
1832 * This is a lind of paragraph layout box used for storing
1833 * paragraphs for Undo/Redo, for example.
1836 IMPLEMENT_DYNAMIC_CLASS(wxRichTextFragment
, wxRichTextParagraphLayoutBox
)
1839 void wxRichTextFragment::Init()
1841 m_partialParagraph
= false;
1845 void wxRichTextFragment::Copy(const wxRichTextFragment
& obj
)
1847 wxRichTextParagraphLayoutBox::Copy(obj
);
1849 m_partialParagraph
= obj
.m_partialParagraph
;
1853 * wxRichTextParagraph
1854 * This object represents a single paragraph (or in a straight text editor, a line).
1857 IMPLEMENT_DYNAMIC_CLASS(wxRichTextParagraph
, wxRichTextBox
)
1859 wxRichTextParagraph::wxRichTextParagraph(wxRichTextObject
* parent
, wxTextAttrEx
* style
):
1860 wxRichTextBox(parent
)
1862 if (parent
&& !style
)
1863 SetAttributes(parent
->GetAttributes());
1865 SetAttributes(*style
);
1868 wxRichTextParagraph::wxRichTextParagraph(const wxString
& text
, wxRichTextObject
* parent
, wxTextAttrEx
* style
):
1869 wxRichTextBox(parent
)
1871 if (parent
&& !style
)
1872 SetAttributes(parent
->GetAttributes());
1874 SetAttributes(*style
);
1876 AppendChild(new wxRichTextPlainText(text
, this));
1879 wxRichTextParagraph::~wxRichTextParagraph()
1885 bool wxRichTextParagraph::Draw(wxDC
& dc
, const wxRichTextRange
& WXUNUSED(range
), const wxRichTextRange
& selectionRange
, const wxRect
& WXUNUSED(rect
), int WXUNUSED(descent
), int style
)
1887 // Draw the bullet, if any
1888 if (GetAttributes().GetBulletStyle() != wxTEXT_ATTR_BULLET_STYLE_NONE
)
1890 if (GetAttributes().GetLeftSubIndent() != 0)
1892 int spaceBeforePara
= ConvertTenthsMMToPixels(dc
, GetAttributes().GetParagraphSpacingBefore());
1893 // int spaceAfterPara = ConvertTenthsMMToPixels(dc, GetAttributes().GetParagraphSpacingAfter());
1894 int leftIndent
= ConvertTenthsMMToPixels(dc
, GetAttributes().GetLeftIndent());
1895 // int leftSubIndent = ConvertTenthsMMToPixels(dc, GetAttributes().GetLeftSubIndent());
1896 // int rightIndent = ConvertTenthsMMToPixels(dc, GetAttributes().GetRightIndent());
1898 if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_BITMAP
)
1904 wxString bulletText
= GetBulletText();
1905 if (!bulletText
.empty())
1907 if (GetAttributes().GetFont().Ok())
1908 dc
.SetFont(GetAttributes().GetFont());
1910 if (GetAttributes().GetTextColour().Ok())
1911 dc
.SetTextForeground(GetAttributes().GetTextColour());
1913 dc
.SetBackgroundMode(wxTRANSPARENT
);
1915 // Get line height from first line, if any
1916 wxRichTextLine
* line
= m_cachedLines
.GetFirst() ? (wxRichTextLine
* ) m_cachedLines
.GetFirst()->GetData() : (wxRichTextLine
*) NULL
;
1919 int lineHeight
wxDUMMY_INITIALIZE(0);
1922 lineHeight
= line
->GetSize().y
;
1923 linePos
= line
->GetPosition() + GetPosition();
1927 lineHeight
= dc
.GetCharHeight();
1928 linePos
= GetPosition();
1929 linePos
.y
+= spaceBeforePara
;
1932 int charHeight
= dc
.GetCharHeight();
1934 int x
= GetPosition().x
+ leftIndent
;
1935 int y
= linePos
.y
+ (lineHeight
- charHeight
);
1937 dc
.DrawText(bulletText
, x
, y
);
1943 // Draw the range for each line, one object at a time.
1945 wxRichTextLineList::compatibility_iterator node
= m_cachedLines
.GetFirst();
1948 wxRichTextLine
* line
= node
->GetData();
1949 wxRichTextRange lineRange
= line
->GetAbsoluteRange();
1951 int maxDescent
= line
->GetDescent();
1953 // Lines are specified relative to the paragraph
1955 wxPoint linePosition
= line
->GetPosition() + GetPosition();
1956 wxPoint objectPosition
= linePosition
;
1958 // Loop through objects until we get to the one within range
1959 wxRichTextObjectList::compatibility_iterator node2
= m_children
.GetFirst();
1962 wxRichTextObject
* child
= node2
->GetData();
1963 if (!child
->GetRange().IsOutside(lineRange
))
1965 // Draw this part of the line at the correct position
1966 wxRichTextRange
objectRange(child
->GetRange());
1967 objectRange
.LimitTo(lineRange
);
1971 child
->GetRangeSize(objectRange
, objectSize
, descent
, dc
, wxRICHTEXT_UNFORMATTED
, objectPosition
);
1973 // Use the child object's width, but the whole line's height
1974 wxRect
childRect(objectPosition
, wxSize(objectSize
.x
, line
->GetSize().y
));
1975 child
->Draw(dc
, objectRange
, selectionRange
, childRect
, maxDescent
, style
);
1977 objectPosition
.x
+= objectSize
.x
;
1979 else if (child
->GetRange().GetStart() > lineRange
.GetEnd())
1980 // Can break out of inner loop now since we've passed this line's range
1983 node2
= node2
->GetNext();
1986 node
= node
->GetNext();
1992 /// Lay the item out
1993 bool wxRichTextParagraph::Layout(wxDC
& dc
, const wxRect
& rect
, int style
)
1997 // Increase the size of the paragraph due to spacing
1998 int spaceBeforePara
= ConvertTenthsMMToPixels(dc
, GetAttributes().GetParagraphSpacingBefore());
1999 int spaceAfterPara
= ConvertTenthsMMToPixels(dc
, GetAttributes().GetParagraphSpacingAfter());
2000 int leftIndent
= ConvertTenthsMMToPixels(dc
, GetAttributes().GetLeftIndent());
2001 int leftSubIndent
= ConvertTenthsMMToPixels(dc
, GetAttributes().GetLeftSubIndent());
2002 int rightIndent
= ConvertTenthsMMToPixels(dc
, GetAttributes().GetRightIndent());
2004 int lineSpacing
= 0;
2006 // Let's assume line spacing of 10 is normal, 15 is 1.5, 20 is 2, etc.
2007 if (GetAttributes().GetLineSpacing() > 10 && GetAttributes().GetFont().Ok())
2009 dc
.SetFont(GetAttributes().GetFont());
2010 lineSpacing
= (ConvertTenthsMMToPixels(dc
, dc
.GetCharHeight()) * GetAttributes().GetLineSpacing())/10;
2013 // Available space for text on each line differs.
2014 int availableTextSpaceFirstLine
= rect
.GetWidth() - leftIndent
- rightIndent
;
2016 // Bullets start the text at the same position as subsequent lines
2017 if (GetAttributes().GetBulletStyle() != wxTEXT_ATTR_BULLET_STYLE_NONE
)
2018 availableTextSpaceFirstLine
-= leftSubIndent
;
2020 int availableTextSpaceSubsequentLines
= rect
.GetWidth() - leftIndent
- rightIndent
- leftSubIndent
;
2022 // Start position for each line relative to the paragraph
2023 int startPositionFirstLine
= leftIndent
;
2024 int startPositionSubsequentLines
= leftIndent
+ leftSubIndent
;
2026 // If we have a bullet in this paragraph, the start position for the first line's text
2027 // is actually leftIndent + leftSubIndent.
2028 if (GetAttributes().GetBulletStyle() != wxTEXT_ATTR_BULLET_STYLE_NONE
)
2029 startPositionFirstLine
= startPositionSubsequentLines
;
2031 //bool restrictWidth = wxRichTextHasStyle(style, wxRICHTEXT_FIXED_WIDTH);
2032 //bool restrictHeight = wxRichTextHasStyle(style, wxRICHTEXT_FIXED_HEIGHT);
2034 long lastEndPos
= GetRange().GetStart()-1;
2035 long lastCompletedEndPos
= lastEndPos
;
2037 int currentWidth
= 0;
2038 SetPosition(rect
.GetPosition());
2040 wxPoint
currentPosition(0, spaceBeforePara
); // We will calculate lines relative to paragraph
2049 // We may need to go back to a previous child, in which case create the new line,
2050 // find the child corresponding to the start position of the string, and
2053 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
2056 wxRichTextObject
* child
= node
->GetData();
2058 // If this is e.g. a composite text box, it will need to be laid out itself.
2059 // But if just a text fragment or image, for example, this will
2060 // do nothing. NB: won't we need to set the position after layout?
2061 // since for example if position is dependent on vertical line size, we
2062 // can't tell the position until the size is determined. So possibly introduce
2063 // another layout phase.
2065 child
->Layout(dc
, rect
, style
);
2067 // Available width depends on whether we're on the first or subsequent lines
2068 int availableSpaceForText
= (lineCount
== 0 ? availableTextSpaceFirstLine
: availableTextSpaceSubsequentLines
);
2070 currentPosition
.x
= (lineCount
== 0 ? startPositionFirstLine
: startPositionSubsequentLines
);
2072 // We may only be looking at part of a child, if we searched back for wrapping
2073 // and found a suitable point some way into the child. So get the size for the fragment
2077 int childDescent
= 0;
2078 if (lastEndPos
== child
->GetRange().GetStart() - 1)
2080 childSize
= child
->GetCachedSize();
2081 childDescent
= child
->GetDescent();
2084 GetRangeSize(wxRichTextRange(lastEndPos
+1, child
->GetRange().GetEnd()), childSize
, childDescent
, dc
, wxRICHTEXT_UNFORMATTED
,rect
.GetPosition());
2086 if (childSize
.x
+ currentWidth
> availableSpaceForText
)
2088 long wrapPosition
= 0;
2090 // Find a place to wrap. This may walk back to previous children,
2091 // for example if a word spans several objects.
2092 if (!FindWrapPosition(wxRichTextRange(lastCompletedEndPos
+1, child
->GetRange().GetEnd()), dc
, availableSpaceForText
, wrapPosition
))
2094 // If the function failed, just cut it off at the end of this child.
2095 wrapPosition
= child
->GetRange().GetEnd();
2098 // FindWrapPosition can still return a value that will put us in an endless wrapping loop
2099 if (wrapPosition
<= lastCompletedEndPos
)
2100 wrapPosition
= wxMax(lastCompletedEndPos
+1,child
->GetRange().GetEnd());
2102 // wxLogDebug(wxT("Split at %ld"), wrapPosition);
2104 // Let's find the actual size of the current line now
2106 wxRichTextRange
actualRange(lastCompletedEndPos
+1, wrapPosition
);
2107 GetRangeSize(actualRange
, actualSize
, childDescent
, dc
, wxRICHTEXT_UNFORMATTED
);
2108 currentWidth
= actualSize
.x
;
2109 lineHeight
= wxMax(lineHeight
, actualSize
.y
);
2110 maxDescent
= wxMax(childDescent
, maxDescent
);
2113 wxRichTextLine
* line
= AllocateLine(lineCount
);
2115 // Set relative range so we won't have to change line ranges when paragraphs are moved
2116 line
->SetRange(wxRichTextRange(actualRange
.GetStart() - GetRange().GetStart(), actualRange
.GetEnd() - GetRange().GetStart()));
2117 line
->SetPosition(currentPosition
);
2118 line
->SetSize(wxSize(currentWidth
, lineHeight
));
2119 line
->SetDescent(maxDescent
);
2121 // Now move down a line. TODO: add margins, spacing
2122 currentPosition
.y
+= lineHeight
;
2123 currentPosition
.y
+= lineSpacing
;
2126 maxWidth
= wxMax(maxWidth
, currentWidth
);
2130 // TODO: account for zero-length objects, such as fields
2131 wxASSERT(wrapPosition
> lastCompletedEndPos
);
2133 lastEndPos
= wrapPosition
;
2134 lastCompletedEndPos
= lastEndPos
;
2138 // May need to set the node back to a previous one, due to searching back in wrapping
2139 wxRichTextObject
* childAfterWrapPosition
= FindObjectAtPosition(wrapPosition
+1);
2140 if (childAfterWrapPosition
)
2141 node
= m_children
.Find(childAfterWrapPosition
);
2143 node
= node
->GetNext();
2147 // We still fit, so don't add a line, and keep going
2148 currentWidth
+= childSize
.x
;
2149 lineHeight
= wxMax(lineHeight
, childSize
.y
);
2150 maxDescent
= wxMax(childDescent
, maxDescent
);
2152 maxWidth
= wxMax(maxWidth
, currentWidth
);
2153 lastEndPos
= child
->GetRange().GetEnd();
2155 node
= node
->GetNext();
2159 // Add the last line - it's the current pos -> last para pos
2160 // Substract -1 because the last position is always the end-paragraph position.
2161 if (lastCompletedEndPos
<= GetRange().GetEnd()-1)
2163 currentPosition
.x
= (lineCount
== 0 ? startPositionFirstLine
: startPositionSubsequentLines
);
2165 wxRichTextLine
* line
= AllocateLine(lineCount
);
2167 wxRichTextRange
actualRange(lastCompletedEndPos
+1, GetRange().GetEnd()-1);
2169 // Set relative range so we won't have to change line ranges when paragraphs are moved
2170 line
->SetRange(wxRichTextRange(actualRange
.GetStart() - GetRange().GetStart(), actualRange
.GetEnd() - GetRange().GetStart()));
2172 line
->SetPosition(currentPosition
);
2174 if (lineHeight
== 0)
2176 if (GetAttributes().GetFont().Ok())
2177 dc
.SetFont(GetAttributes().GetFont());
2178 lineHeight
= dc
.GetCharHeight();
2180 if (maxDescent
== 0)
2183 dc
.GetTextExtent(wxT("X"), & w
, &h
, & maxDescent
);
2186 line
->SetSize(wxSize(currentWidth
, lineHeight
));
2187 line
->SetDescent(maxDescent
);
2188 currentPosition
.y
+= lineHeight
;
2189 currentPosition
.y
+= lineSpacing
;
2193 // Remove remaining unused line objects, if any
2194 ClearUnusedLines(lineCount
);
2196 // Apply styles to wrapped lines
2197 ApplyParagraphStyle(rect
);
2199 SetCachedSize(wxSize(maxWidth
, currentPosition
.y
+ spaceBeforePara
+ spaceAfterPara
));
2206 /// Apply paragraph styles, such as centering, to wrapped lines
2207 void wxRichTextParagraph::ApplyParagraphStyle(const wxRect
& rect
)
2209 if (!GetAttributes().HasAlignment())
2212 wxRichTextLineList::compatibility_iterator node
= m_cachedLines
.GetFirst();
2215 wxRichTextLine
* line
= node
->GetData();
2217 wxPoint pos
= line
->GetPosition();
2218 wxSize size
= line
->GetSize();
2220 // centering, right-justification
2221 if (GetAttributes().HasAlignment() && GetAttributes().GetAlignment() == wxTEXT_ALIGNMENT_CENTRE
)
2223 pos
.x
= (rect
.GetWidth() - size
.x
)/2 + pos
.x
;
2224 line
->SetPosition(pos
);
2226 else if (GetAttributes().HasAlignment() && GetAttributes().GetAlignment() == wxTEXT_ALIGNMENT_RIGHT
)
2228 pos
.x
= rect
.GetRight() - size
.x
;
2229 line
->SetPosition(pos
);
2232 node
= node
->GetNext();
2236 /// Insert text at the given position
2237 bool wxRichTextParagraph::InsertText(long pos
, const wxString
& text
)
2239 wxRichTextObject
* childToUse
= NULL
;
2240 wxRichTextObjectList::compatibility_iterator nodeToUse
= wxRichTextObjectList::compatibility_iterator();
2242 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
2245 wxRichTextObject
* child
= node
->GetData();
2246 if (child
->GetRange().Contains(pos
) && child
->GetRange().GetLength() > 0)
2253 node
= node
->GetNext();
2258 wxRichTextPlainText
* textObject
= wxDynamicCast(childToUse
, wxRichTextPlainText
);
2261 int posInString
= pos
- textObject
->GetRange().GetStart();
2263 wxString newText
= textObject
->GetText().Mid(0, posInString
) +
2264 text
+ textObject
->GetText().Mid(posInString
);
2265 textObject
->SetText(newText
);
2267 int textLength
= text
.Length();
2269 textObject
->SetRange(wxRichTextRange(textObject
->GetRange().GetStart(),
2270 textObject
->GetRange().GetEnd() + textLength
));
2272 // Increment the end range of subsequent fragments in this paragraph.
2273 // We'll set the paragraph range itself at a higher level.
2275 wxRichTextObjectList::compatibility_iterator node
= nodeToUse
->GetNext();
2278 wxRichTextObject
* child
= node
->GetData();
2279 child
->SetRange(wxRichTextRange(textObject
->GetRange().GetStart() + textLength
,
2280 textObject
->GetRange().GetEnd() + textLength
));
2282 node
= node
->GetNext();
2289 // TODO: if not a text object, insert at closest position, e.g. in front of it
2295 // Don't pass parent initially to suppress auto-setting of parent range.
2296 // We'll do that at a higher level.
2297 wxRichTextPlainText
* textObject
= new wxRichTextPlainText(text
, this);
2299 AppendChild(textObject
);
2306 void wxRichTextParagraph::Copy(const wxRichTextParagraph
& obj
)
2308 wxRichTextBox::Copy(obj
);
2311 /// Clear the cached lines
2312 void wxRichTextParagraph::ClearLines()
2314 WX_CLEAR_LIST(wxRichTextLineList
, m_cachedLines
);
2317 /// Get/set the object size for the given range. Returns false if the range
2318 /// is invalid for this object.
2319 bool wxRichTextParagraph::GetRangeSize(const wxRichTextRange
& range
, wxSize
& size
, int& descent
, wxDC
& dc
, int flags
, wxPoint position
) const
2321 if (!range
.IsWithin(GetRange()))
2324 if (flags
& wxRICHTEXT_UNFORMATTED
)
2326 // Just use unformatted data, assume no line breaks
2327 // TODO: take into account line breaks
2331 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
2334 wxRichTextObject
* child
= node
->GetData();
2335 if (!child
->GetRange().IsOutside(range
))
2339 wxRichTextRange rangeToUse
= range
;
2340 rangeToUse
.LimitTo(child
->GetRange());
2341 int childDescent
= 0;
2343 if (child
->GetRangeSize(rangeToUse
, childSize
, childDescent
, dc
, flags
, position
))
2345 sz
.y
= wxMax(sz
.y
, childSize
.y
);
2346 sz
.x
+= childSize
.x
;
2347 descent
= wxMax(descent
, childDescent
);
2351 node
= node
->GetNext();
2357 // Use formatted data, with line breaks
2360 // We're going to loop through each line, and then for each line,
2361 // call GetRangeSize for the fragment that comprises that line.
2362 // Only we have to do that multiple times within the line, because
2363 // the line may be broken into pieces. For now ignore line break commands
2364 // (so we can assume that getting the unformatted size for a fragment
2365 // within a line is the actual size)
2367 wxRichTextLineList::compatibility_iterator node
= m_cachedLines
.GetFirst();
2370 wxRichTextLine
* line
= node
->GetData();
2371 wxRichTextRange lineRange
= line
->GetAbsoluteRange();
2372 if (!lineRange
.IsOutside(range
))
2376 wxRichTextObjectList::compatibility_iterator node2
= m_children
.GetFirst();
2379 wxRichTextObject
* child
= node2
->GetData();
2381 if (!child
->GetRange().IsOutside(lineRange
))
2383 wxRichTextRange rangeToUse
= lineRange
;
2384 rangeToUse
.LimitTo(child
->GetRange());
2387 int childDescent
= 0;
2388 if (child
->GetRangeSize(rangeToUse
, childSize
, childDescent
, dc
, flags
, position
))
2390 lineSize
.y
= wxMax(lineSize
.y
, childSize
.y
);
2391 lineSize
.x
+= childSize
.x
;
2393 descent
= wxMax(descent
, childDescent
);
2396 node2
= node2
->GetNext();
2399 // Increase size by a line (TODO: paragraph spacing)
2401 sz
.x
= wxMax(sz
.x
, lineSize
.x
);
2403 node
= node
->GetNext();
2410 /// Finds the absolute position and row height for the given character position
2411 bool wxRichTextParagraph::FindPosition(wxDC
& dc
, long index
, wxPoint
& pt
, int* height
, bool forceLineStart
)
2415 wxRichTextLine
* line
= ((wxRichTextParagraphLayoutBox
*)GetParent())->GetLineAtPosition(0);
2417 *height
= line
->GetSize().y
;
2419 *height
= dc
.GetCharHeight();
2421 // -1 means 'the start of the buffer'.
2424 pt
= pt
+ line
->GetPosition();
2426 *height
= dc
.GetCharHeight();
2431 // The final position in a paragraph is taken to mean the position
2432 // at the start of the next paragraph.
2433 if (index
== GetRange().GetEnd())
2435 wxRichTextParagraphLayoutBox
* parent
= wxDynamicCast(GetParent(), wxRichTextParagraphLayoutBox
);
2436 wxASSERT( parent
!= NULL
);
2438 // Find the height at the next paragraph, if any
2439 wxRichTextLine
* line
= parent
->GetLineAtPosition(index
+ 1);
2442 *height
= line
->GetSize().y
;
2443 pt
= line
->GetAbsolutePosition();
2447 *height
= dc
.GetCharHeight();
2448 int indent
= ConvertTenthsMMToPixels(dc
, m_attributes
.GetLeftIndent());
2449 pt
= wxPoint(indent
, GetCachedSize().y
);
2455 if (index
< GetRange().GetStart() || index
> GetRange().GetEnd())
2458 wxRichTextLineList::compatibility_iterator node
= m_cachedLines
.GetFirst();
2461 wxRichTextLine
* line
= node
->GetData();
2462 wxRichTextRange lineRange
= line
->GetAbsoluteRange();
2463 if (index
>= lineRange
.GetStart() && index
<= lineRange
.GetEnd())
2465 // If this is the last point in the line, and we're forcing the
2466 // returned value to be the start of the next line, do the required
2468 if (index
== lineRange
.GetEnd() && forceLineStart
)
2470 if (node
->GetNext())
2472 wxRichTextLine
* nextLine
= node
->GetNext()->GetData();
2473 *height
= nextLine
->GetSize().y
;
2474 pt
= nextLine
->GetAbsolutePosition();
2479 pt
.y
= line
->GetPosition().y
+ GetPosition().y
;
2481 wxRichTextRange
r(lineRange
.GetStart(), index
);
2485 // We find the size of the line up to this point,
2486 // then we can add this size to the line start position and
2487 // paragraph start position to find the actual position.
2489 if (GetRangeSize(r
, rangeSize
, descent
, dc
, wxRICHTEXT_UNFORMATTED
, line
->GetPosition()+ GetPosition()))
2491 pt
.x
= line
->GetPosition().x
+ GetPosition().x
+ rangeSize
.x
;
2492 *height
= line
->GetSize().y
;
2499 node
= node
->GetNext();
2505 /// Hit-testing: returns a flag indicating hit test details, plus
2506 /// information about position
2507 int wxRichTextParagraph::HitTest(wxDC
& dc
, const wxPoint
& pt
, long& textPosition
)
2509 wxPoint paraPos
= GetPosition();
2511 wxRichTextLineList::compatibility_iterator node
= m_cachedLines
.GetFirst();
2514 wxRichTextLine
* line
= node
->GetData();
2515 wxPoint linePos
= paraPos
+ line
->GetPosition();
2516 wxSize lineSize
= line
->GetSize();
2517 wxRichTextRange lineRange
= line
->GetAbsoluteRange();
2519 if (pt
.y
>= linePos
.y
&& pt
.y
<= linePos
.y
+ lineSize
.y
)
2521 if (pt
.x
< linePos
.x
)
2523 textPosition
= lineRange
.GetStart();
2524 return wxRICHTEXT_HITTEST_BEFORE
;
2526 else if (pt
.x
>= (linePos
.x
+ lineSize
.x
))
2528 textPosition
= lineRange
.GetEnd();
2529 return wxRICHTEXT_HITTEST_AFTER
;
2534 int lastX
= linePos
.x
;
2535 for (i
= lineRange
.GetStart(); i
<= lineRange
.GetEnd(); i
++)
2540 wxRichTextRange
rangeToUse(lineRange
.GetStart(), i
);
2542 GetRangeSize(rangeToUse
, childSize
, descent
, dc
, wxRICHTEXT_UNFORMATTED
, linePos
);
2544 int nextX
= childSize
.x
+ linePos
.x
;
2546 if (pt
.x
>= lastX
&& pt
.x
<= nextX
)
2550 // So now we know it's between i-1 and i.
2551 // Let's see if we can be more precise about
2552 // which side of the position it's on.
2554 int midPoint
= (nextX
- lastX
)/2 + lastX
;
2555 if (pt
.x
>= midPoint
)
2556 return wxRICHTEXT_HITTEST_AFTER
;
2558 return wxRICHTEXT_HITTEST_BEFORE
;
2568 node
= node
->GetNext();
2571 return wxRICHTEXT_HITTEST_NONE
;
2574 /// Split an object at this position if necessary, and return
2575 /// the previous object, or NULL if inserting at beginning.
2576 wxRichTextObject
* wxRichTextParagraph::SplitAt(long pos
, wxRichTextObject
** previousObject
)
2578 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
2581 wxRichTextObject
* child
= node
->GetData();
2583 if (pos
== child
->GetRange().GetStart())
2587 if (node
->GetPrevious())
2588 *previousObject
= node
->GetPrevious()->GetData();
2590 *previousObject
= NULL
;
2596 if (child
->GetRange().Contains(pos
))
2598 // This should create a new object, transferring part of
2599 // the content to the old object and the rest to the new object.
2600 wxRichTextObject
* newObject
= child
->DoSplit(pos
);
2602 // If we couldn't split this object, just insert in front of it.
2605 // Maybe this is an empty string, try the next one
2610 // Insert the new object after 'child'
2611 if (node
->GetNext())
2612 m_children
.Insert(node
->GetNext(), newObject
);
2614 m_children
.Append(newObject
);
2615 newObject
->SetParent(this);
2618 *previousObject
= child
;
2624 node
= node
->GetNext();
2627 *previousObject
= NULL
;
2631 /// Move content to a list from obj on
2632 void wxRichTextParagraph::MoveToList(wxRichTextObject
* obj
, wxList
& list
)
2634 wxRichTextObjectList::compatibility_iterator node
= m_children
.Find(obj
);
2637 wxRichTextObject
* child
= node
->GetData();
2640 wxRichTextObjectList::compatibility_iterator oldNode
= node
;
2642 node
= node
->GetNext();
2644 m_children
.DeleteNode(oldNode
);
2648 /// Add content back from list
2649 void wxRichTextParagraph::MoveFromList(wxList
& list
)
2651 for (wxList::compatibility_iterator node
= list
.GetFirst(); node
; node
= node
->GetNext())
2653 AppendChild((wxRichTextObject
*) node
->GetData());
2658 void wxRichTextParagraph::CalculateRange(long start
, long& end
)
2660 wxRichTextCompositeObject::CalculateRange(start
, end
);
2662 // Add one for end of paragraph
2665 m_range
.SetRange(start
, end
);
2668 /// Find the object at the given position
2669 wxRichTextObject
* wxRichTextParagraph::FindObjectAtPosition(long position
)
2671 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
2674 wxRichTextObject
* obj
= node
->GetData();
2675 if (obj
->GetRange().Contains(position
))
2678 node
= node
->GetNext();
2683 /// Get the plain text searching from the start or end of the range.
2684 /// The resulting string may be shorter than the range given.
2685 bool wxRichTextParagraph::GetContiguousPlainText(wxString
& text
, const wxRichTextRange
& range
, bool fromStart
)
2687 text
= wxEmptyString
;
2691 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetFirst();
2694 wxRichTextObject
* obj
= node
->GetData();
2695 if (!obj
->GetRange().IsOutside(range
))
2697 wxRichTextPlainText
* textObj
= wxDynamicCast(obj
, wxRichTextPlainText
);
2700 text
+= textObj
->GetTextForRange(range
);
2706 node
= node
->GetNext();
2711 wxRichTextObjectList::compatibility_iterator node
= m_children
.GetLast();
2714 wxRichTextObject
* obj
= node
->GetData();
2715 if (!obj
->GetRange().IsOutside(range
))
2717 wxRichTextPlainText
* textObj
= wxDynamicCast(obj
, wxRichTextPlainText
);
2720 text
= textObj
->GetTextForRange(range
) + text
;
2726 node
= node
->GetPrevious();
2733 /// Find a suitable wrap position.
2734 bool wxRichTextParagraph::FindWrapPosition(const wxRichTextRange
& range
, wxDC
& dc
, int availableSpace
, long& wrapPosition
)
2736 // Find the first position where the line exceeds the available space.
2739 long breakPosition
= range
.GetEnd();
2740 for (i
= range
.GetStart(); i
<= range
.GetEnd(); i
++)
2743 GetRangeSize(wxRichTextRange(range
.GetStart(), i
), sz
, descent
, dc
, wxRICHTEXT_UNFORMATTED
);
2745 if (sz
.x
> availableSpace
)
2747 breakPosition
= i
-1;
2752 // Now we know the last position on the line.
2753 // Let's try to find a word break.
2756 if (GetContiguousPlainText(plainText
, wxRichTextRange(range
.GetStart(), breakPosition
), false))
2758 int spacePos
= plainText
.Find(wxT(' '), true);
2759 if (spacePos
!= wxNOT_FOUND
)
2761 int positionsFromEndOfString
= plainText
.Length() - spacePos
- 1;
2762 breakPosition
= breakPosition
- positionsFromEndOfString
;
2766 wrapPosition
= breakPosition
;
2771 /// Get the bullet text for this paragraph.
2772 wxString
wxRichTextParagraph::GetBulletText()
2774 if (GetAttributes().GetBulletStyle() == wxTEXT_ATTR_BULLET_STYLE_NONE
||
2775 (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_BITMAP
))
2776 return wxEmptyString
;
2778 int number
= GetAttributes().GetBulletNumber();
2781 if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ARABIC
)
2783 text
.Printf(wxT("%d"), number
);
2785 else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_LETTERS_UPPER
)
2787 // TODO: Unicode, and also check if number > 26
2788 text
.Printf(wxT("%c"), (wxChar
) (number
+64));
2790 else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_LETTERS_LOWER
)
2792 // TODO: Unicode, and also check if number > 26
2793 text
.Printf(wxT("%c"), (wxChar
) (number
+96));
2795 else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ROMAN_UPPER
)
2797 // TODO: convert from number to roman numeral
2800 else if (number
== 2)
2802 else if (number
== 3)
2804 else if (number
== 4)
2809 else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_ROMAN_LOWER
)
2811 // TODO: convert from number to roman numeral
2814 else if (number
== 2)
2816 else if (number
== 3)
2818 else if (number
== 4)
2823 else if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_SYMBOL
)
2825 text
= GetAttributes().GetBulletSymbol();
2828 if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_PARENTHESES
)
2830 text
= wxT("(") + text
+ wxT(")");
2832 if (GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_PERIOD
)
2840 /// Allocate or reuse a line object
2841 wxRichTextLine
* wxRichTextParagraph::AllocateLine(int pos
)
2843 if (pos
< (int) m_cachedLines
.GetCount())
2845 wxRichTextLine
* line
= m_cachedLines
.Item(pos
)->GetData();
2851 wxRichTextLine
* line
= new wxRichTextLine(this);
2852 m_cachedLines
.Append(line
);
2857 /// Clear remaining unused line objects, if any
2858 bool wxRichTextParagraph::ClearUnusedLines(int lineCount
)
2860 int cachedLineCount
= m_cachedLines
.GetCount();
2861 if ((int) cachedLineCount
> lineCount
)
2863 for (int i
= 0; i
< (int) (cachedLineCount
- lineCount
); i
++)
2865 wxRichTextLineList::compatibility_iterator node
= m_cachedLines
.GetLast();
2866 wxRichTextLine
* line
= node
->GetData();
2867 m_cachedLines
.Erase(node
);
2877 * This object represents a line in a paragraph, and stores
2878 * offsets from the start of the paragraph representing the
2879 * start and end positions of the line.
2882 wxRichTextLine::wxRichTextLine(wxRichTextParagraph
* parent
)
2888 void wxRichTextLine::Init(wxRichTextParagraph
* parent
)
2891 m_range
.SetRange(-1, -1);
2892 m_pos
= wxPoint(0, 0);
2893 m_size
= wxSize(0, 0);
2898 void wxRichTextLine::Copy(const wxRichTextLine
& obj
)
2900 m_range
= obj
.m_range
;
2903 /// Get the absolute object position
2904 wxPoint
wxRichTextLine::GetAbsolutePosition() const
2906 return m_parent
->GetPosition() + m_pos
;
2909 /// Get the absolute range
2910 wxRichTextRange
wxRichTextLine::GetAbsoluteRange() const
2912 wxRichTextRange
range(m_range
.GetStart() + m_parent
->GetRange().GetStart(), 0);
2913 range
.SetEnd(range
.GetStart() + m_range
.GetLength()-1);
2918 * wxRichTextPlainText
2919 * This object represents a single piece of text.
2922 IMPLEMENT_DYNAMIC_CLASS(wxRichTextPlainText
, wxRichTextObject
)
2924 wxRichTextPlainText::wxRichTextPlainText(const wxString
& text
, wxRichTextObject
* parent
, wxTextAttrEx
* style
):
2925 wxRichTextObject(parent
)
2927 if (parent
&& !style
)
2928 SetAttributes(parent
->GetAttributes());
2930 SetAttributes(*style
);
2936 bool wxRichTextPlainText::Draw(wxDC
& dc
, const wxRichTextRange
& range
, const wxRichTextRange
& selectionRange
, const wxRect
& rect
, int descent
, int WXUNUSED(style
))
2938 int offset
= GetRange().GetStart();
2940 long len
= range
.GetLength();
2941 wxString stringChunk
= m_text
.Mid(range
.GetStart() - offset
, (size_t) len
);
2943 int charHeight
= dc
.GetCharHeight();
2946 int y
= rect
.y
+ (rect
.height
- charHeight
- (descent
- m_descent
));
2948 // Test for the optimized situations where all is selected, or none
2951 if (GetAttributes().GetFont().Ok())
2952 dc
.SetFont(GetAttributes().GetFont());
2954 // (a) All selected.
2955 if (selectionRange
.GetStart() <= range
.GetStart() && selectionRange
.GetEnd() >= range
.GetEnd())
2957 // Draw all selected
2958 dc.SetBrush(*wxBLACK_BRUSH);
2959 dc.SetPen(*wxBLACK_PEN);
2961 dc.GetTextExtent(stringChunk, & w, & h);
2962 wxRect selRect(x, rect.y, w, rect.GetHeight());
2963 dc.DrawRectangle(selRect);
2964 dc.SetTextForeground(*wxWHITE);
2965 dc.SetBackgroundMode(wxTRANSPARENT);
2966 dc.DrawText(stringChunk, x, y);*/
2967 DrawTabbedString(dc
, rect
,stringChunk
, x
, y
, true);
2969 // (b) None selected.
2970 else if (selectionRange
.GetEnd() < range
.GetStart() || selectionRange
.GetStart() > range
.GetEnd())
2972 // Draw all unselected
2974 dc.SetTextForeground(GetAttributes().GetTextColour());
2975 dc.SetBackgroundMode(wxTRANSPARENT);
2976 dc.DrawText(stringChunk, x, y);*/
2977 DrawTabbedString(dc
, rect
,stringChunk
, x
, y
, false);
2981 // (c) Part selected, part not
2982 // Let's draw unselected chunk, selected chunk, then unselected chunk.
2984 dc
.SetBackgroundMode(wxTRANSPARENT
);
2986 // 1. Initial unselected chunk, if any, up until start of selection.
2987 if (selectionRange
.GetStart() > range
.GetStart() && selectionRange
.GetStart() <= range
.GetEnd())
2989 int r1
= range
.GetStart();
2990 int s1
= selectionRange
.GetStart()-1;
2991 int fragmentLen
= s1
- r1
+ 1;
2992 if (fragmentLen
< 0)
2993 wxLogDebug(wxT("Mid(%d, %d"), (int)(r1
- offset
), (int)fragmentLen
);
2994 wxString stringFragment
= m_text
.Mid(r1
- offset
, fragmentLen
);
2996 dc.SetTextForeground(GetAttributes().GetTextColour());
2997 dc.DrawText(stringFragment, x, y);
3000 dc.GetTextExtent(stringFragment, & w, & h);
3002 DrawTabbedString(dc
, rect
,stringFragment
, x
, y
, false);
3005 // 2. Selected chunk, if any.
3006 if (selectionRange
.GetEnd() >= range
.GetStart())
3008 int s1
= wxMax(selectionRange
.GetStart(), range
.GetStart());
3009 int s2
= wxMin(selectionRange
.GetEnd(), range
.GetEnd());
3011 int fragmentLen
= s2
- s1
+ 1;
3012 if (fragmentLen
< 0)
3013 wxLogDebug(wxT("Mid(%d, %d"), (int)(s1
- offset
), (int)fragmentLen
);
3014 wxString stringFragment
= m_text
.Mid(s1
- offset
, fragmentLen
);
3017 dc.GetTextExtent(stringFragment, & w, & h);
3018 wxRect selRect(x, rect.y, w, rect.GetHeight());
3020 dc.SetBrush(*wxBLACK_BRUSH);
3021 dc.SetPen(*wxBLACK_PEN);
3022 dc.DrawRectangle(selRect);
3023 dc.SetTextForeground(*wxWHITE);
3024 dc.DrawText(stringFragment, x, y);
3027 DrawTabbedString(dc
, rect
,stringFragment
, x
, y
, true);
3030 // 3. Remaining unselected chunk, if any
3031 if (selectionRange
.GetEnd() < range
.GetEnd())
3033 int s2
= wxMin(selectionRange
.GetEnd()+1, range
.GetEnd());
3034 int r2
= range
.GetEnd();
3036 int fragmentLen
= r2
- s2
+ 1;
3037 if (fragmentLen
< 0)
3038 wxLogDebug(wxT("Mid(%d, %d"), (int)(s2
- offset
), (int)fragmentLen
);
3039 wxString stringFragment
= m_text
.Mid(s2
- offset
, fragmentLen
);
3041 dc.SetTextForeground(GetAttributes().GetTextColour());
3042 dc.DrawText(stringFragment, x, y);*/
3043 DrawTabbedString(dc
, rect
,stringFragment
, x
, y
, false);
3050 bool wxRichTextPlainText::DrawTabbedString(wxDC
& dc
,const wxRect
& rect
,wxString
& str
, wxCoord
& x
, wxCoord
& y
, bool selected
)
3052 wxArrayInt tab_array
= GetAttributes().GetTabs();
3053 if(tab_array
.IsEmpty()){// create a default tab list at 10 mm each.
3054 for( int i
= 0; i
< 20; ++i
){
3055 tab_array
.Add(i
*100);
3058 int map_mode
= dc
.GetMapMode();
3059 dc
.SetMapMode(wxMM_LOMETRIC
);
3060 int num_tabs
= tab_array
.GetCount();
3061 for( int i
= 0; i
< num_tabs
; ++i
){
3062 tab_array
[i
] = dc
.LogicalToDeviceXRel(tab_array
[i
]);
3064 dc
.SetMapMode(map_mode
);
3065 int next_tab_pos
= -1;
3069 dc
.SetBrush(*wxBLACK_BRUSH
);
3070 dc
.SetPen(*wxBLACK_PEN
);
3071 dc
.SetTextForeground(*wxWHITE
);
3072 dc
.SetBackgroundMode(wxTRANSPARENT
);
3075 dc
.SetTextForeground(GetAttributes().GetTextColour());
3076 dc
.SetBackgroundMode(wxTRANSPARENT
);
3078 while(str
.Find(wxT('\t')) >= 0){// the string has a tab
3079 // break up the string at the Tab
3080 wxString stringChunk
= str
.BeforeFirst(wxT('\t'));
3081 str
= str
.AfterFirst(wxT('\t'));
3082 dc
.GetTextExtent(stringChunk
, & w
, & h
);
3084 bool not_found
= true;
3085 for( int i
= 0; i
< num_tabs
&& not_found
; ++i
){
3086 next_tab_pos
= tab_array
.Item(i
);
3087 if( next_tab_pos
> tab_pos
){
3090 w
= next_tab_pos
- x
;
3091 wxRect
selRect(x
, rect
.y
, w
, rect
.GetHeight());
3092 dc
.DrawRectangle(selRect
);
3094 dc
.DrawText(stringChunk
, x
, y
);
3100 dc
.GetTextExtent(str
, & w
, & h
);
3102 wxRect
selRect(x
, rect
.y
, w
, rect
.GetHeight());
3103 dc
.DrawRectangle(selRect
);
3105 dc
.DrawText(str
, x
, y
);
3110 /// Lay the item out
3111 bool wxRichTextPlainText::Layout(wxDC
& dc
, const wxRect
& WXUNUSED(rect
), int WXUNUSED(style
))
3113 if (GetAttributes().GetFont().Ok())
3114 dc
.SetFont(GetAttributes().GetFont());
3117 dc
.GetTextExtent(m_text
, & w
, & h
, & m_descent
);
3118 m_size
= wxSize(w
, dc
.GetCharHeight());
3124 void wxRichTextPlainText::Copy(const wxRichTextPlainText
& obj
)
3126 wxRichTextObject::Copy(obj
);
3128 m_text
= obj
.m_text
;
3131 /// Get/set the object size for the given range. Returns false if the range
3132 /// is invalid for this object.
3133 bool wxRichTextPlainText::GetRangeSize(const wxRichTextRange
& range
, wxSize
& size
, int& descent
, wxDC
& dc
, int WXUNUSED(flags
), wxPoint position
) const
3135 if (!range
.IsWithin(GetRange()))
3138 // Always assume unformatted text, since at this level we have no knowledge
3139 // of line breaks - and we don't need it, since we'll calculate size within
3140 // formatted text by doing it in chunks according to the line ranges
3142 if (GetAttributes().GetFont().Ok())
3143 dc
.SetFont(GetAttributes().GetFont());
3145 int startPos
= range
.GetStart() - GetRange().GetStart();
3146 long len
= range
.GetLength();
3147 wxString stringChunk
= m_text
.Mid(startPos
, (size_t) len
);
3150 if(stringChunk
.Find(wxT('\t')) >= 0){// the string has a tab
3151 wxArrayInt tab_array
= GetAttributes().GetTabs();
3152 if(tab_array
.IsEmpty()){// create a default tab list at 10 mm each.
3153 for( int i
= 0; i
< 20; ++i
){
3154 tab_array
.Add(i
*100);
3157 int map_mode
= dc
.GetMapMode();
3158 dc
.SetMapMode(wxMM_LOMETRIC
);
3159 int num_tabs
= tab_array
.GetCount();
3160 for( int i
= 0; i
< num_tabs
; ++i
){
3161 tab_array
[i
] = dc
.LogicalToDeviceXRel(tab_array
[i
]);
3163 dc
.SetMapMode(map_mode
);
3164 int next_tab_pos
= -1;
3166 while(stringChunk
.Find(wxT('\t')) >= 0){// the string has a tab
3167 // break up the string at the Tab
3168 wxString stringFragment
= stringChunk
.BeforeFirst(wxT('\t'));
3169 stringChunk
= stringChunk
.AfterFirst(wxT('\t'));
3170 dc
.GetTextExtent(stringFragment
, & w
, & h
);
3172 int absolute_width
= width
+ position
.x
;
3173 bool not_found
= true;
3174 for( int i
= 0; i
< num_tabs
&& not_found
; ++i
){
3175 next_tab_pos
= tab_array
.Item(i
);
3176 if( next_tab_pos
> absolute_width
){
3178 width
= next_tab_pos
- position
.x
;
3183 dc
.GetTextExtent(stringChunk
, & w
, & h
, & descent
);
3185 size
= wxSize(width
, dc
.GetCharHeight());
3190 /// Do a split, returning an object containing the second part, and setting
3191 /// the first part in 'this'.
3192 wxRichTextObject
* wxRichTextPlainText::DoSplit(long pos
)
3194 int index
= pos
- GetRange().GetStart();
3195 if (index
< 0 || index
>= (int) m_text
.Length())
3198 wxString firstPart
= m_text
.Mid(0, index
);
3199 wxString secondPart
= m_text
.Mid(index
);
3203 wxRichTextPlainText
* newObject
= new wxRichTextPlainText(secondPart
);
3204 newObject
->SetAttributes(GetAttributes());
3206 newObject
->SetRange(wxRichTextRange(pos
, GetRange().GetEnd()));
3207 GetRange().SetEnd(pos
-1);
3213 void wxRichTextPlainText::CalculateRange(long start
, long& end
)
3215 end
= start
+ m_text
.Length() - 1;
3216 m_range
.SetRange(start
, end
);
3220 bool wxRichTextPlainText::DeleteRange(const wxRichTextRange
& range
)
3222 wxRichTextRange r
= range
;
3224 r
.LimitTo(GetRange());
3226 if (r
.GetStart() == GetRange().GetStart() && r
.GetEnd() == GetRange().GetEnd())
3232 long startIndex
= r
.GetStart() - GetRange().GetStart();
3233 long len
= r
.GetLength();
3235 m_text
= m_text
.Mid(0, startIndex
) + m_text
.Mid(startIndex
+len
);
3239 /// Get text for the given range.
3240 wxString
wxRichTextPlainText::GetTextForRange(const wxRichTextRange
& range
) const
3242 wxRichTextRange r
= range
;
3244 r
.LimitTo(GetRange());
3246 long startIndex
= r
.GetStart() - GetRange().GetStart();
3247 long len
= r
.GetLength();
3249 return m_text
.Mid(startIndex
, len
);
3252 /// Returns true if this object can merge itself with the given one.
3253 bool wxRichTextPlainText::CanMerge(wxRichTextObject
* object
) const
3255 return object
->GetClassInfo() == CLASSINFO(wxRichTextPlainText
) &&
3256 (m_text
.empty() || wxTextAttrEq(GetAttributes(), object
->GetAttributes()));
3259 /// Returns true if this object merged itself with the given one.
3260 /// The calling code will then delete the given object.
3261 bool wxRichTextPlainText::Merge(wxRichTextObject
* object
)
3263 wxRichTextPlainText
* textObject
= wxDynamicCast(object
, wxRichTextPlainText
);
3264 wxASSERT( textObject
!= NULL
);
3268 m_text
+= textObject
->GetText();
3275 /// Dump to output stream for debugging
3276 void wxRichTextPlainText::Dump(wxTextOutputStream
& stream
)
3278 wxRichTextObject::Dump(stream
);
3279 stream
<< m_text
<< wxT("\n");
3284 * This is a kind of box, used to represent the whole buffer
3287 IMPLEMENT_DYNAMIC_CLASS(wxRichTextBuffer
, wxRichTextParagraphLayoutBox
)
3289 wxList
wxRichTextBuffer::sm_handlers
;
3292 void wxRichTextBuffer::Init()
3294 m_commandProcessor
= new wxCommandProcessor
;
3295 m_styleSheet
= NULL
;
3297 m_batchedCommandDepth
= 0;
3298 m_batchedCommand
= NULL
;
3303 wxRichTextBuffer::~wxRichTextBuffer()
3305 delete m_commandProcessor
;
3306 delete m_batchedCommand
;
3311 void wxRichTextBuffer::Clear()
3314 GetCommandProcessor()->ClearCommands();
3316 Invalidate(wxRICHTEXT_ALL
);
3319 void wxRichTextBuffer::Reset()
3322 AddParagraph(wxEmptyString
);
3323 GetCommandProcessor()->ClearCommands();
3325 Invalidate(wxRICHTEXT_ALL
);
3328 /// Submit command to insert the given text
3329 bool wxRichTextBuffer::InsertTextWithUndo(long pos
, const wxString
& text
, wxRichTextCtrl
* ctrl
)
3331 wxRichTextAction
* action
= new wxRichTextAction(NULL
, _("Insert Text"), wxRICHTEXT_INSERT
, this, ctrl
, false);
3333 action
->GetNewParagraphs().AddParagraphs(text
);
3334 if (action
->GetNewParagraphs().GetChildCount() == 1)
3335 action
->GetNewParagraphs().SetPartialParagraph(true);
3337 action
->SetPosition(pos
);
3339 // Set the range we'll need to delete in Undo
3340 action
->SetRange(wxRichTextRange(pos
, pos
+ text
.Length() - 1));
3342 SubmitAction(action
);
3347 /// Submit command to insert the given text
3348 bool wxRichTextBuffer::InsertNewlineWithUndo(long pos
, wxRichTextCtrl
* ctrl
)
3350 wxRichTextAction
* action
= new wxRichTextAction(NULL
, _("Insert Text"), wxRICHTEXT_INSERT
, this, ctrl
, false);
3352 wxTextAttrEx
attr(GetBasicStyle());
3353 wxRichTextApplyStyle(attr
, GetDefaultStyle());
3355 wxRichTextParagraph
* newPara
= new wxRichTextParagraph(wxEmptyString
, this, & attr
);
3356 action
->GetNewParagraphs().AppendChild(newPara
);
3357 action
->GetNewParagraphs().UpdateRanges();
3358 action
->GetNewParagraphs().SetPartialParagraph(false);
3359 action
->SetPosition(pos
);
3361 // Set the range we'll need to delete in Undo
3362 action
->SetRange(wxRichTextRange(pos
, pos
));
3364 SubmitAction(action
);
3369 /// Submit command to insert the given image
3370 bool wxRichTextBuffer::InsertImageWithUndo(long pos
, const wxRichTextImageBlock
& imageBlock
, wxRichTextCtrl
* ctrl
)
3372 wxRichTextAction
* action
= new wxRichTextAction(NULL
, _("Insert Image"), wxRICHTEXT_INSERT
, this, ctrl
, false);
3374 wxTextAttrEx
attr(GetBasicStyle());
3375 wxRichTextApplyStyle(attr
, GetDefaultStyle());
3377 wxRichTextParagraph
* newPara
= new wxRichTextParagraph(this, & attr
);
3378 wxRichTextImage
* imageObject
= new wxRichTextImage(imageBlock
, newPara
);
3379 newPara
->AppendChild(imageObject
);
3380 action
->GetNewParagraphs().AppendChild(newPara
);
3381 action
->GetNewParagraphs().UpdateRanges();
3383 action
->GetNewParagraphs().SetPartialParagraph(true);
3385 action
->SetPosition(pos
);
3387 // Set the range we'll need to delete in Undo
3388 action
->SetRange(wxRichTextRange(pos
, pos
));
3390 SubmitAction(action
);
3395 /// Submit command to delete this range
3396 bool wxRichTextBuffer::DeleteRangeWithUndo(const wxRichTextRange
& range
, long initialCaretPosition
, long WXUNUSED(newCaretPositon
), wxRichTextCtrl
* ctrl
)
3398 wxRichTextAction
* action
= new wxRichTextAction(NULL
, _("Delete"), wxRICHTEXT_DELETE
, this, ctrl
);
3400 action
->SetPosition(initialCaretPosition
);
3402 // Set the range to delete
3403 action
->SetRange(range
);
3405 // Copy the fragment that we'll need to restore in Undo
3406 CopyFragment(range
, action
->GetOldParagraphs());
3408 // Special case: if there is only one (non-partial) paragraph,
3409 // we must save the *next* paragraph's style, because that
3410 // is the style we must apply when inserting the content back
3411 // when undoing the delete. (This is because we're merging the
3412 // paragraph with the previous paragraph and throwing away
3413 // the style, and we need to restore it.)
3414 if (!action
->GetOldParagraphs().GetPartialParagraph() && action
->GetOldParagraphs().GetChildCount() == 1)
3416 wxRichTextParagraph
* lastPara
= GetParagraphAtPosition(range
.GetStart());
3419 wxRichTextParagraph
* nextPara
= GetParagraphAtPosition(range
.GetEnd()+1);
3422 wxRichTextParagraph
* para
= (wxRichTextParagraph
*) action
->GetOldParagraphs().GetChild(0);
3423 para
->SetAttributes(nextPara
->GetAttributes());
3428 SubmitAction(action
);
3433 /// Collapse undo/redo commands
3434 bool wxRichTextBuffer::BeginBatchUndo(const wxString
& cmdName
)
3436 if (m_batchedCommandDepth
== 0)
3438 wxASSERT(m_batchedCommand
== NULL
);
3439 if (m_batchedCommand
)
3441 GetCommandProcessor()->Submit(m_batchedCommand
);
3443 m_batchedCommand
= new wxRichTextCommand(cmdName
);
3446 m_batchedCommandDepth
++;
3451 /// Collapse undo/redo commands
3452 bool wxRichTextBuffer::EndBatchUndo()
3454 m_batchedCommandDepth
--;
3456 wxASSERT(m_batchedCommandDepth
>= 0);
3457 wxASSERT(m_batchedCommand
!= NULL
);
3459 if (m_batchedCommandDepth
== 0)
3461 GetCommandProcessor()->Submit(m_batchedCommand
);
3462 m_batchedCommand
= NULL
;
3468 /// Submit immediately, or delay according to whether collapsing is on
3469 bool wxRichTextBuffer::SubmitAction(wxRichTextAction
* action
)
3471 if (BatchingUndo() && m_batchedCommand
&& !SuppressingUndo())
3472 m_batchedCommand
->AddAction(action
);
3475 wxRichTextCommand
* cmd
= new wxRichTextCommand(action
->GetName());
3476 cmd
->AddAction(action
);
3478 // Only store it if we're not suppressing undo.
3479 return GetCommandProcessor()->Submit(cmd
, !SuppressingUndo());
3485 /// Begin suppressing undo/redo commands.
3486 bool wxRichTextBuffer::BeginSuppressUndo()
3493 /// End suppressing undo/redo commands.
3494 bool wxRichTextBuffer::EndSuppressUndo()
3501 /// Begin using a style
3502 bool wxRichTextBuffer::BeginStyle(const wxTextAttrEx
& style
)
3504 wxTextAttrEx
newStyle(GetDefaultStyle());
3506 // Save the old default style
3507 m_attributeStack
.Append((wxObject
*) new wxTextAttrEx(GetDefaultStyle()));
3509 wxRichTextApplyStyle(newStyle
, style
);
3510 newStyle
.SetFlags(style
.GetFlags()|newStyle
.GetFlags());
3512 SetDefaultStyle(newStyle
);
3514 // wxLogDebug("Default style size = %d", GetDefaultStyle().GetFont().GetPointSize());
3520 bool wxRichTextBuffer::EndStyle()
3522 if (!m_attributeStack
.GetFirst())
3524 wxLogDebug(_("Too many EndStyle calls!"));
3528 wxList::compatibility_iterator node
= m_attributeStack
.GetLast();
3529 wxTextAttrEx
* attr
= (wxTextAttrEx
*)node
->GetData();
3530 m_attributeStack
.Erase(node
);
3532 SetDefaultStyle(*attr
);
3539 bool wxRichTextBuffer::EndAllStyles()
3541 while (m_attributeStack
.GetCount() != 0)
3546 /// Clear the style stack
3547 void wxRichTextBuffer::ClearStyleStack()
3549 for (wxList::compatibility_iterator node
= m_attributeStack
.GetFirst(); node
; node
= node
->GetNext())
3550 delete (wxTextAttrEx
*) node
->GetData();
3551 m_attributeStack
.Clear();
3554 /// Begin using bold
3555 bool wxRichTextBuffer::BeginBold()
3557 wxFont
font(GetBasicStyle().GetFont());
3558 font
.SetWeight(wxBOLD
);
3561 attr
.SetFont(font
,wxTEXT_ATTR_FONT_WEIGHT
);
3563 return BeginStyle(attr
);
3566 /// Begin using italic
3567 bool wxRichTextBuffer::BeginItalic()
3569 wxFont
font(GetBasicStyle().GetFont());
3570 font
.SetStyle(wxITALIC
);
3573 attr
.SetFont(font
, wxTEXT_ATTR_FONT_ITALIC
);
3575 return BeginStyle(attr
);
3578 /// Begin using underline
3579 bool wxRichTextBuffer::BeginUnderline()
3581 wxFont
font(GetBasicStyle().GetFont());
3582 font
.SetUnderlined(true);
3585 attr
.SetFont(font
, wxTEXT_ATTR_FONT_UNDERLINE
);
3587 return BeginStyle(attr
);
3590 /// Begin using point size
3591 bool wxRichTextBuffer::BeginFontSize(int pointSize
)
3593 wxFont
font(GetBasicStyle().GetFont());
3594 font
.SetPointSize(pointSize
);
3597 attr
.SetFont(font
, wxTEXT_ATTR_FONT_SIZE
);
3599 return BeginStyle(attr
);
3602 /// Begin using this font
3603 bool wxRichTextBuffer::BeginFont(const wxFont
& font
)
3606 attr
.SetFlags(wxTEXT_ATTR_FONT
);
3609 return BeginStyle(attr
);
3612 /// Begin using this colour
3613 bool wxRichTextBuffer::BeginTextColour(const wxColour
& colour
)
3616 attr
.SetFlags(wxTEXT_ATTR_TEXT_COLOUR
);
3617 attr
.SetTextColour(colour
);
3619 return BeginStyle(attr
);
3622 /// Begin using alignment
3623 bool wxRichTextBuffer::BeginAlignment(wxTextAttrAlignment alignment
)
3626 attr
.SetFlags(wxTEXT_ATTR_ALIGNMENT
);
3627 attr
.SetAlignment(alignment
);
3629 return BeginStyle(attr
);
3632 /// Begin left indent
3633 bool wxRichTextBuffer::BeginLeftIndent(int leftIndent
, int leftSubIndent
)
3636 attr
.SetFlags(wxTEXT_ATTR_LEFT_INDENT
);
3637 attr
.SetLeftIndent(leftIndent
, leftSubIndent
);
3639 return BeginStyle(attr
);
3642 /// Begin right indent
3643 bool wxRichTextBuffer::BeginRightIndent(int rightIndent
)
3646 attr
.SetFlags(wxTEXT_ATTR_RIGHT_INDENT
);
3647 attr
.SetRightIndent(rightIndent
);
3649 return BeginStyle(attr
);
3652 /// Begin paragraph spacing
3653 bool wxRichTextBuffer::BeginParagraphSpacing(int before
, int after
)
3657 flags
|= wxTEXT_ATTR_PARA_SPACING_BEFORE
;
3659 flags
|= wxTEXT_ATTR_PARA_SPACING_AFTER
;
3662 attr
.SetFlags(flags
);
3663 attr
.SetParagraphSpacingBefore(before
);
3664 attr
.SetParagraphSpacingAfter(after
);
3666 return BeginStyle(attr
);
3669 /// Begin line spacing
3670 bool wxRichTextBuffer::BeginLineSpacing(int lineSpacing
)
3673 attr
.SetFlags(wxTEXT_ATTR_LINE_SPACING
);
3674 attr
.SetLineSpacing(lineSpacing
);
3676 return BeginStyle(attr
);
3679 /// Begin numbered bullet
3680 bool wxRichTextBuffer::BeginNumberedBullet(int bulletNumber
, int leftIndent
, int leftSubIndent
, int bulletStyle
)
3683 attr
.SetFlags(wxTEXT_ATTR_BULLET_STYLE
|wxTEXT_ATTR_BULLET_NUMBER
|wxTEXT_ATTR_LEFT_INDENT
);
3684 attr
.SetBulletStyle(bulletStyle
);
3685 attr
.SetBulletNumber(bulletNumber
);
3686 attr
.SetLeftIndent(leftIndent
, leftSubIndent
);
3688 return BeginStyle(attr
);
3691 /// Begin symbol bullet
3692 bool wxRichTextBuffer::BeginSymbolBullet(wxChar symbol
, int leftIndent
, int leftSubIndent
, int bulletStyle
)
3695 attr
.SetFlags(wxTEXT_ATTR_BULLET_STYLE
|wxTEXT_ATTR_BULLET_SYMBOL
|wxTEXT_ATTR_LEFT_INDENT
);
3696 attr
.SetBulletStyle(bulletStyle
);
3697 attr
.SetLeftIndent(leftIndent
, leftSubIndent
);
3698 attr
.SetBulletSymbol(symbol
);
3700 return BeginStyle(attr
);
3703 /// Begin named character style
3704 bool wxRichTextBuffer::BeginCharacterStyle(const wxString
& characterStyle
)
3706 if (GetStyleSheet())
3708 wxRichTextCharacterStyleDefinition
* def
= GetStyleSheet()->FindCharacterStyle(characterStyle
);
3712 def
->GetStyle().CopyTo(attr
);
3713 return BeginStyle(attr
);
3719 /// Begin named paragraph style
3720 bool wxRichTextBuffer::BeginParagraphStyle(const wxString
& paragraphStyle
)
3722 if (GetStyleSheet())
3724 wxRichTextParagraphStyleDefinition
* def
= GetStyleSheet()->FindParagraphStyle(paragraphStyle
);
3728 def
->GetStyle().CopyTo(attr
);
3729 return BeginStyle(attr
);
3735 /// Adds a handler to the end
3736 void wxRichTextBuffer::AddHandler(wxRichTextFileHandler
*handler
)
3738 sm_handlers
.Append(handler
);
3741 /// Inserts a handler at the front
3742 void wxRichTextBuffer::InsertHandler(wxRichTextFileHandler
*handler
)
3744 sm_handlers
.Insert( handler
);
3747 /// Removes a handler
3748 bool wxRichTextBuffer::RemoveHandler(const wxString
& name
)
3750 wxRichTextFileHandler
*handler
= FindHandler(name
);
3753 sm_handlers
.DeleteObject(handler
);
3761 /// Finds a handler by filename or, if supplied, type
3762 wxRichTextFileHandler
*wxRichTextBuffer::FindHandlerFilenameOrType(const wxString
& filename
, int imageType
)
3764 if (imageType
!= wxRICHTEXT_TYPE_ANY
)
3765 return FindHandler(imageType
);
3768 wxString path
, file
, ext
;
3769 wxSplitPath(filename
, & path
, & file
, & ext
);
3770 return FindHandler(ext
, imageType
);
3775 /// Finds a handler by name
3776 wxRichTextFileHandler
* wxRichTextBuffer::FindHandler(const wxString
& name
)
3778 wxList::compatibility_iterator node
= sm_handlers
.GetFirst();
3781 wxRichTextFileHandler
*handler
= (wxRichTextFileHandler
*)node
->GetData();
3782 if (handler
->GetName().Lower() == name
.Lower()) return handler
;
3784 node
= node
->GetNext();
3789 /// Finds a handler by extension and type
3790 wxRichTextFileHandler
* wxRichTextBuffer::FindHandler(const wxString
& extension
, int type
)
3792 wxList::compatibility_iterator node
= sm_handlers
.GetFirst();
3795 wxRichTextFileHandler
*handler
= (wxRichTextFileHandler
*)node
->GetData();
3796 if ( handler
->GetExtension().Lower() == extension
.Lower() &&
3797 (type
== wxRICHTEXT_TYPE_ANY
|| handler
->GetType() == type
) )
3799 node
= node
->GetNext();
3804 /// Finds a handler by type
3805 wxRichTextFileHandler
* wxRichTextBuffer::FindHandler(int type
)
3807 wxList::compatibility_iterator node
= sm_handlers
.GetFirst();
3810 wxRichTextFileHandler
*handler
= (wxRichTextFileHandler
*)node
->GetData();
3811 if (handler
->GetType() == type
) return handler
;
3812 node
= node
->GetNext();
3817 void wxRichTextBuffer::InitStandardHandlers()
3819 if (!FindHandler(wxRICHTEXT_TYPE_TEXT
))
3820 AddHandler(new wxRichTextPlainTextHandler
);
3823 void wxRichTextBuffer::CleanUpHandlers()
3825 wxList::compatibility_iterator node
= sm_handlers
.GetFirst();
3828 wxRichTextFileHandler
* handler
= (wxRichTextFileHandler
*)node
->GetData();
3829 wxList::compatibility_iterator next
= node
->GetNext();
3834 sm_handlers
.Clear();
3837 wxString
wxRichTextBuffer::GetExtWildcard(bool combine
, bool save
, wxArrayInt
* types
)
3844 wxList::compatibility_iterator node
= GetHandlers().GetFirst();
3848 wxRichTextFileHandler
* handler
= (wxRichTextFileHandler
*) node
->GetData();
3849 if (handler
->IsVisible() && ((save
&& handler
->CanSave()) || !save
&& handler
->CanLoad()))
3854 wildcard
+= wxT(";");
3855 wildcard
+= wxT("*.") + handler
->GetExtension();
3860 wildcard
+= wxT("|");
3861 wildcard
+= handler
->GetName();
3862 wildcard
+= wxT(" ");
3863 wildcard
+= _("files");
3864 wildcard
+= wxT(" (*.");
3865 wildcard
+= handler
->GetExtension();
3866 wildcard
+= wxT(")|*.");
3867 wildcard
+= handler
->GetExtension();
3869 types
->Add(handler
->GetType());
3874 node
= node
->GetNext();
3878 wildcard
= wxT("(") + wildcard
+ wxT(")|") + wildcard
;
3883 bool wxRichTextBuffer::LoadFile(const wxString
& filename
, int type
)
3885 wxRichTextFileHandler
* handler
= FindHandlerFilenameOrType(filename
, type
);
3888 SetDefaultStyle(wxTextAttrEx());
3890 bool success
= handler
->LoadFile(this, filename
);
3891 Invalidate(wxRICHTEXT_ALL
);
3899 bool wxRichTextBuffer::SaveFile(const wxString
& filename
, int type
)
3901 wxRichTextFileHandler
* handler
= FindHandlerFilenameOrType(filename
, type
);
3903 return handler
->SaveFile(this, filename
);
3908 /// Load from a stream
3909 bool wxRichTextBuffer::LoadFile(wxInputStream
& stream
, int type
)
3911 wxRichTextFileHandler
* handler
= FindHandler(type
);
3914 SetDefaultStyle(wxTextAttrEx());
3915 bool success
= handler
->LoadFile(this, stream
);
3916 Invalidate(wxRICHTEXT_ALL
);
3923 /// Save to a stream
3924 bool wxRichTextBuffer::SaveFile(wxOutputStream
& stream
, int type
)
3926 wxRichTextFileHandler
* handler
= FindHandler(type
);
3928 return handler
->SaveFile(this, stream
);
3933 /// Copy the range to the clipboard
3934 bool wxRichTextBuffer::CopyToClipboard(const wxRichTextRange
& range
)
3936 bool success
= false;
3937 #if wxUSE_CLIPBOARD && wxUSE_DATAOBJ
3938 wxString text
= GetTextForRange(range
);
3939 if (!wxTheClipboard
->IsOpened() && wxTheClipboard
->Open())
3941 success
= wxTheClipboard
->SetData(new wxTextDataObject(text
));
3942 wxTheClipboard
->Close();
3950 /// Paste the clipboard content to the buffer
3951 bool wxRichTextBuffer::PasteFromClipboard(long position
)
3953 bool success
= false;
3954 #if wxUSE_CLIPBOARD && wxUSE_DATAOBJ
3955 if (CanPasteFromClipboard())
3957 if (wxTheClipboard
->Open())
3959 if (wxTheClipboard
->IsSupported(wxDF_TEXT
))
3961 wxTextDataObject data
;
3962 wxTheClipboard
->GetData(data
);
3963 wxString
text(data
.GetText());
3964 text
.Replace(_T("\r\n"), _T("\n"));
3966 InsertTextWithUndo(position
+1, text
, GetRichTextCtrl());
3970 else if (wxTheClipboard
->IsSupported(wxDF_BITMAP
))
3972 wxBitmapDataObject data
;
3973 wxTheClipboard
->GetData(data
);
3974 wxBitmap
bitmap(data
.GetBitmap());
3975 wxImage
image(bitmap
.ConvertToImage());
3977 wxRichTextAction
* action
= new wxRichTextAction(NULL
, _("Insert Image"), wxRICHTEXT_INSERT
, this, GetRichTextCtrl(), false);
3979 action
->GetNewParagraphs().AddImage(image
);
3981 if (action
->GetNewParagraphs().GetChildCount() == 1)
3982 action
->GetNewParagraphs().SetPartialParagraph(true);
3984 action
->SetPosition(position
);
3986 // Set the range we'll need to delete in Undo
3987 action
->SetRange(wxRichTextRange(position
, position
));
3989 SubmitAction(action
);
3993 wxTheClipboard
->Close();
3997 wxUnusedVar(position
);
4002 /// Can we paste from the clipboard?
4003 bool wxRichTextBuffer::CanPasteFromClipboard() const
4005 bool canPaste
= false;
4006 #if wxUSE_CLIPBOARD && wxUSE_DATAOBJ
4007 if (!wxTheClipboard
->IsOpened() && wxTheClipboard
->Open())
4009 if (wxTheClipboard
->IsSupported(wxDF_TEXT
) || wxTheClipboard
->IsSupported(wxDF_BITMAP
))
4013 wxTheClipboard
->Close();
4019 /// Dumps contents of buffer for debugging purposes
4020 void wxRichTextBuffer::Dump()
4024 wxStringOutputStream
stream(& text
);
4025 wxTextOutputStream
textStream(stream
);
4034 * Module to initialise and clean up handlers
4037 class wxRichTextModule
: public wxModule
4039 DECLARE_DYNAMIC_CLASS(wxRichTextModule
)
4041 wxRichTextModule() {}
4042 bool OnInit() { wxRichTextBuffer::InitStandardHandlers(); return true; };
4043 void OnExit() { wxRichTextBuffer::CleanUpHandlers(); };
4046 IMPLEMENT_DYNAMIC_CLASS(wxRichTextModule
, wxModule
)
4050 * Commands for undo/redo
4054 wxRichTextCommand::wxRichTextCommand(const wxString
& name
, wxRichTextCommandId id
, wxRichTextBuffer
* buffer
,
4055 wxRichTextCtrl
* ctrl
, bool ignoreFirstTime
): wxCommand(true, name
)
4057 /* wxRichTextAction* action = */ new wxRichTextAction(this, name
, id
, buffer
, ctrl
, ignoreFirstTime
);
4060 wxRichTextCommand::wxRichTextCommand(const wxString
& name
): wxCommand(true, name
)
4064 wxRichTextCommand::~wxRichTextCommand()
4069 void wxRichTextCommand::AddAction(wxRichTextAction
* action
)
4071 if (!m_actions
.Member(action
))
4072 m_actions
.Append(action
);
4075 bool wxRichTextCommand::Do()
4077 for (wxList::compatibility_iterator node
= m_actions
.GetFirst(); node
; node
= node
->GetNext())
4079 wxRichTextAction
* action
= (wxRichTextAction
*) node
->GetData();
4086 bool wxRichTextCommand::Undo()
4088 for (wxList::compatibility_iterator node
= m_actions
.GetLast(); node
; node
= node
->GetPrevious())
4090 wxRichTextAction
* action
= (wxRichTextAction
*) node
->GetData();
4097 void wxRichTextCommand::ClearActions()
4099 WX_CLEAR_LIST(wxList
, m_actions
);
4107 wxRichTextAction::wxRichTextAction(wxRichTextCommand
* cmd
, const wxString
& name
, wxRichTextCommandId id
, wxRichTextBuffer
* buffer
,
4108 wxRichTextCtrl
* ctrl
, bool ignoreFirstTime
)
4111 m_ignoreThis
= ignoreFirstTime
;
4116 m_newParagraphs
.SetDefaultStyle(buffer
->GetDefaultStyle());
4117 m_newParagraphs
.SetBasicStyle(buffer
->GetBasicStyle());
4119 cmd
->AddAction(this);
4122 wxRichTextAction::~wxRichTextAction()
4126 bool wxRichTextAction::Do()
4128 m_buffer
->Modify(true);
4132 case wxRICHTEXT_INSERT
:
4134 m_buffer
->InsertFragment(GetPosition(), m_newParagraphs
);
4135 m_buffer
->UpdateRanges();
4136 m_buffer
->Invalidate(GetRange());
4138 long newCaretPosition
= GetPosition() + m_newParagraphs
.GetRange().GetLength() - 1;
4139 if (m_newParagraphs
.GetPartialParagraph())
4140 newCaretPosition
--;
4142 UpdateAppearance(newCaretPosition
, true /* send update event */);
4146 case wxRICHTEXT_DELETE
:
4148 m_buffer
->DeleteRange(GetRange());
4149 m_buffer
->UpdateRanges();
4150 m_buffer
->Invalidate(wxRichTextRange(GetRange().GetStart(), GetRange().GetStart()));
4152 UpdateAppearance(GetRange().GetStart()-1, true /* send update event */);
4156 case wxRICHTEXT_CHANGE_STYLE
:
4158 ApplyParagraphs(GetNewParagraphs());
4159 m_buffer
->Invalidate(GetRange());
4161 UpdateAppearance(GetPosition());
4172 bool wxRichTextAction::Undo()
4174 m_buffer
->Modify(true);
4178 case wxRICHTEXT_INSERT
:
4180 m_buffer
->DeleteRange(GetRange());
4181 m_buffer
->UpdateRanges();
4182 m_buffer
->Invalidate(wxRichTextRange(GetRange().GetStart(), GetRange().GetStart()));
4184 long newCaretPosition
= GetPosition() - 1;
4185 // if (m_newParagraphs.GetPartialParagraph())
4186 // newCaretPosition --;
4188 UpdateAppearance(newCaretPosition
, true /* send update event */);
4192 case wxRICHTEXT_DELETE
:
4194 m_buffer
->InsertFragment(GetRange().GetStart(), m_oldParagraphs
);
4195 m_buffer
->UpdateRanges();
4196 m_buffer
->Invalidate(GetRange());
4198 UpdateAppearance(GetPosition(), true /* send update event */);
4202 case wxRICHTEXT_CHANGE_STYLE
:
4204 ApplyParagraphs(GetOldParagraphs());
4205 m_buffer
->Invalidate(GetRange());
4207 UpdateAppearance(GetPosition());
4218 /// Update the control appearance
4219 void wxRichTextAction::UpdateAppearance(long caretPosition
, bool sendUpdateEvent
)
4223 m_ctrl
->SetCaretPosition(caretPosition
);
4224 if (!m_ctrl
->IsFrozen())
4226 m_ctrl
->LayoutContent();
4227 m_ctrl
->PositionCaret();
4228 m_ctrl
->Refresh(false);
4230 if (sendUpdateEvent
)
4231 m_ctrl
->SendUpdateEvent();
4236 /// Replace the buffer paragraphs with the new ones.
4237 void wxRichTextAction::ApplyParagraphs(const wxRichTextFragment
& fragment
)
4239 wxRichTextObjectList::compatibility_iterator node
= fragment
.GetChildren().GetFirst();
4242 wxRichTextParagraph
* para
= wxDynamicCast(node
->GetData(), wxRichTextParagraph
);
4243 wxASSERT (para
!= NULL
);
4245 // We'll replace the existing paragraph by finding the paragraph at this position,
4246 // delete its node data, and setting a copy as the new node data.
4247 // TODO: make more efficient by simply swapping old and new paragraph objects.
4249 wxRichTextParagraph
* existingPara
= m_buffer
->GetParagraphAtPosition(para
->GetRange().GetStart());
4252 wxRichTextObjectList::compatibility_iterator bufferParaNode
= m_buffer
->GetChildren().Find(existingPara
);
4255 wxRichTextParagraph
* newPara
= new wxRichTextParagraph(*para
);
4256 newPara
->SetParent(m_buffer
);
4258 bufferParaNode
->SetData(newPara
);
4260 delete existingPara
;
4264 node
= node
->GetNext();
4271 * This stores beginning and end positions for a range of data.
4274 /// Limit this range to be within 'range'
4275 bool wxRichTextRange::LimitTo(const wxRichTextRange
& range
)
4277 if (m_start
< range
.m_start
)
4278 m_start
= range
.m_start
;
4280 if (m_end
> range
.m_end
)
4281 m_end
= range
.m_end
;
4287 * wxRichTextImage implementation
4288 * This object represents an image.
4291 IMPLEMENT_DYNAMIC_CLASS(wxRichTextImage
, wxRichTextObject
)
4293 wxRichTextImage::wxRichTextImage(const wxImage
& image
, wxRichTextObject
* parent
):
4294 wxRichTextObject(parent
)
4299 wxRichTextImage::wxRichTextImage(const wxRichTextImageBlock
& imageBlock
, wxRichTextObject
* parent
):
4300 wxRichTextObject(parent
)
4302 m_imageBlock
= imageBlock
;
4303 m_imageBlock
.Load(m_image
);
4306 /// Load wxImage from the block
4307 bool wxRichTextImage::LoadFromBlock()
4309 m_imageBlock
.Load(m_image
);
4310 return m_imageBlock
.Ok();
4313 /// Make block from the wxImage
4314 bool wxRichTextImage::MakeBlock()
4316 if (m_imageBlock
.GetImageType() == wxBITMAP_TYPE_ANY
|| m_imageBlock
.GetImageType() == -1)
4317 m_imageBlock
.SetImageType(wxBITMAP_TYPE_PNG
);
4319 m_imageBlock
.MakeImageBlock(m_image
, m_imageBlock
.GetImageType());
4320 return m_imageBlock
.Ok();
4325 bool wxRichTextImage::Draw(wxDC
& dc
, const wxRichTextRange
& range
, const wxRichTextRange
& selectionRange
, const wxRect
& rect
, int WXUNUSED(descent
), int WXUNUSED(style
))
4327 if (!m_image
.Ok() && m_imageBlock
.Ok())
4333 if (m_image
.Ok() && !m_bitmap
.Ok())
4334 m_bitmap
= wxBitmap(m_image
);
4336 int y
= rect
.y
+ (rect
.height
- m_image
.GetHeight());
4339 dc
.DrawBitmap(m_bitmap
, rect
.x
, y
, true);
4341 if (selectionRange
.Contains(range
.GetStart()))
4343 dc
.SetBrush(*wxBLACK_BRUSH
);
4344 dc
.SetPen(*wxBLACK_PEN
);
4345 dc
.SetLogicalFunction(wxINVERT
);
4346 dc
.DrawRectangle(rect
);
4347 dc
.SetLogicalFunction(wxCOPY
);
4353 /// Lay the item out
4354 bool wxRichTextImage::Layout(wxDC
& WXUNUSED(dc
), const wxRect
& rect
, int WXUNUSED(style
))
4361 SetCachedSize(wxSize(m_image
.GetWidth(), m_image
.GetHeight()));
4362 SetPosition(rect
.GetPosition());
4368 /// Get/set the object size for the given range. Returns false if the range
4369 /// is invalid for this object.
4370 bool wxRichTextImage::GetRangeSize(const wxRichTextRange
& range
, wxSize
& size
, int& WXUNUSED(descent
), wxDC
& WXUNUSED(dc
), int WXUNUSED(flags
), wxPoint
WXUNUSED(position
)) const
4372 if (!range
.IsWithin(GetRange()))
4378 size
.x
= m_image
.GetWidth();
4379 size
.y
= m_image
.GetHeight();
4385 void wxRichTextImage::Copy(const wxRichTextImage
& obj
)
4387 m_image
= obj
.m_image
;
4388 m_imageBlock
= obj
.m_imageBlock
;
4396 /// Compare two attribute objects
4397 bool wxTextAttrEq(const wxTextAttrEx
& attr1
, const wxTextAttrEx
& attr2
)
4400 attr1
.GetTextColour() == attr2
.GetTextColour() &&
4401 attr1
.GetBackgroundColour() == attr2
.GetBackgroundColour() &&
4402 attr1
.GetFont() == attr2
.GetFont() &&
4403 attr1
.GetAlignment() == attr2
.GetAlignment() &&
4404 attr1
.GetLeftIndent() == attr2
.GetLeftIndent() &&
4405 attr1
.GetRightIndent() == attr2
.GetRightIndent() &&
4406 attr1
.GetLeftSubIndent() == attr2
.GetLeftSubIndent() &&
4407 attr1
.GetTabs().GetCount() == attr2
.GetTabs().GetCount() && // heuristic
4408 attr1
.GetLineSpacing() == attr2
.GetLineSpacing() &&
4409 attr1
.GetParagraphSpacingAfter() == attr2
.GetParagraphSpacingAfter() &&
4410 attr1
.GetParagraphSpacingBefore() == attr2
.GetParagraphSpacingBefore() &&
4411 attr1
.GetBulletStyle() == attr2
.GetBulletStyle() &&
4412 attr1
.GetBulletNumber() == attr2
.GetBulletNumber() &&
4413 attr1
.GetBulletSymbol() == attr2
.GetBulletSymbol() &&
4414 attr1
.GetCharacterStyleName() == attr2
.GetCharacterStyleName() &&
4415 attr1
.GetParagraphStyleName() == attr2
.GetParagraphStyleName());
4418 bool wxTextAttrEq(const wxTextAttrEx
& attr1
, const wxRichTextAttr
& attr2
)
4421 attr1
.GetTextColour() == attr2
.GetTextColour() &&
4422 attr1
.GetBackgroundColour() == attr2
.GetBackgroundColour() &&
4423 attr1
.GetFont().GetPointSize() == attr2
.GetFontSize() &&
4424 attr1
.GetFont().GetStyle() == attr2
.GetFontStyle() &&
4425 attr1
.GetFont().GetWeight() == attr2
.GetFontWeight() &&
4426 attr1
.GetFont().GetFaceName() == attr2
.GetFontFaceName() &&
4427 attr1
.GetFont().GetUnderlined() == attr2
.GetFontUnderlined() &&
4428 attr1
.GetAlignment() == attr2
.GetAlignment() &&
4429 attr1
.GetLeftIndent() == attr2
.GetLeftIndent() &&
4430 attr1
.GetRightIndent() == attr2
.GetRightIndent() &&
4431 attr1
.GetLeftSubIndent() == attr2
.GetLeftSubIndent() &&
4432 attr1
.GetTabs().GetCount() == attr2
.GetTabs().GetCount() && // heuristic
4433 attr1
.GetLineSpacing() == attr2
.GetLineSpacing() &&
4434 attr1
.GetParagraphSpacingAfter() == attr2
.GetParagraphSpacingAfter() &&
4435 attr1
.GetParagraphSpacingBefore() == attr2
.GetParagraphSpacingBefore() &&
4436 attr1
.GetBulletStyle() == attr2
.GetBulletStyle() &&
4437 attr1
.GetBulletNumber() == attr2
.GetBulletNumber() &&
4438 attr1
.GetBulletSymbol() == attr2
.GetBulletSymbol() &&
4439 attr1
.GetCharacterStyleName() == attr2
.GetCharacterStyleName() &&
4440 attr1
.GetParagraphStyleName() == attr2
.GetParagraphStyleName());
4443 /// Compare two attribute objects, but take into account the flags
4444 /// specifying attributes of interest.
4445 bool wxTextAttrEqPartial(const wxTextAttrEx
& attr1
, const wxTextAttrEx
& attr2
, int flags
)
4447 if ((flags
& wxTEXT_ATTR_TEXT_COLOUR
) && attr1
.GetTextColour() != attr2
.GetTextColour())
4450 if ((flags
& wxTEXT_ATTR_BACKGROUND_COLOUR
) && attr1
.GetBackgroundColour() != attr2
.GetBackgroundColour())
4453 if ((flags
& wxTEXT_ATTR_FONT_FACE
) && attr1
.GetFont().Ok() && attr2
.GetFont().Ok() &&
4454 attr1
.GetFont().GetFaceName() != attr2
.GetFont().GetFaceName())
4457 if ((flags
& wxTEXT_ATTR_FONT_SIZE
) && attr1
.GetFont().Ok() && attr2
.GetFont().Ok() &&
4458 attr1
.GetFont().GetPointSize() != attr2
.GetFont().GetPointSize())
4461 if ((flags
& wxTEXT_ATTR_FONT_WEIGHT
) && attr1
.GetFont().Ok() && attr2
.GetFont().Ok() &&
4462 attr1
.GetFont().GetWeight() != attr2
.GetFont().GetWeight())
4465 if ((flags
& wxTEXT_ATTR_FONT_ITALIC
) && attr1
.GetFont().Ok() && attr2
.GetFont().Ok() &&
4466 attr1
.GetFont().GetStyle() != attr2
.GetFont().GetStyle())
4469 if ((flags
& wxTEXT_ATTR_FONT_UNDERLINE
) && attr1
.GetFont().Ok() && attr2
.GetFont().Ok() &&
4470 attr1
.GetFont().GetUnderlined() != attr2
.GetFont().GetUnderlined())
4473 if ((flags
& wxTEXT_ATTR_ALIGNMENT
) && attr1
.GetAlignment() != attr2
.GetAlignment())
4476 if ((flags
& wxTEXT_ATTR_LEFT_INDENT
) &&
4477 ((attr1
.GetLeftIndent() != attr2
.GetLeftIndent()) || (attr1
.GetLeftSubIndent() != attr2
.GetLeftSubIndent())))
4480 if ((flags
& wxTEXT_ATTR_RIGHT_INDENT
) &&
4481 (attr1
.GetRightIndent() != attr2
.GetRightIndent()))
4484 if ((flags
& wxTEXT_ATTR_PARA_SPACING_AFTER
) &&
4485 (attr1
.GetParagraphSpacingAfter() != attr2
.GetParagraphSpacingAfter()))
4488 if ((flags
& wxTEXT_ATTR_PARA_SPACING_BEFORE
) &&
4489 (attr1
.GetParagraphSpacingBefore() != attr2
.GetParagraphSpacingBefore()))
4492 if ((flags
& wxTEXT_ATTR_LINE_SPACING
) &&
4493 (attr1
.GetLineSpacing() != attr2
.GetLineSpacing()))
4496 if ((flags
& wxTEXT_ATTR_CHARACTER_STYLE_NAME
) &&
4497 (attr1
.GetCharacterStyleName() != attr2
.GetCharacterStyleName()))
4500 if ((flags
& wxTEXT_ATTR_PARAGRAPH_STYLE_NAME
) &&
4501 (attr1
.GetParagraphStyleName() != attr2
.GetParagraphStyleName()))
4504 if ((flags
& wxTEXT_ATTR_BULLET_STYLE
) &&
4505 (attr1
.GetBulletStyle() != attr2
.GetBulletStyle()))
4508 if ((flags
& wxTEXT_ATTR_BULLET_NUMBER
) &&
4509 (attr1
.GetBulletNumber() != attr2
.GetBulletNumber()))
4512 if ((flags
& wxTEXT_ATTR_BULLET_SYMBOL
) &&
4513 (attr1
.GetBulletSymbol() != attr2
.GetBulletSymbol()))
4517 if ((flags & wxTEXT_ATTR_TABS) &&
4524 bool wxTextAttrEqPartial(const wxTextAttrEx
& attr1
, const wxRichTextAttr
& attr2
, int flags
)
4526 if ((flags
& wxTEXT_ATTR_TEXT_COLOUR
) && attr1
.GetTextColour() != attr2
.GetTextColour())
4529 if ((flags
& wxTEXT_ATTR_BACKGROUND_COLOUR
) && attr1
.GetBackgroundColour() != attr2
.GetBackgroundColour())
4532 if ((flags
& (wxTEXT_ATTR_FONT
)) && !attr1
.GetFont().Ok())
4535 if ((flags
& wxTEXT_ATTR_FONT_FACE
) && attr1
.GetFont().Ok() &&
4536 attr1
.GetFont().GetFaceName() != attr2
.GetFontFaceName())
4539 if ((flags
& wxTEXT_ATTR_FONT_SIZE
) && attr1
.GetFont().Ok() &&
4540 attr1
.GetFont().GetPointSize() != attr2
.GetFontSize())
4543 if ((flags
& wxTEXT_ATTR_FONT_WEIGHT
) && attr1
.GetFont().Ok() &&
4544 attr1
.GetFont().GetWeight() != attr2
.GetFontWeight())
4547 if ((flags
& wxTEXT_ATTR_FONT_ITALIC
) && attr1
.GetFont().Ok() &&
4548 attr1
.GetFont().GetStyle() != attr2
.GetFontStyle())
4551 if ((flags
& wxTEXT_ATTR_FONT_UNDERLINE
) && attr1
.GetFont().Ok() &&
4552 attr1
.GetFont().GetUnderlined() != attr2
.GetFontUnderlined())
4555 if ((flags
& wxTEXT_ATTR_ALIGNMENT
) && attr1
.GetAlignment() != attr2
.GetAlignment())
4558 if ((flags
& wxTEXT_ATTR_LEFT_INDENT
) &&
4559 ((attr1
.GetLeftIndent() != attr2
.GetLeftIndent()) || (attr1
.GetLeftSubIndent() != attr2
.GetLeftSubIndent())))
4562 if ((flags
& wxTEXT_ATTR_RIGHT_INDENT
) &&
4563 (attr1
.GetRightIndent() != attr2
.GetRightIndent()))
4566 if ((flags
& wxTEXT_ATTR_PARA_SPACING_AFTER
) &&
4567 (attr1
.GetParagraphSpacingAfter() != attr2
.GetParagraphSpacingAfter()))
4570 if ((flags
& wxTEXT_ATTR_PARA_SPACING_BEFORE
) &&
4571 (attr1
.GetParagraphSpacingBefore() != attr2
.GetParagraphSpacingBefore()))
4574 if ((flags
& wxTEXT_ATTR_LINE_SPACING
) &&
4575 (attr1
.GetLineSpacing() != attr2
.GetLineSpacing()))
4578 if ((flags
& wxTEXT_ATTR_CHARACTER_STYLE_NAME
) &&
4579 (attr1
.GetCharacterStyleName() != attr2
.GetCharacterStyleName()))
4582 if ((flags
& wxTEXT_ATTR_PARAGRAPH_STYLE_NAME
) &&
4583 (attr1
.GetParagraphStyleName() != attr2
.GetParagraphStyleName()))
4586 if ((flags
& wxTEXT_ATTR_BULLET_STYLE
) &&
4587 (attr1
.GetBulletStyle() != attr2
.GetBulletStyle()))
4590 if ((flags
& wxTEXT_ATTR_BULLET_NUMBER
) &&
4591 (attr1
.GetBulletNumber() != attr2
.GetBulletNumber()))
4594 if ((flags
& wxTEXT_ATTR_BULLET_SYMBOL
) &&
4595 (attr1
.GetBulletSymbol() != attr2
.GetBulletSymbol()))
4599 if ((flags & wxTEXT_ATTR_TABS) &&
4607 /// Apply one style to another
4608 bool wxRichTextApplyStyle(wxTextAttrEx
& destStyle
, const wxTextAttrEx
& style
)
4611 if (style
.GetFont().Ok() && ((style
.GetFlags() & (wxTEXT_ATTR_FONT
)) == (wxTEXT_ATTR_FONT
)))
4612 destStyle
.SetFont(style
.GetFont());
4613 else if (style
.GetFont().Ok())
4615 wxFont font
= destStyle
.GetFont();
4617 if (style
.GetFlags() & wxTEXT_ATTR_FONT_FACE
)
4618 font
.SetFaceName(style
.GetFont().GetFaceName());
4620 if (style
.GetFlags() & wxTEXT_ATTR_FONT_SIZE
)
4621 font
.SetPointSize(style
.GetFont().GetPointSize());
4623 if (style
.GetFlags() & wxTEXT_ATTR_FONT_ITALIC
)
4624 font
.SetStyle(style
.GetFont().GetStyle());
4626 if (style
.GetFlags() & wxTEXT_ATTR_FONT_WEIGHT
)
4627 font
.SetWeight(style
.GetFont().GetWeight());
4629 if (style
.GetFlags() & wxTEXT_ATTR_FONT_UNDERLINE
)
4630 font
.SetUnderlined(style
.GetFont().GetUnderlined());
4632 if (font
!= destStyle
.GetFont())
4633 destStyle
.SetFont(font
);
4636 if ( style
.GetTextColour().Ok() && style
.HasTextColour())
4637 destStyle
.SetTextColour(style
.GetTextColour());
4639 if ( style
.GetBackgroundColour().Ok() && style
.HasBackgroundColour())
4640 destStyle
.SetBackgroundColour(style
.GetBackgroundColour());
4642 if (style
.HasAlignment())
4643 destStyle
.SetAlignment(style
.GetAlignment());
4645 if (style
.HasTabs())
4646 destStyle
.SetTabs(style
.GetTabs());
4648 if (style
.HasLeftIndent())
4649 destStyle
.SetLeftIndent(style
.GetLeftIndent(), style
.GetLeftSubIndent());
4651 if (style
.HasRightIndent())
4652 destStyle
.SetRightIndent(style
.GetRightIndent());
4654 if (style
.HasParagraphSpacingAfter())
4655 destStyle
.SetParagraphSpacingAfter(style
.GetParagraphSpacingAfter());
4657 if (style
.HasParagraphSpacingBefore())
4658 destStyle
.SetParagraphSpacingBefore(style
.GetParagraphSpacingBefore());
4660 if (style
.HasLineSpacing())
4661 destStyle
.SetLineSpacing(style
.GetLineSpacing());
4663 if (style
.HasCharacterStyleName())
4664 destStyle
.SetCharacterStyleName(style
.GetCharacterStyleName());
4666 if (style
.HasParagraphStyleName())
4667 destStyle
.SetParagraphStyleName(style
.GetParagraphStyleName());
4669 if (style
.HasBulletStyle())
4671 destStyle
.SetBulletStyle(style
.GetBulletStyle());
4672 destStyle
.SetBulletSymbol(style
.GetBulletSymbol());
4675 if (style
.HasBulletNumber())
4676 destStyle
.SetBulletNumber(style
.GetBulletNumber());
4681 bool wxRichTextApplyStyle(wxRichTextAttr
& destStyle
, const wxTextAttrEx
& style
)
4683 wxTextAttrEx destStyle2
;
4684 destStyle
.CopyTo(destStyle2
);
4685 wxRichTextApplyStyle(destStyle2
, style
);
4686 destStyle
= destStyle2
;
4690 bool wxRichTextApplyStyle(wxTextAttrEx
& destStyle
, const wxRichTextAttr
& style
)
4693 // Whole font. Avoiding setting individual attributes if possible, since
4694 // it recreates the font each time.
4695 if ((style
.GetFlags() & (wxTEXT_ATTR_FONT
)) == (wxTEXT_ATTR_FONT
))
4697 destStyle
.SetFont(wxFont(style
.GetFontSize(), destStyle
.GetFont().Ok() ? destStyle
.GetFont().GetFamily() : wxDEFAULT
,
4698 style
.GetFontStyle(), style
.GetFontWeight(), style
.GetFontUnderlined(), style
.GetFontFaceName()));
4700 else if (style
.GetFlags() & (wxTEXT_ATTR_FONT
))
4702 wxFont font
= destStyle
.GetFont();
4704 if (style
.GetFlags() & wxTEXT_ATTR_FONT_FACE
)
4705 font
.SetFaceName(style
.GetFontFaceName());
4707 if (style
.GetFlags() & wxTEXT_ATTR_FONT_SIZE
)
4708 font
.SetPointSize(style
.GetFontSize());
4710 if (style
.GetFlags() & wxTEXT_ATTR_FONT_ITALIC
)
4711 font
.SetStyle(style
.GetFontStyle());
4713 if (style
.GetFlags() & wxTEXT_ATTR_FONT_WEIGHT
)
4714 font
.SetWeight(style
.GetFontWeight());
4716 if (style
.GetFlags() & wxTEXT_ATTR_FONT_UNDERLINE
)
4717 font
.SetUnderlined(style
.GetFontUnderlined());
4719 if (font
!= destStyle
.GetFont())
4720 destStyle
.SetFont(font
);
4723 if ( style
.GetTextColour().Ok() && style
.HasTextColour())
4724 destStyle
.SetTextColour(style
.GetTextColour());
4726 if ( style
.GetBackgroundColour().Ok() && style
.HasBackgroundColour())
4727 destStyle
.SetBackgroundColour(style
.GetBackgroundColour());
4729 if (style
.HasAlignment())
4730 destStyle
.SetAlignment(style
.GetAlignment());
4732 if (style
.HasTabs())
4733 destStyle
.SetTabs(style
.GetTabs());
4735 if (style
.HasLeftIndent())
4736 destStyle
.SetLeftIndent(style
.GetLeftIndent(), style
.GetLeftSubIndent());
4738 if (style
.HasRightIndent())
4739 destStyle
.SetRightIndent(style
.GetRightIndent());
4741 if (style
.HasParagraphSpacingAfter())
4742 destStyle
.SetParagraphSpacingAfter(style
.GetParagraphSpacingAfter());
4744 if (style
.HasParagraphSpacingBefore())
4745 destStyle
.SetParagraphSpacingBefore(style
.GetParagraphSpacingBefore());
4747 if (style
.HasLineSpacing())
4748 destStyle
.SetLineSpacing(style
.GetLineSpacing());
4750 if (style
.HasCharacterStyleName())
4751 destStyle
.SetCharacterStyleName(style
.GetCharacterStyleName());
4753 if (style
.HasParagraphStyleName())
4754 destStyle
.SetParagraphStyleName(style
.GetParagraphStyleName());
4756 if (style
.HasBulletStyle())
4758 destStyle
.SetBulletStyle(style
.GetBulletStyle());
4759 destStyle
.SetBulletSymbol(style
.GetBulletSymbol());
4762 if (style
.HasBulletNumber())
4763 destStyle
.SetBulletNumber(style
.GetBulletNumber());
4770 * wxRichTextAttr stores attributes without a wxFont object, so is a much more
4771 * efficient way to query styles.
4775 wxRichTextAttr::wxRichTextAttr(const wxColour
& colText
,
4776 const wxColour
& colBack
,
4777 wxTextAttrAlignment alignment
): m_textAlignment(alignment
), m_colText(colText
), m_colBack(colBack
)
4781 if (m_colText
.Ok()) m_flags
|= wxTEXT_ATTR_TEXT_COLOUR
;
4782 if (m_colBack
.Ok()) m_flags
|= wxTEXT_ATTR_BACKGROUND_COLOUR
;
4783 if (alignment
!= wxTEXT_ALIGNMENT_DEFAULT
)
4784 m_flags
|= wxTEXT_ATTR_ALIGNMENT
;
4787 wxRichTextAttr::wxRichTextAttr(const wxTextAttrEx
& attr
)
4795 void wxRichTextAttr::Init()
4797 m_textAlignment
= wxTEXT_ALIGNMENT_DEFAULT
;
4800 m_leftSubIndent
= 0;
4804 m_fontStyle
= wxNORMAL
;
4805 m_fontWeight
= wxNORMAL
;
4806 m_fontUnderlined
= false;
4808 m_paragraphSpacingAfter
= 0;
4809 m_paragraphSpacingBefore
= 0;
4811 m_bulletStyle
= wxTEXT_ATTR_BULLET_STYLE_NONE
;
4813 m_bulletSymbol
= wxT('*');
4817 void wxRichTextAttr::operator= (const wxRichTextAttr
& attr
)
4819 m_colText
= attr
.m_colText
;
4820 m_colBack
= attr
.m_colBack
;
4821 m_textAlignment
= attr
.m_textAlignment
;
4822 m_leftIndent
= attr
.m_leftIndent
;
4823 m_leftSubIndent
= attr
.m_leftSubIndent
;
4824 m_rightIndent
= attr
.m_rightIndent
;
4825 m_tabs
= attr
.m_tabs
;
4826 m_flags
= attr
.m_flags
;
4828 m_fontSize
= attr
.m_fontSize
;
4829 m_fontStyle
= attr
.m_fontStyle
;
4830 m_fontWeight
= attr
.m_fontWeight
;
4831 m_fontUnderlined
= attr
.m_fontUnderlined
;
4832 m_fontFaceName
= attr
.m_fontFaceName
;
4834 m_paragraphSpacingAfter
= attr
.m_paragraphSpacingAfter
;
4835 m_paragraphSpacingBefore
= attr
.m_paragraphSpacingBefore
;
4836 m_lineSpacing
= attr
.m_lineSpacing
;
4837 m_characterStyleName
= attr
.m_characterStyleName
;
4838 m_paragraphStyleName
= attr
.m_paragraphStyleName
;
4839 m_bulletStyle
= attr
.m_bulletStyle
;
4840 m_bulletNumber
= attr
.m_bulletNumber
;
4841 m_bulletSymbol
= attr
.m_bulletSymbol
;
4845 void wxRichTextAttr::operator= (const wxTextAttrEx
& attr
)
4847 m_colText
= attr
.GetTextColour();
4848 m_colBack
= attr
.GetBackgroundColour();
4849 m_textAlignment
= attr
.GetAlignment();
4850 m_leftIndent
= attr
.GetLeftIndent();
4851 m_leftSubIndent
= attr
.GetLeftSubIndent();
4852 m_rightIndent
= attr
.GetRightIndent();
4853 m_tabs
= attr
.GetTabs();
4854 m_flags
= attr
.GetFlags();
4856 m_paragraphSpacingAfter
= attr
.GetParagraphSpacingAfter();
4857 m_paragraphSpacingBefore
= attr
.GetParagraphSpacingBefore();
4858 m_lineSpacing
= attr
.GetLineSpacing();
4859 m_characterStyleName
= attr
.GetCharacterStyleName();
4860 m_paragraphStyleName
= attr
.GetParagraphStyleName();
4862 if (attr
.GetFont().Ok())
4863 GetFontAttributes(attr
.GetFont());
4866 // Making a wxTextAttrEx object.
4867 wxRichTextAttr::operator wxTextAttrEx () const
4874 // Copy to a wxTextAttr
4875 void wxRichTextAttr::CopyTo(wxTextAttrEx
& attr
) const
4877 attr
.SetTextColour(GetTextColour());
4878 attr
.SetBackgroundColour(GetBackgroundColour());
4879 attr
.SetAlignment(GetAlignment());
4880 attr
.SetTabs(GetTabs());
4881 attr
.SetLeftIndent(GetLeftIndent(), GetLeftSubIndent());
4882 attr
.SetRightIndent(GetRightIndent());
4883 attr
.SetFont(CreateFont());
4884 attr
.SetFlags(GetFlags()); // Important: set after SetFont, since SetFont sets flags
4886 attr
.SetParagraphSpacingAfter(m_paragraphSpacingAfter
);
4887 attr
.SetParagraphSpacingBefore(m_paragraphSpacingBefore
);
4888 attr
.SetLineSpacing(m_lineSpacing
);
4889 attr
.SetBulletStyle(m_bulletStyle
);
4890 attr
.SetBulletNumber(m_bulletNumber
);
4891 attr
.SetBulletSymbol(m_bulletSymbol
);
4892 attr
.SetCharacterStyleName(m_characterStyleName
);
4893 attr
.SetParagraphStyleName(m_paragraphStyleName
);
4897 // Create font from font attributes.
4898 wxFont
wxRichTextAttr::CreateFont() const
4900 wxFont
font(m_fontSize
, wxDEFAULT
, m_fontStyle
, m_fontWeight
, m_fontUnderlined
, m_fontFaceName
);
4902 font
.SetNoAntiAliasing(true);
4907 // Get attributes from font.
4908 bool wxRichTextAttr::GetFontAttributes(const wxFont
& font
)
4913 m_fontSize
= font
.GetPointSize();
4914 m_fontStyle
= font
.GetStyle();
4915 m_fontWeight
= font
.GetWeight();
4916 m_fontUnderlined
= font
.GetUnderlined();
4917 m_fontFaceName
= font
.GetFaceName();
4922 wxRichTextAttr
wxRichTextAttr::Combine(const wxRichTextAttr
& attr
,
4923 const wxRichTextAttr
& attrDef
,
4924 const wxTextCtrlBase
*text
)
4926 wxColour colFg
= attr
.GetTextColour();
4929 colFg
= attrDef
.GetTextColour();
4931 if ( text
&& !colFg
.Ok() )
4932 colFg
= text
->GetForegroundColour();
4935 wxColour colBg
= attr
.GetBackgroundColour();
4938 colBg
= attrDef
.GetBackgroundColour();
4940 if ( text
&& !colBg
.Ok() )
4941 colBg
= text
->GetBackgroundColour();
4944 wxRichTextAttr
newAttr(colFg
, colBg
);
4946 if (attr
.HasWeight())
4947 newAttr
.SetFontWeight(attr
.GetFontWeight());
4950 newAttr
.SetFontSize(attr
.GetFontSize());
4952 if (attr
.HasItalic())
4953 newAttr
.SetFontStyle(attr
.GetFontStyle());
4955 if (attr
.HasUnderlined())
4956 newAttr
.SetFontUnderlined(attr
.GetFontUnderlined());
4958 if (attr
.HasFaceName())
4959 newAttr
.SetFontFaceName(attr
.GetFontFaceName());
4961 if (attr
.HasAlignment())
4962 newAttr
.SetAlignment(attr
.GetAlignment());
4963 else if (attrDef
.HasAlignment())
4964 newAttr
.SetAlignment(attrDef
.GetAlignment());
4967 newAttr
.SetTabs(attr
.GetTabs());
4968 else if (attrDef
.HasTabs())
4969 newAttr
.SetTabs(attrDef
.GetTabs());
4971 if (attr
.HasLeftIndent())
4972 newAttr
.SetLeftIndent(attr
.GetLeftIndent(), attr
.GetLeftSubIndent());
4973 else if (attrDef
.HasLeftIndent())
4974 newAttr
.SetLeftIndent(attrDef
.GetLeftIndent(), attr
.GetLeftSubIndent());
4976 if (attr
.HasRightIndent())
4977 newAttr
.SetRightIndent(attr
.GetRightIndent());
4978 else if (attrDef
.HasRightIndent())
4979 newAttr
.SetRightIndent(attrDef
.GetRightIndent());
4983 if (attr
.HasParagraphSpacingAfter())
4984 newAttr
.SetParagraphSpacingAfter(attr
.GetParagraphSpacingAfter());
4986 if (attr
.HasParagraphSpacingBefore())
4987 newAttr
.SetParagraphSpacingBefore(attr
.GetParagraphSpacingBefore());
4989 if (attr
.HasLineSpacing())
4990 newAttr
.SetLineSpacing(attr
.GetLineSpacing());
4992 if (attr
.HasCharacterStyleName())
4993 newAttr
.SetCharacterStyleName(attr
.GetCharacterStyleName());
4995 if (attr
.HasParagraphStyleName())
4996 newAttr
.SetParagraphStyleName(attr
.GetParagraphStyleName());
4998 if (attr
.HasBulletStyle())
4999 newAttr
.SetBulletStyle(attr
.GetBulletStyle());
5001 if (attr
.HasBulletNumber())
5002 newAttr
.SetBulletNumber(attr
.GetBulletNumber());
5004 if (attr
.HasBulletSymbol())
5005 newAttr
.SetBulletSymbol(attr
.GetBulletSymbol());
5011 * wxTextAttrEx is an extended version of wxTextAttr with more paragraph attributes.
5014 wxTextAttrEx::wxTextAttrEx(const wxTextAttrEx
& attr
): wxTextAttr(attr
)
5016 m_paragraphSpacingAfter
= attr
.m_paragraphSpacingAfter
;
5017 m_paragraphSpacingBefore
= attr
.m_paragraphSpacingBefore
;
5018 m_lineSpacing
= attr
.m_lineSpacing
;
5019 m_paragraphStyleName
= attr
.m_paragraphStyleName
;
5020 m_characterStyleName
= attr
.m_characterStyleName
;
5021 m_bulletStyle
= attr
.m_bulletStyle
;
5022 m_bulletNumber
= attr
.m_bulletNumber
;
5023 m_bulletSymbol
= attr
.m_bulletSymbol
;
5026 // Initialise this object.
5027 void wxTextAttrEx::Init()
5029 m_paragraphSpacingAfter
= 0;
5030 m_paragraphSpacingBefore
= 0;
5032 m_bulletStyle
= wxTEXT_ATTR_BULLET_STYLE_NONE
;
5035 m_bulletSymbol
= wxT('*');
5038 // Assignment from a wxTextAttrEx object
5039 void wxTextAttrEx::operator= (const wxTextAttrEx
& attr
)
5041 wxTextAttr::operator= (attr
);
5043 m_paragraphSpacingAfter
= attr
.m_paragraphSpacingAfter
;
5044 m_paragraphSpacingBefore
= attr
.m_paragraphSpacingBefore
;
5045 m_lineSpacing
= attr
.m_lineSpacing
;
5046 m_characterStyleName
= attr
.m_characterStyleName
;
5047 m_paragraphStyleName
= attr
.m_paragraphStyleName
;
5048 m_bulletStyle
= attr
.m_bulletStyle
;
5049 m_bulletNumber
= attr
.m_bulletNumber
;
5050 m_bulletSymbol
= attr
.m_bulletSymbol
;
5053 // Assignment from a wxTextAttr object.
5054 void wxTextAttrEx::operator= (const wxTextAttr
& attr
)
5056 wxTextAttr::operator= (attr
);
5059 wxTextAttrEx
wxTextAttrEx::CombineEx(const wxTextAttrEx
& attr
,
5060 const wxTextAttrEx
& attrDef
,
5061 const wxTextCtrlBase
*text
)
5063 wxTextAttrEx newAttr
;
5065 // If attr specifies the complete font, just use that font, overriding all
5066 // default font attributes.
5067 if ((attr
.GetFlags() & wxTEXT_ATTR_FONT
) == wxTEXT_ATTR_FONT
)
5068 newAttr
.SetFont(attr
.GetFont());
5071 // First find the basic, default font
5075 if (attrDef
.HasFont())
5077 flags
= (attrDef
.GetFlags() & wxTEXT_ATTR_FONT
);
5078 font
= attrDef
.GetFont();
5083 font
= text
->GetFont();
5085 // We leave flags at 0 because no font attributes have been specified yet
5088 font
= *wxNORMAL_FONT
;
5090 // Otherwise, if there are font attributes in attr, apply them
5095 flags
|= wxTEXT_ATTR_FONT_SIZE
;
5096 font
.SetPointSize(attr
.GetFont().GetPointSize());
5098 if (attr
.HasItalic())
5100 flags
|= wxTEXT_ATTR_FONT_ITALIC
;;
5101 font
.SetStyle(attr
.GetFont().GetStyle());
5103 if (attr
.HasWeight())
5105 flags
|= wxTEXT_ATTR_FONT_WEIGHT
;
5106 font
.SetWeight(attr
.GetFont().GetWeight());
5108 if (attr
.HasFaceName())
5110 flags
|= wxTEXT_ATTR_FONT_FACE
;
5111 font
.SetFaceName(attr
.GetFont().GetFaceName());
5113 if (attr
.HasUnderlined())
5115 flags
|= wxTEXT_ATTR_FONT_UNDERLINE
;
5116 font
.SetUnderlined(attr
.GetFont().GetUnderlined());
5118 newAttr
.SetFont(font
);
5119 newAttr
.SetFlags(newAttr
.GetFlags()|flags
);
5123 // TODO: should really check we are specifying these in the flags,
5124 // before setting them, as per above; or we will set them willy-nilly.
5125 // However, we should also check whether this is the intention
5126 // as per wxTextAttr::Combine, i.e. always to have valid colours
5128 wxColour colFg
= attr
.GetTextColour();
5131 colFg
= attrDef
.GetTextColour();
5133 if ( text
&& !colFg
.Ok() )
5134 colFg
= text
->GetForegroundColour();
5137 wxColour colBg
= attr
.GetBackgroundColour();
5140 colBg
= attrDef
.GetBackgroundColour();
5142 if ( text
&& !colBg
.Ok() )
5143 colBg
= text
->GetBackgroundColour();
5146 newAttr
.SetTextColour(colFg
);
5147 newAttr
.SetBackgroundColour(colBg
);
5149 if (attr
.HasAlignment())
5150 newAttr
.SetAlignment(attr
.GetAlignment());
5151 else if (attrDef
.HasAlignment())
5152 newAttr
.SetAlignment(attrDef
.GetAlignment());
5155 newAttr
.SetTabs(attr
.GetTabs());
5156 else if (attrDef
.HasTabs())
5157 newAttr
.SetTabs(attrDef
.GetTabs());
5159 if (attr
.HasLeftIndent())
5160 newAttr
.SetLeftIndent(attr
.GetLeftIndent(), attr
.GetLeftSubIndent());
5161 else if (attrDef
.HasLeftIndent())
5162 newAttr
.SetLeftIndent(attrDef
.GetLeftIndent(), attr
.GetLeftSubIndent());
5164 if (attr
.HasRightIndent())
5165 newAttr
.SetRightIndent(attr
.GetRightIndent());
5166 else if (attrDef
.HasRightIndent())
5167 newAttr
.SetRightIndent(attrDef
.GetRightIndent());
5171 if (attr
.HasParagraphSpacingAfter())
5172 newAttr
.SetParagraphSpacingAfter(attr
.GetParagraphSpacingAfter());
5174 if (attr
.HasParagraphSpacingBefore())
5175 newAttr
.SetParagraphSpacingBefore(attr
.GetParagraphSpacingBefore());
5177 if (attr
.HasLineSpacing())
5178 newAttr
.SetLineSpacing(attr
.GetLineSpacing());
5180 if (attr
.HasCharacterStyleName())
5181 newAttr
.SetCharacterStyleName(attr
.GetCharacterStyleName());
5183 if (attr
.HasParagraphStyleName())
5184 newAttr
.SetParagraphStyleName(attr
.GetParagraphStyleName());
5186 if (attr
.HasBulletStyle())
5187 newAttr
.SetBulletStyle(attr
.GetBulletStyle());
5189 if (attr
.HasBulletNumber())
5190 newAttr
.SetBulletNumber(attr
.GetBulletNumber());
5192 if (attr
.HasBulletSymbol())
5193 newAttr
.SetBulletSymbol(attr
.GetBulletSymbol());
5200 * wxRichTextFileHandler
5201 * Base class for file handlers
5204 IMPLEMENT_CLASS(wxRichTextFileHandler
, wxObject
)
5207 bool wxRichTextFileHandler::LoadFile(wxRichTextBuffer
*buffer
, const wxString
& filename
)
5209 wxFFileInputStream
stream(filename
);
5211 return LoadFile(buffer
, stream
);
5216 bool wxRichTextFileHandler::SaveFile(wxRichTextBuffer
*buffer
, const wxString
& filename
)
5218 wxFFileOutputStream
stream(filename
);
5220 return SaveFile(buffer
, stream
);
5224 #endif // wxUSE_STREAMS
5226 /// Can we handle this filename (if using files)? By default, checks the extension.
5227 bool wxRichTextFileHandler::CanHandle(const wxString
& filename
) const
5229 wxString path
, file
, ext
;
5230 wxSplitPath(filename
, & path
, & file
, & ext
);
5232 return (ext
.Lower() == GetExtension());
5236 * wxRichTextTextHandler
5237 * Plain text handler
5240 IMPLEMENT_CLASS(wxRichTextPlainTextHandler
, wxRichTextFileHandler
)
5243 bool wxRichTextPlainTextHandler::DoLoadFile(wxRichTextBuffer
*buffer
, wxInputStream
& stream
)
5251 while (!stream
.Eof())
5253 int ch
= stream
.GetC();
5257 if (ch
== 10 && lastCh
!= 13)
5260 if (ch
> 0 && ch
!= 10)
5268 buffer
->AddParagraphs(str
);
5269 buffer
->UpdateRanges();
5275 bool wxRichTextPlainTextHandler::DoSaveFile(wxRichTextBuffer
*buffer
, wxOutputStream
& stream
)
5280 wxString text
= buffer
->GetText();
5281 wxCharBuffer buf
= text
.ToAscii();
5283 stream
.Write((const char*) buf
, text
.Length());
5286 #endif // wxUSE_STREAMS
5289 * Stores information about an image, in binary in-memory form
5292 wxRichTextImageBlock::wxRichTextImageBlock()
5297 wxRichTextImageBlock::wxRichTextImageBlock(const wxRichTextImageBlock
& block
):wxObject()
5303 wxRichTextImageBlock::~wxRichTextImageBlock()
5312 void wxRichTextImageBlock::Init()
5319 void wxRichTextImageBlock::Clear()
5328 // Load the original image into a memory block.
5329 // If the image is not a JPEG, we must convert it into a JPEG
5330 // to conserve space.
5331 // If it's not a JPEG we can make use of 'image', already scaled, so we don't have to
5332 // load the image a 2nd time.
5334 bool wxRichTextImageBlock::MakeImageBlock(const wxString
& filename
, int imageType
, wxImage
& image
, bool convertToJPEG
)
5336 m_imageType
= imageType
;
5338 wxString
filenameToRead(filename
);
5339 bool removeFile
= false;
5341 if (imageType
== -1)
5342 return false; // Could not determine image type
5344 if ((imageType
!= wxBITMAP_TYPE_JPEG
) && convertToJPEG
)
5347 bool success
= wxGetTempFileName(_("image"), tempFile
) ;
5351 wxUnusedVar(success
);
5353 image
.SaveFile(tempFile
, wxBITMAP_TYPE_JPEG
);
5354 filenameToRead
= tempFile
;
5357 m_imageType
= wxBITMAP_TYPE_JPEG
;
5360 if (!file
.Open(filenameToRead
))
5363 m_dataSize
= (size_t) file
.Length();
5368 m_data
= ReadBlock(filenameToRead
, m_dataSize
);
5371 wxRemoveFile(filenameToRead
);
5373 return (m_data
!= NULL
);
5376 // Make an image block from the wxImage in the given
5378 bool wxRichTextImageBlock::MakeImageBlock(wxImage
& image
, int imageType
, int quality
)
5380 m_imageType
= imageType
;
5381 image
.SetOption(wxT("quality"), quality
);
5383 if (imageType
== -1)
5384 return false; // Could not determine image type
5387 bool success
= wxGetTempFileName(_("image"), tempFile
) ;
5390 wxUnusedVar(success
);
5392 if (!image
.SaveFile(tempFile
, m_imageType
))
5394 if (wxFileExists(tempFile
))
5395 wxRemoveFile(tempFile
);
5400 if (!file
.Open(tempFile
))
5403 m_dataSize
= (size_t) file
.Length();
5408 m_data
= ReadBlock(tempFile
, m_dataSize
);
5410 wxRemoveFile(tempFile
);
5412 return (m_data
!= NULL
);
5417 bool wxRichTextImageBlock::Write(const wxString
& filename
)
5419 return WriteBlock(filename
, m_data
, m_dataSize
);
5422 void wxRichTextImageBlock::Copy(const wxRichTextImageBlock
& block
)
5424 m_imageType
= block
.m_imageType
;
5430 m_dataSize
= block
.m_dataSize
;
5431 if (m_dataSize
== 0)
5434 m_data
= new unsigned char[m_dataSize
];
5436 for (i
= 0; i
< m_dataSize
; i
++)
5437 m_data
[i
] = block
.m_data
[i
];
5441 void wxRichTextImageBlock::operator=(const wxRichTextImageBlock
& block
)
5446 // Load a wxImage from the block
5447 bool wxRichTextImageBlock::Load(wxImage
& image
)
5452 // Read in the image.
5454 wxMemoryInputStream
mstream(m_data
, m_dataSize
);
5455 bool success
= image
.LoadFile(mstream
, GetImageType());
5458 bool success
= wxGetTempFileName(_("image"), tempFile
) ;
5461 if (!WriteBlock(tempFile
, m_data
, m_dataSize
))
5465 success
= image
.LoadFile(tempFile
, GetImageType());
5466 wxRemoveFile(tempFile
);
5472 // Write data in hex to a stream
5473 bool wxRichTextImageBlock::WriteHex(wxOutputStream
& stream
)
5477 for (i
= 0; i
< (int) m_dataSize
; i
++)
5479 hex
= wxDecToHex(m_data
[i
]);
5480 wxCharBuffer buf
= hex
.ToAscii();
5482 stream
.Write((const char*) buf
, hex
.Length());
5488 // Read data in hex from a stream
5489 bool wxRichTextImageBlock::ReadHex(wxInputStream
& stream
, int length
, int imageType
)
5491 int dataSize
= length
/2;
5496 wxString
str(wxT(" "));
5497 m_data
= new unsigned char[dataSize
];
5499 for (i
= 0; i
< dataSize
; i
++)
5501 str
[0] = stream
.GetC();
5502 str
[1] = stream
.GetC();
5504 m_data
[i
] = (unsigned char)wxHexToDec(str
);
5507 m_dataSize
= dataSize
;
5508 m_imageType
= imageType
;
5514 // Allocate and read from stream as a block of memory
5515 unsigned char* wxRichTextImageBlock::ReadBlock(wxInputStream
& stream
, size_t size
)
5517 unsigned char* block
= new unsigned char[size
];
5521 stream
.Read(block
, size
);
5526 unsigned char* wxRichTextImageBlock::ReadBlock(const wxString
& filename
, size_t size
)
5528 wxFileInputStream
stream(filename
);
5532 return ReadBlock(stream
, size
);
5535 // Write memory block to stream
5536 bool wxRichTextImageBlock::WriteBlock(wxOutputStream
& stream
, unsigned char* block
, size_t size
)
5538 stream
.Write((void*) block
, size
);
5539 return stream
.IsOk();
5543 // Write memory block to file
5544 bool wxRichTextImageBlock::WriteBlock(const wxString
& filename
, unsigned char* block
, size_t size
)
5546 wxFileOutputStream
outStream(filename
);
5547 if (!outStream
.Ok())
5550 return WriteBlock(outStream
, block
, size
);