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