]> git.saurik.com Git - wxWidgets.git/blob - include/wx/richtext/richtextbuffer.h
enum wxWebViewBackend has been removed.
[wxWidgets.git] / include / wx / richtext / richtextbuffer.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/richtext/richtextbuffer.h
3 // Purpose: Buffer for wxRichTextCtrl
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 2005-09-30
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifndef _WX_RICHTEXTBUFFER_H_
13 #define _WX_RICHTEXTBUFFER_H_
14
15 /*
16
17 Data structures
18 ===============
19
20 Data is represented by a hierarchy of objects, all derived from
21 wxRichTextObject.
22
23 The top of the hierarchy is the buffer, a kind of wxRichTextParagraphLayoutBox.
24 These boxes will allow flexible placement of text boxes on a page, but
25 for now there is a single box representing the document, and this box is
26 a wxRichTextParagraphLayoutBox which contains further wxRichTextParagraph
27 objects, each of which can include text and images.
28
29 Each object maintains a range (start and end position) measured
30 from the start of the main parent box.
31 A paragraph object knows its range, and a text fragment knows its range
32 too. So, a character or image in a page has a position relative to the
33 start of the document, and a character in an embedded text box has
34 a position relative to that text box. For now, we will not be dealing with
35 embedded objects but it's something to bear in mind for later.
36
37 Note that internally, a range (5,5) represents a range of one character.
38 In the public wx[Rich]TextCtrl API, this would be passed to e.g. SetSelection
39 as (5,6). A paragraph with one character might have an internal range of (0, 1)
40 since the end of the paragraph takes up one position.
41
42 Layout
43 ======
44
45 When Layout is called on an object, it is given a size which the object
46 must limit itself to, or one or more flexible directions (vertical
47 or horizontal). So for example a centered paragraph is given the page
48 width to play with (minus any margins), but can extend indefinitely
49 in the vertical direction. The implementation of Layout can then
50 cache the calculated size and position within the parent.
51
52 */
53
54 /*!
55 * Includes
56 */
57
58 #include "wx/defs.h"
59
60 #if wxUSE_RICHTEXT
61
62 #include "wx/list.h"
63 #include "wx/textctrl.h"
64 #include "wx/bitmap.h"
65 #include "wx/image.h"
66 #include "wx/cmdproc.h"
67 #include "wx/txtstrm.h"
68 #include "wx/variant.h"
69
70 #if wxUSE_DATAOBJ
71 #include "wx/dataobj.h"
72 #endif
73
74 // Compatibility
75 //#define wxRichTextAttr wxTextAttr
76 #define wxTextAttrEx wxTextAttr
77
78 // Setting wxRICHTEXT_USE_OWN_CARET to 1 implements a
79 // caret reliably without using wxClientDC in case there
80 // are platform-specific problems with the generic caret.
81 #if defined(__WXGTK__) || defined(__WXMAC__)
82 #define wxRICHTEXT_USE_OWN_CARET 1
83 #else
84 #define wxRICHTEXT_USE_OWN_CARET 0
85 #endif
86
87 // Switch off for binary compatibility, on for faster drawing
88 // Note: this seems to be buggy (overzealous use of extents) so
89 // don't use for now
90 #define wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING 0
91
92 // The following two symbols determine whether an output implementation
93 // is present. To switch the relevant one on, set wxRICHTEXT_USE_XMLDOCUMENT_OUTPUT in
94 // richtextxml.cpp. By default, the faster direct output implementation is used.
95
96 // Include the wxXmlDocument implementation for output
97 #define wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT 1
98
99 // Include the faster, direct implementation for output
100 #define wxRICHTEXT_HAVE_DIRECT_OUTPUT 1
101
102 /**
103 The line break character that can be embedded in content.
104 */
105
106 extern WXDLLIMPEXP_RICHTEXT const wxChar wxRichTextLineBreakChar;
107
108 /**
109 File types in wxRichText context.
110 */
111 enum wxRichTextFileType
112 {
113 wxRICHTEXT_TYPE_ANY = 0,
114 wxRICHTEXT_TYPE_TEXT,
115 wxRICHTEXT_TYPE_XML,
116 wxRICHTEXT_TYPE_HTML,
117 wxRICHTEXT_TYPE_RTF,
118 wxRICHTEXT_TYPE_PDF
119 };
120
121 /*
122 * Forward declarations
123 */
124
125 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextCtrl;
126 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextObject;
127 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextImage;
128 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextCacheObject;
129 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextObjectList;
130 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextLine;
131 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextParagraph;
132 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextFileHandler;
133 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextDrawingHandler;
134 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextField;
135 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextFieldType;
136 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextStyleSheet;
137 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextListStyleDefinition;
138 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextEvent;
139 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextRenderer;
140 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextBuffer;
141 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextXMLHandler;
142 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextParagraphLayoutBox;
143 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextImageBlock;
144 class WXDLLIMPEXP_FWD_XML wxXmlNode;
145 class wxRichTextFloatCollector;
146 class WXDLLIMPEXP_FWD_BASE wxDataInputStream;
147 class WXDLLIMPEXP_FWD_BASE wxDataOutputStream;
148
149 /**
150 Flags determining the available space, passed to Layout.
151 */
152
153 #define wxRICHTEXT_FIXED_WIDTH 0x01
154 #define wxRICHTEXT_FIXED_HEIGHT 0x02
155 #define wxRICHTEXT_VARIABLE_WIDTH 0x04
156 #define wxRICHTEXT_VARIABLE_HEIGHT 0x08
157
158 // Only lay out the part of the buffer that lies within
159 // the rect passed to Layout.
160 #define wxRICHTEXT_LAYOUT_SPECIFIED_RECT 0x10
161
162 /**
163 Flags to pass to Draw
164 */
165
166 // Ignore paragraph cache optimization, e.g. for printing purposes
167 // where one line may be drawn higher (on the next page) compared
168 // with the previous line
169 #define wxRICHTEXT_DRAW_IGNORE_CACHE 0x01
170 #define wxRICHTEXT_DRAW_SELECTED 0x02
171 #define wxRICHTEXT_DRAW_PRINT 0x04
172 #define wxRICHTEXT_DRAW_GUIDELINES 0x08
173
174 /**
175 Flags returned from hit-testing, or passed to hit-test function.
176 */
177 enum wxRichTextHitTestFlags
178 {
179 // The point was not on this object
180 wxRICHTEXT_HITTEST_NONE = 0x01,
181
182 // The point was before the position returned from HitTest
183 wxRICHTEXT_HITTEST_BEFORE = 0x02,
184
185 // The point was after the position returned from HitTest
186 wxRICHTEXT_HITTEST_AFTER = 0x04,
187
188 // The point was on the position returned from HitTest
189 wxRICHTEXT_HITTEST_ON = 0x08,
190
191 // The point was on space outside content
192 wxRICHTEXT_HITTEST_OUTSIDE = 0x10,
193
194 // Only do hit-testing at the current level (don't traverse into top-level objects)
195 wxRICHTEXT_HITTEST_NO_NESTED_OBJECTS = 0x20,
196
197 // Ignore floating objects
198 wxRICHTEXT_HITTEST_NO_FLOATING_OBJECTS = 0x40,
199
200 // Don't recurse into objects marked as atomic
201 wxRICHTEXT_HITTEST_HONOUR_ATOMIC = 0x80
202 };
203
204 /**
205 Flags for GetRangeSize.
206 */
207
208 #define wxRICHTEXT_FORMATTED 0x01
209 #define wxRICHTEXT_UNFORMATTED 0x02
210 #define wxRICHTEXT_CACHE_SIZE 0x04
211 #define wxRICHTEXT_HEIGHT_ONLY 0x08
212
213 /**
214 Flags for SetStyle/SetListStyle.
215 */
216
217 #define wxRICHTEXT_SETSTYLE_NONE 0x00
218
219 // Specifies that this operation should be undoable
220 #define wxRICHTEXT_SETSTYLE_WITH_UNDO 0x01
221
222 // Specifies that the style should not be applied if the
223 // combined style at this point is already the style in question.
224 #define wxRICHTEXT_SETSTYLE_OPTIMIZE 0x02
225
226 // Specifies that the style should only be applied to paragraphs,
227 // and not the content. This allows content styling to be
228 // preserved independently from that of e.g. a named paragraph style.
229 #define wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY 0x04
230
231 // Specifies that the style should only be applied to characters,
232 // and not the paragraph. This allows content styling to be
233 // preserved independently from that of e.g. a named paragraph style.
234 #define wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY 0x08
235
236 // For SetListStyle only: specifies starting from the given number, otherwise
237 // deduces number from existing attributes
238 #define wxRICHTEXT_SETSTYLE_RENUMBER 0x10
239
240 // For SetListStyle only: specifies the list level for all paragraphs, otherwise
241 // the current indentation will be used
242 #define wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL 0x20
243
244 // Resets the existing style before applying the new style
245 #define wxRICHTEXT_SETSTYLE_RESET 0x40
246
247 // Removes the given style instead of applying it
248 #define wxRICHTEXT_SETSTYLE_REMOVE 0x80
249
250 /**
251 Flags for SetProperties.
252 */
253
254 #define wxRICHTEXT_SETPROPERTIES_NONE 0x00
255
256 // Specifies that this operation should be undoable
257 #define wxRICHTEXT_SETPROPERTIES_WITH_UNDO 0x01
258
259 // Specifies that the properties should only be applied to paragraphs,
260 // and not the content.
261 #define wxRICHTEXT_SETPROPERTIES_PARAGRAPHS_ONLY 0x02
262
263 // Specifies that the properties should only be applied to characters,
264 // and not the paragraph.
265 #define wxRICHTEXT_SETPROPERTIES_CHARACTERS_ONLY 0x04
266
267 // Resets the existing properties before applying the new properties.
268 #define wxRICHTEXT_SETPROPERTIES_RESET 0x08
269
270 // Removes the given properties instead of applying them.
271 #define wxRICHTEXT_SETPROPERTIES_REMOVE 0x10
272
273 /**
274 Flags for object insertion.
275 */
276
277 #define wxRICHTEXT_INSERT_NONE 0x00
278 #define wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE 0x01
279 #define wxRICHTEXT_INSERT_INTERACTIVE 0x02
280
281 // A special flag telling the buffer to keep the first paragraph style
282 // as-is, when deleting a paragraph marker. In future we might pass a
283 // flag to InsertFragment and DeleteRange to indicate the appropriate mode.
284 #define wxTEXT_ATTR_KEEP_FIRST_PARA_STYLE 0x20000000
285
286 /**
287 Default superscript/subscript font multiplication factor.
288 */
289
290 #define wxSCRIPT_MUL_FACTOR 1.5
291
292 /**
293 The type for wxTextAttrDimension flags.
294 */
295 typedef unsigned short wxTextAttrDimensionFlags;
296
297 /**
298 Miscellaneous text box flags
299 */
300 enum wxTextBoxAttrFlags
301 {
302 wxTEXT_BOX_ATTR_FLOAT = 0x00000001,
303 wxTEXT_BOX_ATTR_CLEAR = 0x00000002,
304 wxTEXT_BOX_ATTR_COLLAPSE_BORDERS = 0x00000004,
305 wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT = 0x00000008,
306 wxTEXT_BOX_ATTR_BOX_STYLE_NAME = 0x00000010
307 };
308
309 /**
310 Whether a value is present, used in dimension flags.
311 */
312 enum wxTextAttrValueFlags
313 {
314 wxTEXT_ATTR_VALUE_VALID = 0x1000,
315 wxTEXT_ATTR_VALUE_VALID_MASK = 0x1000
316 };
317
318 /**
319 Units, included in the dimension value.
320 */
321 enum wxTextAttrUnits
322 {
323 wxTEXT_ATTR_UNITS_TENTHS_MM = 0x0001,
324 wxTEXT_ATTR_UNITS_PIXELS = 0x0002,
325 wxTEXT_ATTR_UNITS_PERCENTAGE = 0x0004,
326 wxTEXT_ATTR_UNITS_POINTS = 0x0008,
327
328 wxTEXT_ATTR_UNITS_MASK = 0x000F
329 };
330
331 /**
332 Position alternatives, included in the dimension flags.
333 */
334 enum wxTextBoxAttrPosition
335 {
336 wxTEXT_BOX_ATTR_POSITION_STATIC = 0x0000, // Default is static, i.e. as per normal layout
337 wxTEXT_BOX_ATTR_POSITION_RELATIVE = 0x0010, // Relative to the relevant edge
338 wxTEXT_BOX_ATTR_POSITION_ABSOLUTE = 0x0020, // Relative to the parent
339 wxTEXT_BOX_ATTR_POSITION_FIXED = 0x0040, // Relative to the top-level window
340
341 wxTEXT_BOX_ATTR_POSITION_MASK = 0x00F0
342 };
343
344 /**
345 @class wxTextAttrDimension
346
347 A class representing a rich text dimension, including units and position.
348
349 @library{wxrichtext}
350 @category{richtext}
351
352 @see wxRichTextAttr, wxRichTextCtrl, wxTextAttrDimensions
353 */
354
355 class WXDLLIMPEXP_RICHTEXT wxTextAttrDimension
356 {
357 public:
358 /**
359 Default constructor.
360 */
361 wxTextAttrDimension() { Reset(); }
362 /**
363 Constructor taking value and units flag.
364 */
365 wxTextAttrDimension(int value, wxTextAttrUnits units = wxTEXT_ATTR_UNITS_TENTHS_MM) { m_value = value; m_flags = units|wxTEXT_ATTR_VALUE_VALID; }
366
367 /**
368 Resets the dimension value and flags.
369 */
370 void Reset() { m_value = 0; m_flags = 0; }
371
372 /**
373 Partial equality test. If @a weakTest is @true, attributes of this object do not
374 have to be present if those attributes of @a dim are present. If @a weakTest is
375 @false, the function will fail if an attribute is present in @a dim but not
376 in this object.
377 */
378 bool EqPartial(const wxTextAttrDimension& dim, bool weakTest = true) const;
379
380 /** Apply the dimension, but not those identical to @a compareWith if present.
381 */
382 bool Apply(const wxTextAttrDimension& dim, const wxTextAttrDimension* compareWith = NULL);
383
384 /** Collects the attributes that are common to a range of content, building up a note of
385 which attributes are absent in some objects and which clash in some objects.
386 */
387 void CollectCommonAttributes(const wxTextAttrDimension& attr, wxTextAttrDimension& clashingAttr, wxTextAttrDimension& absentAttr);
388
389 /**
390 Equality operator.
391 */
392 bool operator==(const wxTextAttrDimension& dim) const { return m_value == dim.m_value && m_flags == dim.m_flags; }
393
394 /**
395 Returns the integer value of the dimension.
396 */
397 int GetValue() const { return m_value; }
398
399 /**
400 Returns the floating-pointing value of the dimension in mm.
401
402 */
403 float GetValueMM() const { return float(m_value) / 10.0; }
404
405 /**
406 Sets the value of the dimension in mm.
407 */
408 void SetValueMM(float value) { m_value = (int) ((value * 10.0) + 0.5); m_flags |= wxTEXT_ATTR_VALUE_VALID; }
409
410 /**
411 Sets the integer value of the dimension.
412 */
413 void SetValue(int value) { m_value = value; m_flags |= wxTEXT_ATTR_VALUE_VALID; }
414
415 /**
416 Sets the integer value of the dimension, passing dimension flags.
417 */
418 void SetValue(int value, wxTextAttrDimensionFlags flags) { SetValue(value); m_flags = flags; }
419
420 /**
421 Sets the integer value and units.
422 */
423 void SetValue(int value, wxTextAttrUnits units) { m_value = value; m_flags = units | wxTEXT_ATTR_VALUE_VALID; }
424
425 /**
426 Sets the dimension.
427 */
428 void SetValue(const wxTextAttrDimension& dim) { (*this) = dim; }
429
430 /**
431 Gets the units of the dimension.
432 */
433 wxTextAttrUnits GetUnits() const { return (wxTextAttrUnits) (m_flags & wxTEXT_ATTR_UNITS_MASK); }
434
435 /**
436 Sets the units of the dimension.
437 */
438 void SetUnits(wxTextAttrUnits units) { m_flags &= ~wxTEXT_ATTR_UNITS_MASK; m_flags |= units; }
439
440 /**
441 Gets the position flags.
442 */
443 wxTextBoxAttrPosition GetPosition() const { return (wxTextBoxAttrPosition) (m_flags & wxTEXT_BOX_ATTR_POSITION_MASK); }
444
445 /**
446 Sets the position flags.
447 */
448 void SetPosition(wxTextBoxAttrPosition pos) { m_flags &= ~wxTEXT_BOX_ATTR_POSITION_MASK; m_flags |= pos; }
449
450 /**
451 Returns @true if the dimension is valid.
452 */
453 bool IsValid() const { return (m_flags & wxTEXT_ATTR_VALUE_VALID) != 0; }
454
455 /**
456 Sets the valid flag.
457 */
458 void SetValid(bool b) { m_flags &= ~wxTEXT_ATTR_VALUE_VALID_MASK; m_flags |= (b ? wxTEXT_ATTR_VALUE_VALID : 0); }
459
460 /**
461 Gets the dimension flags.
462 */
463 wxTextAttrDimensionFlags GetFlags() const { return m_flags; }
464
465 /**
466 Sets the dimension flags.
467 */
468 void SetFlags(wxTextAttrDimensionFlags flags) { m_flags = flags; }
469
470 int m_value;
471 wxTextAttrDimensionFlags m_flags;
472 };
473
474 /**
475 @class wxTextAttrDimensions
476 A class for left, right, top and bottom dimensions.
477
478 @library{wxrichtext}
479 @category{richtext}
480
481 @see wxRichTextAttr, wxRichTextCtrl, wxTextAttrDimension
482 */
483
484 class WXDLLIMPEXP_RICHTEXT wxTextAttrDimensions
485 {
486 public:
487 /**
488 Default constructor.
489 */
490 wxTextAttrDimensions() {}
491
492 /**
493 Resets the value and flags for all dimensions.
494 */
495 void Reset() { m_left.Reset(); m_top.Reset(); m_right.Reset(); m_bottom.Reset(); }
496
497 /**
498 Equality operator.
499 */
500 bool operator==(const wxTextAttrDimensions& dims) const { return m_left == dims.m_left && m_top == dims.m_top && m_right == dims.m_right && m_bottom == dims.m_bottom; }
501
502 /**
503 Partial equality test. If @a weakTest is @true, attributes of this object do not
504 have to be present if those attributes of @a dim sare present. If @a weakTest is
505 @false, the function will fail if an attribute is present in @a dims but not
506 in this object.
507
508 */
509 bool EqPartial(const wxTextAttrDimensions& dims, bool weakTest = true) const;
510
511 /**
512 Apply to 'this', but not if the same as @a compareWith.
513
514 */
515 bool Apply(const wxTextAttrDimensions& dims, const wxTextAttrDimensions* compareWith = NULL);
516
517 /**
518 Collects the attributes that are common to a range of content, building up a note of
519 which attributes are absent in some objects and which clash in some objects.
520
521 */
522 void CollectCommonAttributes(const wxTextAttrDimensions& attr, wxTextAttrDimensions& clashingAttr, wxTextAttrDimensions& absentAttr);
523
524 /**
525 Remove specified attributes from this object.
526 */
527 bool RemoveStyle(const wxTextAttrDimensions& attr);
528
529 /**
530 Gets the left dimension.
531 */
532 const wxTextAttrDimension& GetLeft() const { return m_left; }
533 wxTextAttrDimension& GetLeft() { return m_left; }
534
535 /**
536 Gets the right dimension.
537
538 */
539 const wxTextAttrDimension& GetRight() const { return m_right; }
540 wxTextAttrDimension& GetRight() { return m_right; }
541
542 /**
543 Gets the top dimension.
544
545 */
546 const wxTextAttrDimension& GetTop() const { return m_top; }
547 wxTextAttrDimension& GetTop() { return m_top; }
548
549 /**
550 Gets the bottom dimension.
551
552 */
553 const wxTextAttrDimension& GetBottom() const { return m_bottom; }
554 wxTextAttrDimension& GetBottom() { return m_bottom; }
555
556 /**
557 Are all dimensions valid?
558
559 */
560 bool IsValid() const { return m_left.IsValid() && m_top.IsValid() && m_right.IsValid() && m_bottom.IsValid(); }
561
562 wxTextAttrDimension m_left;
563 wxTextAttrDimension m_top;
564 wxTextAttrDimension m_right;
565 wxTextAttrDimension m_bottom;
566 };
567
568 /**
569 @class wxTextAttrSize
570 A class for representing width and height.
571
572 @library{wxrichtext}
573 @category{richtext}
574
575 @see wxRichTextAttr, wxRichTextCtrl, wxTextAttrDimension
576 */
577
578 class WXDLLIMPEXP_RICHTEXT wxTextAttrSize
579 {
580 public:
581 /**
582 Default constructor.
583 */
584 wxTextAttrSize() {}
585
586 /**
587 Resets the width and height dimensions.
588 */
589 void Reset() { m_width.Reset(); m_height.Reset(); }
590
591 /**
592 Equality operator.
593 */
594 bool operator==(const wxTextAttrSize& size) const { return m_width == size.m_width && m_height == size.m_height ; }
595
596 /**
597 Partial equality test. If @a weakTest is @true, attributes of this object do not
598 have to be present if those attributes of @a size are present. If @a weakTest is
599 @false, the function will fail if an attribute is present in @a size but not
600 in this object.
601 */
602 bool EqPartial(const wxTextAttrSize& size, bool weakTest = true) const;
603
604 /**
605 Apply to this object, but not if the same as @a compareWith.
606 */
607 bool Apply(const wxTextAttrSize& dims, const wxTextAttrSize* compareWith = NULL);
608
609 /**
610 Collects the attributes that are common to a range of content, building up a note of
611 which attributes are absent in some objects and which clash in some objects.
612 */
613 void CollectCommonAttributes(const wxTextAttrSize& attr, wxTextAttrSize& clashingAttr, wxTextAttrSize& absentAttr);
614
615 /**
616 Removes the specified attributes from this object.
617 */
618 bool RemoveStyle(const wxTextAttrSize& attr);
619
620 /**
621 Returns the width.
622 */
623 wxTextAttrDimension& GetWidth() { return m_width; }
624 const wxTextAttrDimension& GetWidth() const { return m_width; }
625
626 /**
627 Sets the width.
628 */
629 void SetWidth(int value, wxTextAttrDimensionFlags flags) { m_width.SetValue(value, flags); }
630
631 /**
632 Sets the width.
633 */
634 void SetWidth(int value, wxTextAttrUnits units) { m_width.SetValue(value, units); }
635
636 /**
637 Sets the width.
638 */
639 void SetWidth(const wxTextAttrDimension& dim) { m_width.SetValue(dim); }
640
641 /**
642 Gets the height.
643 */
644 wxTextAttrDimension& GetHeight() { return m_height; }
645 const wxTextAttrDimension& GetHeight() const { return m_height; }
646
647 /**
648 Sets the height.
649 */
650 void SetHeight(int value, wxTextAttrDimensionFlags flags) { m_height.SetValue(value, flags); }
651
652 /**
653 Sets the height.
654 */
655 void SetHeight(int value, wxTextAttrUnits units) { m_height.SetValue(value, units); }
656
657 /**
658 Sets the height.
659 */
660 void SetHeight(const wxTextAttrDimension& dim) { m_height.SetValue(dim); }
661
662 /**
663 Is the size valid?
664 */
665 bool IsValid() const { return m_width.IsValid() && m_height.IsValid(); }
666
667 wxTextAttrDimension m_width;
668 wxTextAttrDimension m_height;
669 };
670
671 /**
672 @class wxTextAttrDimensionConverter
673 A class to make it easier to convert dimensions.
674
675 @library{wxrichtext}
676 @category{richtext}
677
678 @see wxRichTextAttr, wxRichTextCtrl, wxTextAttrDimension
679 */
680
681 class WXDLLIMPEXP_RICHTEXT wxTextAttrDimensionConverter
682 {
683 public:
684 /**
685 Constructor.
686 */
687 wxTextAttrDimensionConverter(wxDC& dc, double scale = 1.0, const wxSize& parentSize = wxDefaultSize);
688 /**
689 Constructor.
690 */
691 wxTextAttrDimensionConverter(int ppi, double scale = 1.0, const wxSize& parentSize = wxDefaultSize);
692
693 /**
694 Gets the pixel size for the given dimension.
695 */
696 int GetPixels(const wxTextAttrDimension& dim, int direction = wxHORIZONTAL) const;
697 /**
698 Gets the mm size for the given dimension.
699 */
700 int GetTenthsMM(const wxTextAttrDimension& dim) const;
701
702 /**
703 Converts tenths of a mm to pixels.
704 */
705 int ConvertTenthsMMToPixels(int units) const;
706 /**
707 Converts pixels to tenths of a mm.
708 */
709 int ConvertPixelsToTenthsMM(int pixels) const;
710
711 int m_ppi;
712 double m_scale;
713 wxSize m_parentSize;
714 };
715
716 /**
717 Border styles, used with wxTextAttrBorder.
718 */
719 enum wxTextAttrBorderStyle
720 {
721 wxTEXT_BOX_ATTR_BORDER_NONE = 0,
722 wxTEXT_BOX_ATTR_BORDER_SOLID = 1,
723 wxTEXT_BOX_ATTR_BORDER_DOTTED = 2,
724 wxTEXT_BOX_ATTR_BORDER_DASHED = 3,
725 wxTEXT_BOX_ATTR_BORDER_DOUBLE = 4,
726 wxTEXT_BOX_ATTR_BORDER_GROOVE = 5,
727 wxTEXT_BOX_ATTR_BORDER_RIDGE = 6,
728 wxTEXT_BOX_ATTR_BORDER_INSET = 7,
729 wxTEXT_BOX_ATTR_BORDER_OUTSET = 8
730 };
731
732 /**
733 Border style presence flags, used with wxTextAttrBorder.
734 */
735 enum wxTextAttrBorderFlags
736 {
737 wxTEXT_BOX_ATTR_BORDER_STYLE = 0x0001,
738 wxTEXT_BOX_ATTR_BORDER_COLOUR = 0x0002
739 };
740
741 /**
742 Border width symbols for qualitative widths, used with wxTextAttrBorder.
743 */
744 enum wxTextAttrBorderWidth
745 {
746 wxTEXT_BOX_ATTR_BORDER_THIN = -1,
747 wxTEXT_BOX_ATTR_BORDER_MEDIUM = -2,
748 wxTEXT_BOX_ATTR_BORDER_THICK = -3
749 };
750
751 /**
752 Float styles.
753 */
754 enum wxTextBoxAttrFloatStyle
755 {
756 wxTEXT_BOX_ATTR_FLOAT_NONE = 0,
757 wxTEXT_BOX_ATTR_FLOAT_LEFT = 1,
758 wxTEXT_BOX_ATTR_FLOAT_RIGHT = 2
759 };
760
761 /**
762 Clear styles.
763 */
764 enum wxTextBoxAttrClearStyle
765 {
766 wxTEXT_BOX_ATTR_CLEAR_NONE = 0,
767 wxTEXT_BOX_ATTR_CLEAR_LEFT = 1,
768 wxTEXT_BOX_ATTR_CLEAR_RIGHT = 2,
769 wxTEXT_BOX_ATTR_CLEAR_BOTH = 3
770 };
771
772 /**
773 Collapse mode styles. TODO: can they be switched on per side?
774 */
775 enum wxTextBoxAttrCollapseMode
776 {
777 wxTEXT_BOX_ATTR_COLLAPSE_NONE = 0,
778 wxTEXT_BOX_ATTR_COLLAPSE_FULL = 1
779 };
780
781 /**
782 Vertical alignment values.
783 */
784 enum wxTextBoxAttrVerticalAlignment
785 {
786 wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_NONE = 0,
787 wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_TOP = 1,
788 wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_CENTRE = 2,
789 wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT_BOTTOM = 3
790 };
791
792 /**
793 @class wxTextAttrBorder
794 A class representing a rich text object border.
795
796 @library{wxrichtext}
797 @category{richtext}
798
799 @see wxRichTextAttr, wxRichTextCtrl, wxRichTextAttrBorders
800 */
801
802 class WXDLLIMPEXP_RICHTEXT wxTextAttrBorder
803 {
804 public:
805 /**
806 Default constructor.
807 */
808 wxTextAttrBorder() { Reset(); }
809
810 /**
811 Equality operator.
812 */
813 bool operator==(const wxTextAttrBorder& border) const
814 {
815 return m_flags == border.m_flags && m_borderStyle == border.m_borderStyle &&
816 m_borderColour == border.m_borderColour && m_borderWidth == border.m_borderWidth;
817 }
818
819 /**
820 Resets the border style, colour, width and flags.
821 */
822 void Reset() { m_borderStyle = 0; m_borderColour = 0; m_flags = 0; m_borderWidth.Reset(); }
823
824 /**
825 Partial equality test. If @a weakTest is @true, attributes of this object do not
826 have to be present if those attributes of @a border are present. If @a weakTest is
827 @false, the function will fail if an attribute is present in @a border but not
828 in this object.
829 */
830 bool EqPartial(const wxTextAttrBorder& border, bool weakTest = true) const;
831
832 /**
833 Applies the border to this object, but not if the same as @a compareWith.
834
835 */
836 bool Apply(const wxTextAttrBorder& border, const wxTextAttrBorder* compareWith = NULL);
837
838 /**
839 Removes the specified attributes from this object.
840 */
841 bool RemoveStyle(const wxTextAttrBorder& attr);
842
843 /**
844 Collects the attributes that are common to a range of content, building up a note of
845 which attributes are absent in some objects and which clash in some objects.
846 */
847 void CollectCommonAttributes(const wxTextAttrBorder& attr, wxTextAttrBorder& clashingAttr, wxTextAttrBorder& absentAttr);
848
849 /**
850 Sets the border style.
851 */
852 void SetStyle(int style) { m_borderStyle = style; m_flags |= wxTEXT_BOX_ATTR_BORDER_STYLE; }
853
854 /**
855 Gets the border style.
856
857 */
858 int GetStyle() const { return m_borderStyle; }
859
860 /**
861 Sets the border colour.
862 */
863 void SetColour(unsigned long colour) { m_borderColour = colour; m_flags |= wxTEXT_BOX_ATTR_BORDER_COLOUR; }
864
865 /**
866 Sets the border colour.
867 */
868 void SetColour(const wxColour& colour) { m_borderColour = colour.GetRGB(); m_flags |= wxTEXT_BOX_ATTR_BORDER_COLOUR; }
869
870 /**
871 Gets the colour as a long.
872 */
873 unsigned long GetColourLong() const { return m_borderColour; }
874
875 /**
876 Gets the colour.
877 */
878 wxColour GetColour() const { return wxColour(m_borderColour); }
879
880 /**
881 Gets the border width.
882 */
883 wxTextAttrDimension& GetWidth() { return m_borderWidth; }
884 const wxTextAttrDimension& GetWidth() const { return m_borderWidth; }
885
886 /**
887 Sets the border width.
888 */
889 void SetWidth(const wxTextAttrDimension& width) { m_borderWidth = width; }
890 /**
891 Sets the border width.
892 */
893 void SetWidth(int value, wxTextAttrUnits units = wxTEXT_ATTR_UNITS_TENTHS_MM) { SetWidth(wxTextAttrDimension(value, units)); }
894
895 /**
896 True if the border has a valid style.
897 */
898 bool HasStyle() const { return (m_flags & wxTEXT_BOX_ATTR_BORDER_STYLE) != 0; }
899
900 /**
901 True if the border has a valid colour.
902 */
903 bool HasColour() const { return (m_flags & wxTEXT_BOX_ATTR_BORDER_COLOUR) != 0; }
904
905 /**
906 True if the border has a valid width.
907 */
908 bool HasWidth() const { return m_borderWidth.IsValid(); }
909
910 /**
911 True if the border is valid.
912 */
913 bool IsValid() const { return HasWidth(); }
914
915 /**
916 Set the valid flag for this border.
917 */
918 void MakeValid() { m_borderWidth.SetValid(true); }
919
920 /**
921 Returns the border flags.
922 */
923 int GetFlags() const { return m_flags; }
924
925 /**
926 Sets the border flags.
927 */
928 void SetFlags(int flags) { m_flags = flags; }
929
930 /**
931 Adds a border flag.
932 */
933 void AddFlag(int flag) { m_flags |= flag; }
934
935 /**
936 Removes a border flag.
937 */
938 void RemoveFlag(int flag) { m_flags &= ~flag; }
939
940 int m_borderStyle;
941 unsigned long m_borderColour;
942 wxTextAttrDimension m_borderWidth;
943 int m_flags;
944 };
945
946 /**
947 @class wxTextAttrBorders
948 A class representing a rich text object's borders.
949
950 @library{wxrichtext}
951 @category{richtext}
952
953 @see wxRichTextAttr, wxRichTextCtrl, wxRichTextAttrBorder
954 */
955
956 class WXDLLIMPEXP_RICHTEXT wxTextAttrBorders
957 {
958 public:
959 /**
960 Default constructor.
961 */
962 wxTextAttrBorders() { }
963
964 /**
965 Equality operator.
966 */
967 bool operator==(const wxTextAttrBorders& borders) const
968 {
969 return m_left == borders.m_left && m_right == borders.m_right &&
970 m_top == borders.m_top && m_bottom == borders.m_bottom;
971 }
972
973 /**
974 Sets the style of all borders.
975 */
976 void SetStyle(int style);
977
978 /**
979 Sets colour of all borders.
980 */
981 void SetColour(unsigned long colour);
982
983 /**
984 Sets the colour for all borders.
985 */
986 void SetColour(const wxColour& colour);
987
988 /**
989 Sets the width of all borders.
990 */
991 void SetWidth(const wxTextAttrDimension& width);
992
993 /**
994 Sets the width of all borders.
995 */
996 void SetWidth(int value, wxTextAttrUnits units = wxTEXT_ATTR_UNITS_TENTHS_MM) { SetWidth(wxTextAttrDimension(value, units)); }
997
998 /**
999 Resets all borders.
1000 */
1001 void Reset() { m_left.Reset(); m_right.Reset(); m_top.Reset(); m_bottom.Reset(); }
1002
1003 /**
1004 Partial equality test. If @a weakTest is @true, attributes of this object do not
1005 have to be present if those attributes of @a borders are present. If @a weakTest is
1006 @false, the function will fail if an attribute is present in @a borders but not
1007 in this object.
1008 */
1009 bool EqPartial(const wxTextAttrBorders& borders, bool weakTest = true) const;
1010
1011 /**
1012 Applies border to this object, but not if the same as @a compareWith.
1013 */
1014 bool Apply(const wxTextAttrBorders& borders, const wxTextAttrBorders* compareWith = NULL);
1015
1016 /**
1017 Removes the specified attributes from this object.
1018 */
1019 bool RemoveStyle(const wxTextAttrBorders& attr);
1020
1021 /**
1022 Collects the attributes that are common to a range of content, building up a note of
1023 which attributes are absent in some objects and which clash in some objects.
1024 */
1025 void CollectCommonAttributes(const wxTextAttrBorders& attr, wxTextAttrBorders& clashingAttr, wxTextAttrBorders& absentAttr);
1026
1027 /**
1028 Returns @true if all borders are valid.
1029 */
1030 bool IsValid() const { return m_left.IsValid() || m_right.IsValid() || m_top.IsValid() || m_bottom.IsValid(); }
1031
1032 /**
1033 Returns the left border.
1034 */
1035 const wxTextAttrBorder& GetLeft() const { return m_left; }
1036 wxTextAttrBorder& GetLeft() { return m_left; }
1037
1038 /**
1039 Returns the right border.
1040 */
1041 const wxTextAttrBorder& GetRight() const { return m_right; }
1042 wxTextAttrBorder& GetRight() { return m_right; }
1043
1044 /**
1045 Returns the top border.
1046 */
1047 const wxTextAttrBorder& GetTop() const { return m_top; }
1048 wxTextAttrBorder& GetTop() { return m_top; }
1049
1050 /**
1051 Returns the bottom border.
1052 */
1053 const wxTextAttrBorder& GetBottom() const { return m_bottom; }
1054 wxTextAttrBorder& GetBottom() { return m_bottom; }
1055
1056 wxTextAttrBorder m_left, m_right, m_top, m_bottom;
1057
1058 };
1059
1060 /**
1061 @class wxTextBoxAttr
1062 A class representing the box attributes of a rich text object.
1063
1064 @library{wxrichtext}
1065 @category{richtext}
1066
1067 @see wxRichTextAttr, wxRichTextCtrl
1068 */
1069
1070 class WXDLLIMPEXP_RICHTEXT wxTextBoxAttr
1071 {
1072 public:
1073 /**
1074 Default constructor.
1075 */
1076 wxTextBoxAttr() { Init(); }
1077
1078 /**
1079 Copy constructor.
1080 */
1081 wxTextBoxAttr(const wxTextBoxAttr& attr) { Init(); (*this) = attr; }
1082
1083 /**
1084 Initialises this object.
1085 */
1086 void Init() { Reset(); }
1087
1088 /**
1089 Resets this object.
1090 */
1091 void Reset();
1092
1093 // Copy. Unnecessary since we let it do a binary copy
1094 //void Copy(const wxTextBoxAttr& attr);
1095
1096 // Assignment
1097 //void operator= (const wxTextBoxAttr& attr);
1098
1099 /**
1100 Equality test.
1101 */
1102 bool operator== (const wxTextBoxAttr& attr) const;
1103
1104 /**
1105 Partial equality test, ignoring unset attributes. If @a weakTest is @true, attributes of this object do not
1106 have to be present if those attributes of @a attr are present. If @a weakTest is
1107 @false, the function will fail if an attribute is present in @a attr but not
1108 in this object.
1109
1110 */
1111 bool EqPartial(const wxTextBoxAttr& attr, bool weakTest = true) const;
1112
1113 /**
1114 Merges the given attributes. If @a compareWith is non-NULL, then it will be used
1115 to mask out those attributes that are the same in style and @a compareWith, for
1116 situations where we don't want to explicitly set inherited attributes.
1117 */
1118 bool Apply(const wxTextBoxAttr& style, const wxTextBoxAttr* compareWith = NULL);
1119
1120 /**
1121 Collects the attributes that are common to a range of content, building up a note of
1122 which attributes are absent in some objects and which clash in some objects.
1123 */
1124 void CollectCommonAttributes(const wxTextBoxAttr& attr, wxTextBoxAttr& clashingAttr, wxTextBoxAttr& absentAttr);
1125
1126 /**
1127 Removes the specified attributes from this object.
1128 */
1129 bool RemoveStyle(const wxTextBoxAttr& attr);
1130
1131 /**
1132 Sets the flags.
1133 */
1134 void SetFlags(int flags) { m_flags = flags; }
1135
1136 /**
1137 Returns the flags.
1138 */
1139 int GetFlags() const { return m_flags; }
1140
1141 /**
1142 Is this flag present?
1143 */
1144 bool HasFlag(wxTextBoxAttrFlags flag) const { return (m_flags & flag) != 0; }
1145
1146 /**
1147 Removes this flag.
1148 */
1149 void RemoveFlag(wxTextBoxAttrFlags flag) { m_flags &= ~flag; }
1150
1151 /**
1152 Adds this flag.
1153 */
1154 void AddFlag(wxTextBoxAttrFlags flag) { m_flags |= flag; }
1155
1156 /**
1157 Returns @true if no attributes are set.
1158 */
1159 bool IsDefault() const;
1160
1161 /**
1162 Returns the float mode.
1163 */
1164 wxTextBoxAttrFloatStyle GetFloatMode() const { return m_floatMode; }
1165
1166 /**
1167 Sets the float mode.
1168 */
1169 void SetFloatMode(wxTextBoxAttrFloatStyle mode) { m_floatMode = mode; m_flags |= wxTEXT_BOX_ATTR_FLOAT; }
1170
1171 /**
1172 Returns @true if float mode is active.
1173 */
1174 bool HasFloatMode() const { return HasFlag(wxTEXT_BOX_ATTR_FLOAT); }
1175
1176 /**
1177 Returns @true if this object is floating.
1178 */
1179 bool IsFloating() const { return HasFloatMode() && GetFloatMode() != wxTEXT_BOX_ATTR_FLOAT_NONE; }
1180
1181 /**
1182 Returns the clear mode - whether to wrap text after object. Currently unimplemented.
1183 */
1184 wxTextBoxAttrClearStyle GetClearMode() const { return m_clearMode; }
1185
1186 /**
1187 Set the clear mode. Currently unimplemented.
1188 */
1189 void SetClearMode(wxTextBoxAttrClearStyle mode) { m_clearMode = mode; m_flags |= wxTEXT_BOX_ATTR_CLEAR; }
1190
1191 /**
1192 Returns @true if we have a clear flag.
1193 */
1194 bool HasClearMode() const { return HasFlag(wxTEXT_BOX_ATTR_CLEAR); }
1195
1196 /**
1197 Returns the collapse mode - whether to collapse borders. Currently unimplemented.
1198 */
1199 wxTextBoxAttrCollapseMode GetCollapseBorders() const { return m_collapseMode; }
1200
1201 /**
1202 Sets the collapse mode - whether to collapse borders. Currently unimplemented.
1203 */
1204 void SetCollapseBorders(wxTextBoxAttrCollapseMode collapse) { m_collapseMode = collapse; m_flags |= wxTEXT_BOX_ATTR_COLLAPSE_BORDERS; }
1205
1206 /**
1207 Returns @true if the collapse borders flag is present.
1208 */
1209 bool HasCollapseBorders() const { return HasFlag(wxTEXT_BOX_ATTR_COLLAPSE_BORDERS); }
1210
1211 /**
1212 Returns the vertical alignment.
1213 */
1214 wxTextBoxAttrVerticalAlignment GetVerticalAlignment() const { return m_verticalAlignment; }
1215
1216 /**
1217 Sets the vertical alignment.
1218 */
1219 void SetVerticalAlignment(wxTextBoxAttrVerticalAlignment verticalAlignment) { m_verticalAlignment = verticalAlignment; m_flags |= wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT; }
1220
1221 /**
1222 Returns @true if a vertical alignment flag is present.
1223 */
1224 bool HasVerticalAlignment() const { return HasFlag(wxTEXT_BOX_ATTR_VERTICAL_ALIGNMENT); }
1225
1226 /**
1227 Returns the margin values.
1228 */
1229 wxTextAttrDimensions& GetMargins() { return m_margins; }
1230 const wxTextAttrDimensions& GetMargins() const { return m_margins; }
1231
1232 /**
1233 Returns the left margin.
1234 */
1235 wxTextAttrDimension& GetLeftMargin() { return m_margins.m_left; }
1236 const wxTextAttrDimension& GetLeftMargin() const { return m_margins.m_left; }
1237
1238 /**
1239 Returns the right margin.
1240 */
1241 wxTextAttrDimension& GetRightMargin() { return m_margins.m_right; }
1242 const wxTextAttrDimension& GetRightMargin() const { return m_margins.m_right; }
1243
1244 /**
1245 Returns the top margin.
1246 */
1247 wxTextAttrDimension& GetTopMargin() { return m_margins.m_top; }
1248 const wxTextAttrDimension& GetTopMargin() const { return m_margins.m_top; }
1249
1250 /**
1251 Returns the bottom margin.
1252 */
1253 wxTextAttrDimension& GetBottomMargin() { return m_margins.m_bottom; }
1254 const wxTextAttrDimension& GetBottomMargin() const { return m_margins.m_bottom; }
1255
1256 /**
1257 Returns the position.
1258 */
1259 wxTextAttrDimensions& GetPosition() { return m_position; }
1260 const wxTextAttrDimensions& GetPosition() const { return m_position; }
1261
1262 /**
1263 Returns the left position.
1264 */
1265 wxTextAttrDimension& GetLeft() { return m_position.m_left; }
1266 const wxTextAttrDimension& GetLeft() const { return m_position.m_left; }
1267
1268 /**
1269 Returns the right position.
1270 */
1271 wxTextAttrDimension& GetRight() { return m_position.m_right; }
1272 const wxTextAttrDimension& GetRight() const { return m_position.m_right; }
1273
1274 /**
1275 Returns the top position.
1276 */
1277 wxTextAttrDimension& GetTop() { return m_position.m_top; }
1278 const wxTextAttrDimension& GetTop() const { return m_position.m_top; }
1279
1280 /**
1281 Returns the bottom position.
1282 */
1283 wxTextAttrDimension& GetBottom() { return m_position.m_bottom; }
1284 const wxTextAttrDimension& GetBottom() const { return m_position.m_bottom; }
1285
1286 /**
1287 Returns the padding values.
1288 */
1289 wxTextAttrDimensions& GetPadding() { return m_padding; }
1290 const wxTextAttrDimensions& GetPadding() const { return m_padding; }
1291
1292 /**
1293 Returns the left padding value.
1294 */
1295 wxTextAttrDimension& GetLeftPadding() { return m_padding.m_left; }
1296 const wxTextAttrDimension& GetLeftPadding() const { return m_padding.m_left; }
1297
1298 /**
1299 Returns the right padding value.
1300 */
1301 wxTextAttrDimension& GetRightPadding() { return m_padding.m_right; }
1302 const wxTextAttrDimension& GetRightPadding() const { return m_padding.m_right; }
1303
1304 /**
1305 Returns the top padding value.
1306 */
1307 wxTextAttrDimension& GetTopPadding() { return m_padding.m_top; }
1308 const wxTextAttrDimension& GetTopPadding() const { return m_padding.m_top; }
1309
1310 /**
1311 Returns the bottom padding value.
1312 */
1313 wxTextAttrDimension& GetBottomPadding() { return m_padding.m_bottom; }
1314 const wxTextAttrDimension& GetBottomPadding() const { return m_padding.m_bottom; }
1315
1316 /**
1317 Returns the borders.
1318 */
1319 wxTextAttrBorders& GetBorder() { return m_border; }
1320 const wxTextAttrBorders& GetBorder() const { return m_border; }
1321
1322 /**
1323 Returns the left border.
1324 */
1325 wxTextAttrBorder& GetLeftBorder() { return m_border.m_left; }
1326 const wxTextAttrBorder& GetLeftBorder() const { return m_border.m_left; }
1327
1328 /**
1329 Returns the top border.
1330 */
1331 wxTextAttrBorder& GetTopBorder() { return m_border.m_top; }
1332 const wxTextAttrBorder& GetTopBorder() const { return m_border.m_top; }
1333
1334 /**
1335 Returns the right border.
1336 */
1337 wxTextAttrBorder& GetRightBorder() { return m_border.m_right; }
1338 const wxTextAttrBorder& GetRightBorder() const { return m_border.m_right; }
1339
1340 /**
1341 Returns the bottom border.
1342 */
1343 wxTextAttrBorder& GetBottomBorder() { return m_border.m_bottom; }
1344 const wxTextAttrBorder& GetBottomBorder() const { return m_border.m_bottom; }
1345
1346 /**
1347 Returns the outline.
1348 */
1349 wxTextAttrBorders& GetOutline() { return m_outline; }
1350 const wxTextAttrBorders& GetOutline() const { return m_outline; }
1351
1352 /**
1353 Returns the left outline.
1354 */
1355 wxTextAttrBorder& GetLeftOutline() { return m_outline.m_left; }
1356 const wxTextAttrBorder& GetLeftOutline() const { return m_outline.m_left; }
1357
1358 /**
1359 Returns the top outline.
1360 */
1361 wxTextAttrBorder& GetTopOutline() { return m_outline.m_top; }
1362 const wxTextAttrBorder& GetTopOutline() const { return m_outline.m_top; }
1363
1364 /**
1365 Returns the right outline.
1366 */
1367 wxTextAttrBorder& GetRightOutline() { return m_outline.m_right; }
1368 const wxTextAttrBorder& GetRightOutline() const { return m_outline.m_right; }
1369
1370 /**
1371 Returns the bottom outline.
1372 */
1373 wxTextAttrBorder& GetBottomOutline() { return m_outline.m_bottom; }
1374 const wxTextAttrBorder& GetBottomOutline() const { return m_outline.m_bottom; }
1375
1376 /**
1377 Returns the object size.
1378 */
1379 wxTextAttrSize& GetSize() { return m_size; }
1380 const wxTextAttrSize& GetSize() const { return m_size; }
1381
1382 /**
1383 Returns the object minimum size.
1384 */
1385
1386 wxTextAttrSize& GetMinSize() { return m_minSize; }
1387 const wxTextAttrSize& GetMinSize() const { return m_minSize; }
1388
1389 /**
1390 Returns the object maximum size.
1391 */
1392
1393 wxTextAttrSize& GetMaxSize() { return m_maxSize; }
1394 const wxTextAttrSize& GetMaxSize() const { return m_maxSize; }
1395
1396 /**
1397 Sets the object size.
1398 */
1399 void SetSize(const wxTextAttrSize& sz) { m_size = sz; }
1400
1401 /**
1402 Sets the object minimum size.
1403 */
1404 void SetMinSize(const wxTextAttrSize& sz) { m_minSize = sz; }
1405
1406 /**
1407 Sets the object maximum size.
1408 */
1409 void SetMaxSize(const wxTextAttrSize& sz) { m_maxSize = sz; }
1410
1411 /**
1412 Returns the object width.
1413 */
1414 wxTextAttrDimension& GetWidth() { return m_size.m_width; }
1415 const wxTextAttrDimension& GetWidth() const { return m_size.m_width; }
1416
1417 /**
1418 Returns the object height.
1419 */
1420 wxTextAttrDimension& GetHeight() { return m_size.m_height; }
1421 const wxTextAttrDimension& GetHeight() const { return m_size.m_height; }
1422
1423 /**
1424 Returns the box style name.
1425 */
1426 const wxString& GetBoxStyleName() const { return m_boxStyleName; }
1427
1428 /**
1429 Sets the box style name.
1430 */
1431 void SetBoxStyleName(const wxString& name) { m_boxStyleName = name; AddFlag(wxTEXT_BOX_ATTR_BOX_STYLE_NAME); }
1432
1433 /**
1434 Returns @true if the box style name is present.
1435 */
1436 bool HasBoxStyleName() const { return HasFlag(wxTEXT_BOX_ATTR_BOX_STYLE_NAME); }
1437
1438 public:
1439
1440 int m_flags;
1441
1442 wxTextAttrDimensions m_margins;
1443 wxTextAttrDimensions m_padding;
1444 wxTextAttrDimensions m_position;
1445
1446 wxTextAttrSize m_size;
1447 wxTextAttrSize m_minSize;
1448 wxTextAttrSize m_maxSize;
1449
1450 wxTextAttrBorders m_border;
1451 wxTextAttrBorders m_outline;
1452
1453 wxTextBoxAttrFloatStyle m_floatMode;
1454 wxTextBoxAttrClearStyle m_clearMode;
1455 wxTextBoxAttrCollapseMode m_collapseMode;
1456 wxTextBoxAttrVerticalAlignment m_verticalAlignment;
1457 wxString m_boxStyleName;
1458 };
1459
1460 /**
1461 @class wxRichTextAttr
1462 A class representing enhanced attributes for rich text objects.
1463 This adds a wxTextBoxAttr member to the basic wxTextAttr class.
1464
1465 @library{wxrichtext}
1466 @category{richtext}
1467
1468 @see wxRichTextAttr, wxTextBoxAttr, wxRichTextCtrl
1469 */
1470
1471 class WXDLLIMPEXP_RICHTEXT wxRichTextAttr: public wxTextAttr
1472 {
1473 public:
1474 /**
1475 Constructor taking a wxTextAttr.
1476 */
1477 wxRichTextAttr(const wxTextAttr& attr) { wxTextAttr::Copy(attr); }
1478
1479 /**
1480 Copy constructor.
1481 */
1482 wxRichTextAttr(const wxRichTextAttr& attr): wxTextAttr() { Copy(attr); }
1483
1484 /**
1485 Default constructor.
1486 */
1487 wxRichTextAttr() {}
1488
1489 /**
1490 Copy function.
1491 */
1492 void Copy(const wxRichTextAttr& attr);
1493
1494 /**
1495 Assignment operator.
1496 */
1497 void operator=(const wxRichTextAttr& attr) { Copy(attr); }
1498
1499 /**
1500 Assignment operator.
1501 */
1502 void operator=(const wxTextAttr& attr) { wxTextAttr::Copy(attr); }
1503
1504 /**
1505 Equality test.
1506 */
1507 bool operator==(const wxRichTextAttr& attr) const;
1508
1509 /**
1510 Partial equality test. If @a weakTest is @true, attributes of this object do not
1511 have to be present if those attributes of @a attr are present. If @a weakTest is
1512 @false, the function will fail if an attribute is present in @a attr but not
1513 in this object.
1514 */
1515 bool EqPartial(const wxRichTextAttr& attr, bool weakTest = true) const;
1516
1517 /**
1518 Merges the given attributes. If @a compareWith
1519 is non-NULL, then it will be used to mask out those attributes that are the same in style
1520 and @a compareWith, for situations where we don't want to explicitly set inherited attributes.
1521 */
1522 bool Apply(const wxRichTextAttr& style, const wxRichTextAttr* compareWith = NULL);
1523
1524 /**
1525 Collects the attributes that are common to a range of content, building up a note of
1526 which attributes are absent in some objects and which clash in some objects.
1527 */
1528 void CollectCommonAttributes(const wxRichTextAttr& attr, wxRichTextAttr& clashingAttr, wxRichTextAttr& absentAttr);
1529
1530 /**
1531 Removes the specified attributes from this object.
1532 */
1533 bool RemoveStyle(const wxRichTextAttr& attr);
1534
1535 /**
1536 Returns the text box attributes.
1537 */
1538 wxTextBoxAttr& GetTextBoxAttr() { return m_textBoxAttr; }
1539 const wxTextBoxAttr& GetTextBoxAttr() const { return m_textBoxAttr; }
1540
1541 /**
1542 Set the text box attributes.
1543 */
1544 void SetTextBoxAttr(const wxTextBoxAttr& attr) { m_textBoxAttr = attr; }
1545
1546 wxTextBoxAttr m_textBoxAttr;
1547 };
1548
1549 WX_DECLARE_USER_EXPORTED_OBJARRAY(wxVariant, wxRichTextVariantArray, WXDLLIMPEXP_RICHTEXT);
1550
1551 /**
1552 @class wxRichTextProperties
1553 A simple property class using wxVariants. This is used to give each rich text object the
1554 ability to store custom properties that can be used by the application.
1555
1556 @library{wxrichtext}
1557 @category{richtext}
1558
1559 @see wxRichTextBuffer, wxRichTextObject, wxRichTextCtrl
1560 */
1561
1562 class WXDLLIMPEXP_RICHTEXT wxRichTextProperties: public wxObject
1563 {
1564 DECLARE_DYNAMIC_CLASS(wxRichTextProperties)
1565 public:
1566
1567 /**
1568 Default constructor.
1569 */
1570 wxRichTextProperties() {}
1571
1572 /**
1573 Copy constructor.
1574 */
1575 wxRichTextProperties(const wxRichTextProperties& props): wxObject() { Copy(props); }
1576
1577 /**
1578 Assignment operator.
1579 */
1580 void operator=(const wxRichTextProperties& props) { Copy(props); }
1581
1582 /**
1583 Equality operator.
1584 */
1585 bool operator==(const wxRichTextProperties& props) const;
1586
1587 /**
1588 Copies from @a props.
1589 */
1590 void Copy(const wxRichTextProperties& props) { m_properties = props.m_properties; }
1591
1592 /**
1593 Returns the variant at the given index.
1594 */
1595 const wxVariant& operator[](size_t idx) const { return m_properties[idx]; }
1596
1597 /**
1598 Returns the variant at the given index.
1599 */
1600 wxVariant& operator[](size_t idx) { return m_properties[idx]; }
1601
1602 /**
1603 Clears the properties.
1604 */
1605 void Clear() { m_properties.Clear(); }
1606
1607 /**
1608 Returns the array of variants implementing the properties.
1609 */
1610 const wxRichTextVariantArray& GetProperties() const { return m_properties; }
1611
1612 /**
1613 Returns the array of variants implementing the properties.
1614 */
1615 wxRichTextVariantArray& GetProperties() { return m_properties; }
1616
1617 /**
1618 Sets the array of variants.
1619 */
1620 void SetProperties(const wxRichTextVariantArray& props) { m_properties = props; }
1621
1622 /**
1623 Returns all the property names.
1624 */
1625 wxArrayString GetPropertyNames() const;
1626
1627 /**
1628 Returns a count of the properties.
1629 */
1630 size_t GetCount() const { return m_properties.GetCount(); }
1631
1632 /**
1633 Returns @true if the given property is found.
1634 */
1635 bool HasProperty(const wxString& name) const { return Find(name) != -1; }
1636
1637 /**
1638 Finds the given property.
1639 */
1640 int Find(const wxString& name) const;
1641
1642 /**
1643 Removes the given property.
1644 */
1645 bool Remove(const wxString& name);
1646
1647 /**
1648 Gets the property variant by name.
1649 */
1650 const wxVariant& GetProperty(const wxString& name) const;
1651
1652 /**
1653 Finds or creates a property with the given name, returning a pointer to the variant.
1654 */
1655 wxVariant* FindOrCreateProperty(const wxString& name);
1656
1657 /**
1658 Gets the value of the named property as a string.
1659 */
1660 wxString GetPropertyString(const wxString& name) const;
1661
1662 /**
1663 Gets the value of the named property as a long integer.
1664 */
1665 long GetPropertyLong(const wxString& name) const;
1666
1667 /**
1668 Gets the value of the named property as a boolean.
1669 */
1670 bool GetPropertyBool(const wxString& name) const;
1671
1672 /**
1673 Gets the value of the named property as a double.
1674 */
1675 double GetPropertyDouble(const wxString& name) const;
1676
1677 /**
1678 Sets the property by passing a variant which contains a name and value.
1679 */
1680 void SetProperty(const wxVariant& variant);
1681
1682 /**
1683 Sets a property by name and variant.
1684 */
1685 void SetProperty(const wxString& name, const wxVariant& variant);
1686
1687 /**
1688 Sets a property by name and string value.
1689 */
1690 void SetProperty(const wxString& name, const wxString& value);
1691
1692 /**
1693 Sets property by name and long integer value.
1694 */
1695 void SetProperty(const wxString& name, long value);
1696
1697 /**
1698 Sets property by name and double value.
1699 */
1700 void SetProperty(const wxString& name, double value);
1701
1702 /**
1703 Sets property by name and boolean value.
1704 */
1705 void SetProperty(const wxString& name, bool value);
1706
1707 /**
1708 Removes the given properties from these properties.
1709 */
1710 void RemoveProperties(const wxRichTextProperties& properties);
1711
1712 /**
1713 Merges the given properties with these properties.
1714 */
1715 void MergeProperties(const wxRichTextProperties& properties);
1716
1717 protected:
1718 wxRichTextVariantArray m_properties;
1719 };
1720
1721
1722 /**
1723 @class wxRichTextFontTable
1724 Manages quick access to a pool of fonts for rendering rich text.
1725
1726 @library{wxrichtext}
1727 @category{richtext}
1728
1729 @see wxRichTextBuffer, wxRichTextCtrl
1730 */
1731
1732 class WXDLLIMPEXP_RICHTEXT wxRichTextFontTable: public wxObject
1733 {
1734 public:
1735 /**
1736 Default constructor.
1737 */
1738 wxRichTextFontTable();
1739
1740 /**
1741 Copy constructor.
1742 */
1743 wxRichTextFontTable(const wxRichTextFontTable& table);
1744 virtual ~wxRichTextFontTable();
1745
1746 /**
1747 Returns @true if the font table is valid.
1748 */
1749 bool IsOk() const { return m_refData != NULL; }
1750
1751 /**
1752 Finds a font for the given attribute object.
1753 */
1754 wxFont FindFont(const wxRichTextAttr& fontSpec);
1755
1756 /**
1757 Clears the font table.
1758 */
1759 void Clear();
1760
1761 /**
1762 Assignment operator.
1763 */
1764 void operator= (const wxRichTextFontTable& table);
1765
1766 /**
1767 Equality operator.
1768 */
1769 bool operator == (const wxRichTextFontTable& table) const;
1770
1771 /**
1772 Inequality operator.
1773 */
1774 bool operator != (const wxRichTextFontTable& table) const { return !(*this == table); }
1775
1776 /**
1777 Set the font scale factor.
1778 */
1779 void SetFontScale(double fontScale);
1780
1781 protected:
1782
1783 double m_fontScale;
1784
1785 DECLARE_DYNAMIC_CLASS(wxRichTextFontTable)
1786 };
1787
1788 /**
1789 @class wxRichTextRange
1790
1791 This stores beginning and end positions for a range of data.
1792
1793 @library{wxrichtext}
1794 @category{richtext}
1795
1796 @see wxRichTextBuffer, wxRichTextCtrl
1797 */
1798
1799 class WXDLLIMPEXP_RICHTEXT wxRichTextRange
1800 {
1801 public:
1802 // Constructors
1803
1804 /**
1805 Default constructor.
1806 */
1807 wxRichTextRange() { m_start = 0; m_end = 0; }
1808
1809 /**
1810 Constructor taking start and end positions.
1811 */
1812 wxRichTextRange(long start, long end) { m_start = start; m_end = end; }
1813
1814 /**
1815 Copy constructor.
1816 */
1817 wxRichTextRange(const wxRichTextRange& range) { m_start = range.m_start; m_end = range.m_end; }
1818 ~wxRichTextRange() {}
1819
1820 /**
1821 Assigns @a range to this range.
1822 */
1823 void operator =(const wxRichTextRange& range) { m_start = range.m_start; m_end = range.m_end; }
1824
1825 /**
1826 Equality operator. Returns @true if @a range is the same as this range.
1827 */
1828 bool operator ==(const wxRichTextRange& range) const { return (m_start == range.m_start && m_end == range.m_end); }
1829
1830 /**
1831 Inequality operator.
1832 */
1833 bool operator !=(const wxRichTextRange& range) const { return (m_start != range.m_start || m_end != range.m_end); }
1834
1835 /**
1836 Subtracts a range from this range.
1837 */
1838 wxRichTextRange operator -(const wxRichTextRange& range) const { return wxRichTextRange(m_start - range.m_start, m_end - range.m_end); }
1839
1840 /**
1841 Adds a range to this range.
1842 */
1843 wxRichTextRange operator +(const wxRichTextRange& range) const { return wxRichTextRange(m_start + range.m_start, m_end + range.m_end); }
1844
1845 /**
1846 Sets the range start and end positions.
1847 */
1848 void SetRange(long start, long end) { m_start = start; m_end = end; }
1849
1850 /**
1851 Sets the start position.
1852 */
1853 void SetStart(long start) { m_start = start; }
1854
1855 /**
1856 Returns the start position.
1857 */
1858 long GetStart() const { return m_start; }
1859
1860 /**
1861 Sets the end position.
1862 */
1863 void SetEnd(long end) { m_end = end; }
1864
1865 /**
1866 Gets the end position.
1867 */
1868 long GetEnd() const { return m_end; }
1869
1870 /**
1871 Returns true if this range is completely outside @a range.
1872 */
1873 bool IsOutside(const wxRichTextRange& range) const { return range.m_start > m_end || range.m_end < m_start; }
1874
1875 /**
1876 Returns true if this range is completely within @a range.
1877 */
1878 bool IsWithin(const wxRichTextRange& range) const { return m_start >= range.m_start && m_end <= range.m_end; }
1879
1880 /**
1881 Returns true if @a pos was within the range. Does not match if the range is empty.
1882 */
1883 bool Contains(long pos) const { return pos >= m_start && pos <= m_end ; }
1884
1885 /**
1886 Limit this range to be within @a range.
1887 */
1888 bool LimitTo(const wxRichTextRange& range) ;
1889
1890 /**
1891 Gets the length of the range.
1892 */
1893 long GetLength() const { return m_end - m_start + 1; }
1894
1895 /**
1896 Swaps the start and end.
1897 */
1898 void Swap() { long tmp = m_start; m_start = m_end; m_end = tmp; }
1899
1900 /**
1901 Converts the API-standard range, whose end is one past the last character in
1902 the range, to the internal form, which uses the first and last character
1903 positions of the range. In other words, one is subtracted from the end position.
1904 (n, n) is the range of a single character.
1905 */
1906 wxRichTextRange ToInternal() const { return wxRichTextRange(m_start, m_end-1); }
1907
1908 /**
1909 Converts the internal range, which uses the first and last character positions
1910 of the range, to the API-standard range, whose end is one past the last
1911 character in the range. In other words, one is added to the end position.
1912 (n, n+1) is the range of a single character.
1913 */
1914 wxRichTextRange FromInternal() const { return wxRichTextRange(m_start, m_end+1); }
1915
1916 protected:
1917 long m_start;
1918 long m_end;
1919 };
1920
1921 WX_DECLARE_USER_EXPORTED_OBJARRAY(wxRichTextRange, wxRichTextRangeArray, WXDLLIMPEXP_RICHTEXT);
1922
1923 #define wxRICHTEXT_ALL wxRichTextRange(-2, -2)
1924 #define wxRICHTEXT_NONE wxRichTextRange(-1, -1)
1925
1926 #define wxRICHTEXT_NO_SELECTION wxRichTextRange(-2, -2)
1927
1928 /**
1929 @class wxRichTextSelection
1930
1931 Stores selection information. The selection does not have to be contiguous, though currently non-contiguous
1932 selections are only supported for a range of table cells (a geometric block of cells can consist
1933 of a set of non-contiguous positions).
1934
1935 The selection consists of an array of ranges, and the container that is the context for the selection. It
1936 follows that a single selection object can only represent ranges with the same parent container.
1937
1938 @library{wxrichtext}
1939 @category{richtext}
1940
1941 @see wxRichTextBuffer, wxRichTextCtrl
1942 */
1943
1944 class WXDLLIMPEXP_RICHTEXT wxRichTextSelection
1945 {
1946 public:
1947 /**
1948 Copy constructor.
1949 */
1950 wxRichTextSelection(const wxRichTextSelection& sel) { Copy(sel); }
1951
1952 /**
1953 Creates a selection from a range and a container.
1954 */
1955 wxRichTextSelection(const wxRichTextRange& range, wxRichTextParagraphLayoutBox* container) { m_ranges.Add(range); m_container = container; }
1956
1957 /**
1958 Default constructor.
1959 */
1960 wxRichTextSelection() { Reset(); }
1961
1962 /**
1963 Resets the selection.
1964 */
1965 void Reset() { m_ranges.Clear(); m_container = NULL; }
1966
1967 /**
1968 Sets the selection.
1969 */
1970
1971 void Set(const wxRichTextRange& range, wxRichTextParagraphLayoutBox* container)
1972 { m_ranges.Clear(); m_ranges.Add(range); m_container = container; }
1973
1974 /**
1975 Adds a range to the selection.
1976 */
1977 void Add(const wxRichTextRange& range)
1978 { m_ranges.Add(range); }
1979
1980 /**
1981 Sets the selections from an array of ranges and a container object.
1982 */
1983 void Set(const wxRichTextRangeArray& ranges, wxRichTextParagraphLayoutBox* container)
1984 { m_ranges = ranges; m_container = container; }
1985
1986 /**
1987 Copies from @a sel.
1988 */
1989 void Copy(const wxRichTextSelection& sel)
1990 { m_ranges = sel.m_ranges; m_container = sel.m_container; }
1991
1992 /**
1993 Assignment operator.
1994 */
1995 void operator=(const wxRichTextSelection& sel) { Copy(sel); }
1996
1997 /**
1998 Equality operator.
1999 */
2000 bool operator==(const wxRichTextSelection& sel) const;
2001
2002 /**
2003 Index operator.
2004 */
2005 wxRichTextRange operator[](size_t i) const { return GetRange(i); }
2006
2007 /**
2008 Returns the selection ranges.
2009 */
2010 wxRichTextRangeArray& GetRanges() { return m_ranges; }
2011
2012 /**
2013 Returns the selection ranges.
2014 */
2015 const wxRichTextRangeArray& GetRanges() const { return m_ranges; }
2016
2017 /**
2018 Sets the selection ranges.
2019 */
2020 void SetRanges(const wxRichTextRangeArray& ranges) { m_ranges = ranges; }
2021
2022 /**
2023 Returns the number of ranges in the selection.
2024 */
2025 size_t GetCount() const { return m_ranges.GetCount(); }
2026
2027 /**
2028 Returns the range at the given index.
2029
2030 */
2031 wxRichTextRange GetRange(size_t i) const { return m_ranges[i]; }
2032
2033 /**
2034 Returns the first range if there is one, otherwise wxRICHTEXT_NO_SELECTION.
2035 */
2036 wxRichTextRange GetRange() const { return (m_ranges.GetCount() > 0) ? (m_ranges[0]) : wxRICHTEXT_NO_SELECTION; }
2037
2038 /**
2039 Sets a single range.
2040 */
2041 void SetRange(const wxRichTextRange& range) { m_ranges.Clear(); m_ranges.Add(range); }
2042
2043 /**
2044 Returns the container for which the selection is valid.
2045 */
2046 wxRichTextParagraphLayoutBox* GetContainer() const { return m_container; }
2047
2048 /**
2049 Sets the container for which the selection is valid.
2050 */
2051 void SetContainer(wxRichTextParagraphLayoutBox* container) { m_container = container; }
2052
2053 /**
2054 Returns @true if the selection is valid.
2055 */
2056 bool IsValid() const { return m_ranges.GetCount() > 0 && GetContainer(); }
2057
2058 /**
2059 Returns the selection appropriate to the specified object, if any; returns an empty array if none
2060 at the level of the object's container.
2061 */
2062 wxRichTextRangeArray GetSelectionForObject(wxRichTextObject* obj) const;
2063
2064 /**
2065 Returns @true if the given position is within the selection.
2066 */
2067 bool WithinSelection(long pos, wxRichTextObject* obj) const;
2068
2069 /**
2070 Returns @true if the given position is within the selection.
2071
2072 */
2073 bool WithinSelection(long pos) const { return WithinSelection(pos, m_ranges); }
2074
2075 /**
2076 Returns @true if the given position is within the selection range.
2077 */
2078 static bool WithinSelection(long pos, const wxRichTextRangeArray& ranges);
2079
2080 /**
2081 Returns @true if the given range is within the selection range.
2082 */
2083 static bool WithinSelection(const wxRichTextRange& range, const wxRichTextRangeArray& ranges);
2084
2085 wxRichTextRangeArray m_ranges;
2086 wxRichTextParagraphLayoutBox* m_container;
2087 };
2088
2089 /**
2090 @class wxRichTextDrawingContext
2091
2092 A class for passing information to drawing and measuring functions.
2093
2094 @library{wxrichtext}
2095 @category{richtext}
2096
2097 @see wxRichTextBuffer, wxRichTextCtrl
2098 */
2099
2100 class WXDLLIMPEXP_RICHTEXT wxRichTextDrawingContext: public wxObject
2101 {
2102 DECLARE_CLASS(wxRichTextDrawingContext)
2103 public:
2104
2105 /**
2106 Pass the buffer to the context so the context can retrieve information
2107 such as virtual attributes.
2108 */
2109 wxRichTextDrawingContext(wxRichTextBuffer* buffer) { Init(); m_buffer = buffer; }
2110
2111 void Init() { m_buffer = NULL; }
2112
2113 /**
2114 Does this object have virtual attributes?
2115 Virtual attributes can be provided for visual cues without
2116 affecting the actual styling.
2117 */
2118 bool HasVirtualAttributes(wxRichTextObject* obj) const;
2119
2120 /**
2121 Returns the virtual attributes for this object.
2122 Virtual attributes can be provided for visual cues without
2123 affecting the actual styling.
2124 */
2125 wxRichTextAttr GetVirtualAttributes(wxRichTextObject* obj) const;
2126
2127 /**
2128 Applies any virtual attributes relevant to this object.
2129 */
2130 bool ApplyVirtualAttributes(wxRichTextAttr& attr, wxRichTextObject* obj) const;
2131
2132 wxRichTextBuffer* m_buffer;
2133 };
2134
2135 /**
2136 @class wxRichTextObject
2137
2138 This is the base for drawable rich text objects.
2139
2140 @library{wxrichtext}
2141 @category{richtext}
2142
2143 @see wxRichTextBuffer, wxRichTextCtrl
2144 */
2145
2146 class WXDLLIMPEXP_RICHTEXT wxRichTextObject: public wxObject
2147 {
2148 DECLARE_CLASS(wxRichTextObject)
2149 public:
2150 /**
2151 Constructor, taking an optional parent pointer.
2152 */
2153 wxRichTextObject(wxRichTextObject* parent = NULL);
2154
2155 virtual ~wxRichTextObject();
2156
2157 // Overridables
2158
2159 /**
2160 Draw the item, within the given range. Some objects may ignore the range (for
2161 example paragraphs) while others must obey it (lines, to implement wrapping)
2162 */
2163 virtual bool Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style) = 0;
2164
2165 /**
2166 Lay the item out at the specified position with the given size constraint.
2167 Layout must set the cached size. @rect is the available space for the object,
2168 and @a parentRect is the container that is used to determine a relative size
2169 or position (for example if a text box must be 50% of the parent text box).
2170 */
2171 virtual bool Layout(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, const wxRect& parentRect, int style) = 0;
2172
2173 /**
2174 Hit-testing: returns a flag indicating hit test details, plus
2175 information about position. @a contextObj is returned to specify what object
2176 position is relevant to, since otherwise there's an ambiguity.
2177 @ obj might not be a child of @a contextObj, since we may be referring to the container itself
2178 if we have no hit on a child - for example if we click outside an object.
2179
2180 The function puts the position in @a textPosition if one is found.
2181 @a pt is in logical units (a zero y position is at the beginning of the buffer).
2182
2183 Pass wxRICHTEXT_HITTEST_NO_NESTED_OBJECTS if you only want to consider objects
2184 directly under the object you are calling HitTest on. Otherwise, it will recurse
2185 and potentially find a nested object.
2186
2187 @return One of the ::wxRichTextHitTestFlags values.
2188 */
2189
2190 virtual int HitTest(wxDC& dc, wxRichTextDrawingContext& context, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags = 0);
2191
2192 /**
2193 Finds the absolute position and row height for the given character position.
2194 */
2195 virtual bool FindPosition(wxDC& WXUNUSED(dc), wxRichTextDrawingContext& WXUNUSED(context), long WXUNUSED(index), wxPoint& WXUNUSED(pt), int* WXUNUSED(height), bool WXUNUSED(forceLineStart)) { return false; }
2196
2197 /**
2198 Returns the best size, i.e. the ideal starting size for this object irrespective
2199 of available space. For a short text string, it will be the size that exactly encloses
2200 the text. For a longer string, it might use the parent width for example.
2201 */
2202 virtual wxSize GetBestSize() const { return m_size; }
2203
2204 /**
2205 Returns the object size for the given range. Returns @false if the range
2206 is invalid for this object.
2207 */
2208
2209 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const = 0;
2210
2211 /**
2212 Do a split from @a pos, returning an object containing the second part, and setting
2213 the first part in 'this'.
2214 */
2215 virtual wxRichTextObject* DoSplit(long WXUNUSED(pos)) { return NULL; }
2216
2217 /**
2218 Calculates the range of the object. By default, guess that the object is 1 unit long.
2219 */
2220 virtual void CalculateRange(long start, long& end) { end = start ; m_range.SetRange(start, end); }
2221
2222 /**
2223 Deletes the given range.
2224 */
2225 virtual bool DeleteRange(const wxRichTextRange& WXUNUSED(range)) { return false; }
2226
2227 /**
2228 Returns @true if the object is empty.
2229 */
2230 virtual bool IsEmpty() const { return false; }
2231
2232 /**
2233 Returns @true if this class of object is floatable.
2234 */
2235 virtual bool IsFloatable() const { return false; }
2236
2237 /**
2238 Returns @true if this object is currently floating.
2239 */
2240 virtual bool IsFloating() const { return GetAttributes().GetTextBoxAttr().IsFloating(); }
2241
2242 /**
2243 Returns the floating direction.
2244 */
2245 virtual int GetFloatDirection() const { return GetAttributes().GetTextBoxAttr().GetFloatMode(); }
2246
2247 /**
2248 Returns any text in this object for the given range.
2249 */
2250 virtual wxString GetTextForRange(const wxRichTextRange& WXUNUSED(range)) const { return wxEmptyString; }
2251
2252 /**
2253 Returns @true if this object can merge itself with the given one.
2254 */
2255 virtual bool CanMerge(wxRichTextObject* WXUNUSED(object)) const { return false; }
2256
2257 /**
2258 Returns @true if this object merged itself with the given one.
2259 The calling code will then delete the given object.
2260 */
2261 virtual bool Merge(wxRichTextObject* WXUNUSED(object)) { return false; }
2262
2263 /**
2264 Dump object data to the given output stream for debugging.
2265 */
2266 virtual void Dump(wxTextOutputStream& stream);
2267
2268 /**
2269 Returns @true if we can edit the object's properties via a GUI.
2270 */
2271 virtual bool CanEditProperties() const { return false; }
2272
2273 /**
2274 Edits the object's properties via a GUI.
2275 */
2276 virtual bool EditProperties(wxWindow* WXUNUSED(parent), wxRichTextBuffer* WXUNUSED(buffer)) { return false; }
2277
2278 /**
2279 Returns the label to be used for the properties context menu item.
2280 */
2281 virtual wxString GetPropertiesMenuLabel() const { return wxEmptyString; }
2282
2283 /**
2284 Returns @true if objects of this class can accept the focus, i.e. a call to SetFocusObject
2285 is possible. For example, containers supporting text, such as a text box object, can accept the focus,
2286 but a table can't (set the focus to individual cells instead).
2287 */
2288 virtual bool AcceptsFocus() const { return false; }
2289
2290 #if wxUSE_XML
2291 /**
2292 Imports this object from XML.
2293 */
2294 virtual bool ImportFromXML(wxRichTextBuffer* buffer, wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse);
2295 #endif
2296
2297 #if wxRICHTEXT_HAVE_DIRECT_OUTPUT
2298 /**
2299 Exports this object directly to the given stream, bypassing the creation of a wxXmlNode hierarchy.
2300 This method is considerably faster than creating a tree first. However, both versions of ExportXML must be
2301 implemented so that if the tree method is made efficient in the future, we can deprecate the
2302 more verbose direct output method. Compiled only if wxRICHTEXT_HAVE_DIRECT_OUTPUT is defined (on by default).
2303 */
2304 virtual bool ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler);
2305 #endif
2306
2307 #if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
2308 /**
2309 Exports this object to the given parent node, usually creating at least one child node.
2310 This method is less efficient than the direct-to-stream method but is retained to allow for
2311 switching to this method if we make it more efficient. Compiled only if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT is defined
2312 (on by default).
2313 */
2314 virtual bool ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler);
2315 #endif
2316
2317 /**
2318 Returns @true if this object takes note of paragraph attributes (text and image objects don't).
2319 */
2320 virtual bool UsesParagraphAttributes() const { return true; }
2321
2322 /**
2323 Returns the XML node name of this object. This must be overridden for wxXmlNode-base XML export to work.
2324 */
2325 virtual wxString GetXMLNodeName() const { return wxT("unknown"); }
2326
2327 /**
2328 Invalidates the object at the given range. With no argument, invalidates the whole object.
2329 */
2330 virtual void Invalidate(const wxRichTextRange& invalidRange = wxRICHTEXT_ALL);
2331
2332 /**
2333 Returns @true if this object can handle the selections of its children, fOr example a table.
2334 Required for composite selection handling to work.
2335 */
2336 virtual bool HandlesChildSelections() const { return false; }
2337
2338 /**
2339 Returns a selection object specifying the selections between start and end character positions.
2340 For example, a table would deduce what cells (of range length 1) are selected when dragging across the table.
2341 */
2342 virtual wxRichTextSelection GetSelection(long WXUNUSED(start), long WXUNUSED(end)) const { return wxRichTextSelection(); }
2343
2344 // Accessors
2345
2346 /**
2347 Gets the cached object size as calculated by Layout.
2348 */
2349 virtual wxSize GetCachedSize() const { return m_size; }
2350
2351 /**
2352 Sets the cached object size as calculated by Layout.
2353 */
2354 virtual void SetCachedSize(const wxSize& sz) { m_size = sz; }
2355
2356 /**
2357 Gets the maximum object size as calculated by Layout. This allows
2358 us to fit an object to its contents or allocate extra space if required.
2359 */
2360 virtual wxSize GetMaxSize() const { return m_maxSize; }
2361
2362 /**
2363 Sets the maximum object size as calculated by Layout. This allows
2364 us to fit an object to its contents or allocate extra space if required.
2365 */
2366 virtual void SetMaxSize(const wxSize& sz) { m_maxSize = sz; }
2367
2368 /**
2369 Gets the minimum object size as calculated by Layout. This allows
2370 us to constrain an object to its absolute minimum size if necessary.
2371 */
2372 virtual wxSize GetMinSize() const { return m_minSize; }
2373
2374 /**
2375 Sets the minimum object size as calculated by Layout. This allows
2376 us to constrain an object to its absolute minimum size if necessary.
2377 */
2378 virtual void SetMinSize(const wxSize& sz) { m_minSize = sz; }
2379
2380 /**
2381 Gets the 'natural' size for an object. For an image, it would be the
2382 image size.
2383 */
2384 virtual wxTextAttrSize GetNaturalSize() const { return wxTextAttrSize(); }
2385
2386 /**
2387 Returns the object position in pixels.
2388 */
2389 virtual wxPoint GetPosition() const { return m_pos; }
2390
2391 /**
2392 Sets the object position in pixels.
2393 */
2394 virtual void SetPosition(const wxPoint& pos) { m_pos = pos; }
2395
2396 /**
2397 Returns the absolute object position, by traversing up the child/parent hierarchy.
2398 TODO: may not be needed, if all object positions are in fact relative to the
2399 top of the coordinate space.
2400 */
2401 virtual wxPoint GetAbsolutePosition() const;
2402
2403 /**
2404 Returns the rectangle enclosing the object.
2405 */
2406 virtual wxRect GetRect() const { return wxRect(GetPosition(), GetCachedSize()); }
2407
2408 /**
2409 Sets the object's range within its container.
2410 */
2411 void SetRange(const wxRichTextRange& range) { m_range = range; }
2412
2413 /**
2414 Returns the object's range.
2415 */
2416 const wxRichTextRange& GetRange() const { return m_range; }
2417
2418 /**
2419 Returns the object's range.
2420 */
2421 wxRichTextRange& GetRange() { return m_range; }
2422
2423 /**
2424 Set the object's own range, for a top-level object with its own position space.
2425 */
2426 void SetOwnRange(const wxRichTextRange& range) { m_ownRange = range; }
2427
2428 /**
2429 Returns the object's own range (valid if top-level).
2430 */
2431 const wxRichTextRange& GetOwnRange() const { return m_ownRange; }
2432
2433 /**
2434 Returns the object's own range (valid if top-level).
2435 */
2436 wxRichTextRange& GetOwnRange() { return m_ownRange; }
2437
2438 /**
2439 Returns the object's own range only if a top-level object.
2440 */
2441 wxRichTextRange GetOwnRangeIfTopLevel() const { return IsTopLevel() ? m_ownRange : m_range; }
2442
2443 /**
2444 Returns @true if this object is composite.
2445 */
2446 virtual bool IsComposite() const { return false; }
2447
2448 /**
2449 Returns @true if no user editing can be done inside the object. This returns @true for simple objects,
2450 @false for most composite objects, but @true for fields, which if composite, should not be user-edited.
2451 */
2452 virtual bool IsAtomic() const { return true; }
2453
2454 /**
2455 Returns a pointer to the parent object.
2456 */
2457 virtual wxRichTextObject* GetParent() const { return m_parent; }
2458
2459 /**
2460 Sets the pointer to the parent object.
2461 */
2462 virtual void SetParent(wxRichTextObject* parent) { m_parent = parent; }
2463
2464 /**
2465 Returns the top-level container of this object.
2466 May return itself if it's a container; use GetParentContainer to return
2467 a different container.
2468 */
2469 virtual wxRichTextParagraphLayoutBox* GetContainer() const;
2470
2471 /**
2472 Returns the top-level container of this object.
2473 Returns a different container than itself, unless there's no parent, in which case it will return NULL.
2474 */
2475 virtual wxRichTextParagraphLayoutBox* GetParentContainer() const { return GetParent() ? GetParent()->GetContainer() : GetContainer(); }
2476
2477 /**
2478 Set the margin around the object, in pixels.
2479 */
2480 virtual void SetMargins(int margin);
2481
2482 /**
2483 Set the margin around the object, in pixels.
2484 */
2485 virtual void SetMargins(int leftMargin, int rightMargin, int topMargin, int bottomMargin);
2486
2487 /**
2488 Returns the left margin of the object, in pixels.
2489 */
2490 virtual int GetLeftMargin() const;
2491
2492 /**
2493 Returns the right margin of the object, in pixels.
2494 */
2495 virtual int GetRightMargin() const;
2496
2497 /**
2498 Returns the top margin of the object, in pixels.
2499 */
2500 virtual int GetTopMargin() const;
2501
2502 /**
2503 Returns the bottom margin of the object, in pixels.
2504 */
2505 virtual int GetBottomMargin() const;
2506
2507 /**
2508 Calculates the available content space in the given rectangle, given the
2509 margins, border and padding specified in the object's attributes.
2510 */
2511 virtual wxRect GetAvailableContentArea(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& outerRect) const;
2512
2513 /**
2514 Lays out the object first with a given amount of space, and then if no width was specified in attr,
2515 lays out the object again using the minimum size. @a availableParentSpace is the maximum space
2516 for the object, whereas @a availableContainerSpace is the container with which relative positions and
2517 sizes should be computed. For example, a text box whose space has already been constrained
2518 in a previous layout pass to @a availableParentSpace, but should have a width of 50% of @a availableContainerSpace.
2519 (If these two rects were the same, a 2nd pass could see the object getting too small.)
2520 */
2521 virtual bool LayoutToBestSize(wxDC& dc, wxRichTextDrawingContext& context, wxRichTextBuffer* buffer,
2522 const wxRichTextAttr& parentAttr, const wxRichTextAttr& attr,
2523 const wxRect& availableParentSpace, const wxRect& availableContainerSpace, int style);
2524
2525 /**
2526 Sets the object's attributes.
2527 */
2528 void SetAttributes(const wxRichTextAttr& attr) { m_attributes = attr; }
2529
2530 /**
2531 Returns the object's attributes.
2532 */
2533 const wxRichTextAttr& GetAttributes() const { return m_attributes; }
2534
2535 /**
2536 Returns the object's attributes.
2537 */
2538 wxRichTextAttr& GetAttributes() { return m_attributes; }
2539
2540 /**
2541 Returns the object's properties.
2542 */
2543 wxRichTextProperties& GetProperties() { return m_properties; }
2544
2545 /**
2546 Returns the object's properties.
2547 */
2548 const wxRichTextProperties& GetProperties() const { return m_properties; }
2549
2550 /**
2551 Sets the object's properties.
2552 */
2553 void SetProperties(const wxRichTextProperties& props) { m_properties = props; }
2554
2555 /**
2556 Sets the stored descent value.
2557 */
2558 void SetDescent(int descent) { m_descent = descent; }
2559
2560 /**
2561 Returns the stored descent value.
2562 */
2563 int GetDescent() const { return m_descent; }
2564
2565 /**
2566 Returns the containing buffer.
2567 */
2568 wxRichTextBuffer* GetBuffer() const;
2569
2570 /**
2571 Sets the identifying name for this object as a property using the "name" key.
2572 */
2573 void SetName(const wxString& name) { m_properties.SetProperty(wxT("name"), name); }
2574
2575 /**
2576 Returns the identifying name for this object from the properties, using the "name" key.
2577 */
2578 wxString GetName() const { return m_properties.GetPropertyString(wxT("name")); }
2579
2580 /**
2581 Returns @true if this object is top-level, i.e. contains its own paragraphs, such as a text box.
2582 */
2583 virtual bool IsTopLevel() const { return false; }
2584
2585 /**
2586 Returns @true if the object will be shown, @false otherwise.
2587 */
2588 bool IsShown() const { return m_show; }
2589
2590 // Operations
2591
2592 /**
2593 Call to show or hide this object. This function does not cause the content to be
2594 laid out or redrawn.
2595 */
2596 virtual void Show(bool show) { m_show = show; }
2597
2598 /**
2599 Clones the object.
2600 */
2601 virtual wxRichTextObject* Clone() const { return NULL; }
2602
2603 /**
2604 Copies the object.
2605 */
2606 void Copy(const wxRichTextObject& obj);
2607
2608 /**
2609 Reference-counting allows us to use the same object in multiple
2610 lists (not yet used).
2611 */
2612
2613 void Reference() { m_refCount ++; }
2614
2615 /**
2616 Reference-counting allows us to use the same object in multiple
2617 lists (not yet used).
2618 */
2619 void Dereference();
2620
2621 /**
2622 Moves the object recursively, by adding the offset from old to new.
2623 */
2624 virtual void Move(const wxPoint& pt);
2625
2626 /**
2627 Converts units in tenths of a millimetre to device units.
2628 */
2629 int ConvertTenthsMMToPixels(wxDC& dc, int units) const;
2630
2631 /**
2632 Converts units in tenths of a millimetre to device units.
2633 */
2634 static int ConvertTenthsMMToPixels(int ppi, int units, double scale = 1.0);
2635
2636 /**
2637 Convert units in pixels to tenths of a millimetre.
2638 */
2639 int ConvertPixelsToTenthsMM(wxDC& dc, int pixels) const;
2640
2641 /**
2642 Convert units in pixels to tenths of a millimetre.
2643 */
2644 static int ConvertPixelsToTenthsMM(int ppi, int pixels, double scale = 1.0);
2645
2646 /**
2647 Draws the borders and background for the given rectangle and attributes.
2648 @a boxRect is taken to be the outer margin box, not the box around the content.
2649 */
2650 static bool DrawBoxAttributes(wxDC& dc, wxRichTextBuffer* buffer, const wxRichTextAttr& attr, const wxRect& boxRect, int flags = 0);
2651
2652 /**
2653 Draws a border.
2654 */
2655 static bool DrawBorder(wxDC& dc, wxRichTextBuffer* buffer, const wxTextAttrBorders& attr, const wxRect& rect, int flags = 0);
2656
2657 /**
2658 Returns the various rectangles of the box model in pixels. You can either specify @a contentRect (inner)
2659 or @a marginRect (outer), and the other must be the default rectangle (no width or height).
2660 Note that the outline doesn't affect the position of the rectangle, it's drawn in whatever space
2661 is available.
2662 */
2663 static bool GetBoxRects(wxDC& dc, wxRichTextBuffer* buffer, const wxRichTextAttr& attr, wxRect& marginRect, wxRect& borderRect, wxRect& contentRect, wxRect& paddingRect, wxRect& outlineRect);
2664
2665 /**
2666 Returns the total margin for the object in pixels, taking into account margin, padding and border size.
2667 */
2668 static bool GetTotalMargin(wxDC& dc, wxRichTextBuffer* buffer, const wxRichTextAttr& attr, int& leftMargin, int& rightMargin,
2669 int& topMargin, int& bottomMargin);
2670
2671 /**
2672 Returns the rectangle which the child has available to it given restrictions specified in the
2673 child attribute, e.g. 50% width of the parent, 400 pixels, x position 20% of the parent, etc.
2674 availableContainerSpace might be a parent that the cell has to compute its width relative to.
2675 E.g. a cell that's 50% of its parent.
2676 */
2677 static wxRect AdjustAvailableSpace(wxDC& dc, wxRichTextBuffer* buffer, const wxRichTextAttr& parentAttr, const wxRichTextAttr& childAttr,
2678 const wxRect& availableParentSpace, const wxRect& availableContainerSpace);
2679
2680 protected:
2681 wxSize m_size;
2682 wxSize m_maxSize;
2683 wxSize m_minSize;
2684 wxPoint m_pos;
2685 int m_descent; // Descent for this object (if any)
2686 int m_refCount;
2687 bool m_show;
2688 wxRichTextObject* m_parent;
2689
2690 // The range of this object (start position to end position)
2691 wxRichTextRange m_range;
2692
2693 // The internal range of this object, if it's a top-level object with its own range space
2694 wxRichTextRange m_ownRange;
2695
2696 // Attributes
2697 wxRichTextAttr m_attributes;
2698
2699 // Properties
2700 wxRichTextProperties m_properties;
2701 };
2702
2703 WX_DECLARE_LIST_WITH_DECL( wxRichTextObject, wxRichTextObjectList, class WXDLLIMPEXP_RICHTEXT );
2704
2705 /**
2706 @class wxRichTextCompositeObject
2707
2708 Objects of this class can contain other objects.
2709
2710 @library{wxrichtext}
2711 @category{richtext}
2712
2713 @see wxRichTextObject, wxRichTextBuffer, wxRichTextCtrl
2714 */
2715
2716 class WXDLLIMPEXP_RICHTEXT wxRichTextCompositeObject: public wxRichTextObject
2717 {
2718 DECLARE_CLASS(wxRichTextCompositeObject)
2719 public:
2720 // Constructors
2721
2722 wxRichTextCompositeObject(wxRichTextObject* parent = NULL);
2723 virtual ~wxRichTextCompositeObject();
2724
2725 // Overridables
2726
2727 virtual int HitTest(wxDC& dc, wxRichTextDrawingContext& context, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags = 0);
2728
2729 virtual bool FindPosition(wxDC& dc, wxRichTextDrawingContext& context, long index, wxPoint& pt, int* height, bool forceLineStart);
2730
2731 virtual void CalculateRange(long start, long& end);
2732
2733 virtual bool DeleteRange(const wxRichTextRange& range);
2734
2735 virtual wxString GetTextForRange(const wxRichTextRange& range) const;
2736
2737 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
2738
2739 virtual void Dump(wxTextOutputStream& stream);
2740
2741 virtual void Invalidate(const wxRichTextRange& invalidRange = wxRICHTEXT_ALL);
2742
2743 // Accessors
2744
2745 /**
2746 Returns the children.
2747 */
2748 wxRichTextObjectList& GetChildren() { return m_children; }
2749 /**
2750 Returns the children.
2751 */
2752 const wxRichTextObjectList& GetChildren() const { return m_children; }
2753
2754 /**
2755 Returns the number of children.
2756 */
2757 size_t GetChildCount() const ;
2758
2759 /**
2760 Returns the nth child.
2761 */
2762 wxRichTextObject* GetChild(size_t n) const ;
2763
2764 /**
2765 Returns @true if this object is composite.
2766 */
2767 virtual bool IsComposite() const { return true; }
2768
2769 /**
2770 Returns @true if no user editing can be done inside the object. This returns @true for simple objects,
2771 @false for most composite objects, but @true for fields, which if composite, should not be user-edited.
2772 */
2773 virtual bool IsAtomic() const { return false; }
2774
2775 /**
2776 Returns true if the buffer is empty.
2777 */
2778 virtual bool IsEmpty() const { return GetChildCount() == 0; }
2779
2780 /**
2781 Returns the child object at the given character position.
2782 */
2783 virtual wxRichTextObject* GetChildAtPosition(long pos) const;
2784
2785 // Operations
2786
2787 void Copy(const wxRichTextCompositeObject& obj);
2788
2789 void operator= (const wxRichTextCompositeObject& obj) { Copy(obj); }
2790
2791 /**
2792 Appends a child, returning the position.
2793 */
2794 size_t AppendChild(wxRichTextObject* child) ;
2795
2796 /**
2797 Inserts the child in front of the given object, or at the beginning.
2798 */
2799 bool InsertChild(wxRichTextObject* child, wxRichTextObject* inFrontOf) ;
2800
2801 /**
2802 Removes and optionally deletes the specified child.
2803 */
2804 bool RemoveChild(wxRichTextObject* child, bool deleteChild = false) ;
2805
2806 /**
2807 Deletes all the children.
2808 */
2809 bool DeleteChildren() ;
2810
2811 /**
2812 Recursively merges all pieces that can be merged.
2813 */
2814 bool Defragment(const wxRichTextRange& range = wxRICHTEXT_ALL);
2815
2816 /**
2817 Moves the object recursively, by adding the offset from old to new.
2818 */
2819 virtual void Move(const wxPoint& pt);
2820
2821 protected:
2822 wxRichTextObjectList m_children;
2823 };
2824
2825 /**
2826 @class wxRichTextParagraphBox
2827
2828 This class knows how to lay out paragraphs.
2829
2830 @library{wxrichtext}
2831 @category{richtext}
2832
2833 @see wxRichTextCompositeObject, wxRichTextObject, wxRichTextBuffer, wxRichTextCtrl
2834 */
2835
2836 class WXDLLIMPEXP_RICHTEXT wxRichTextParagraphLayoutBox: public wxRichTextCompositeObject
2837 {
2838 DECLARE_DYNAMIC_CLASS(wxRichTextParagraphLayoutBox)
2839 public:
2840 // Constructors
2841
2842 wxRichTextParagraphLayoutBox(wxRichTextObject* parent = NULL);
2843 wxRichTextParagraphLayoutBox(const wxRichTextParagraphLayoutBox& obj): wxRichTextCompositeObject() { Init(); Copy(obj); }
2844 ~wxRichTextParagraphLayoutBox();
2845
2846 // Overridables
2847
2848 virtual int HitTest(wxDC& dc, wxRichTextDrawingContext& context, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags = 0);
2849
2850 virtual bool Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
2851
2852 virtual bool Layout(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, const wxRect& parentRect, int style);
2853
2854 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
2855
2856 virtual bool DeleteRange(const wxRichTextRange& range);
2857
2858 virtual wxString GetTextForRange(const wxRichTextRange& range) const;
2859
2860 #if wxUSE_XML
2861 virtual bool ImportFromXML(wxRichTextBuffer* buffer, wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse);
2862 #endif
2863
2864 #if wxRICHTEXT_HAVE_DIRECT_OUTPUT
2865 virtual bool ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler);
2866 #endif
2867
2868 #if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
2869 virtual bool ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler);
2870 #endif
2871
2872 virtual wxString GetXMLNodeName() const { return wxT("paragraphlayout"); }
2873
2874 virtual bool AcceptsFocus() const { return true; }
2875
2876 // Accessors
2877
2878 /**
2879 Associates a control with the buffer, for operations that for example require refreshing the window.
2880 */
2881 void SetRichTextCtrl(wxRichTextCtrl* ctrl) { m_ctrl = ctrl; }
2882
2883 /**
2884 Returns the associated control.
2885 */
2886 wxRichTextCtrl* GetRichTextCtrl() const { return m_ctrl; }
2887
2888 /**
2889 Sets a flag indicating whether the last paragraph is partial or complete.
2890 */
2891 void SetPartialParagraph(bool partialPara) { m_partialParagraph = partialPara; }
2892
2893 /**
2894 Returns a flag indicating whether the last paragraph is partial or complete.
2895 */
2896 bool GetPartialParagraph() const { return m_partialParagraph; }
2897
2898 /**
2899 Returns the style sheet associated with the overall buffer.
2900 */
2901 virtual wxRichTextStyleSheet* GetStyleSheet() const;
2902
2903 virtual bool IsTopLevel() const { return true; }
2904
2905 // Operations
2906
2907 /**
2908 Submits a command to insert paragraphs.
2909 */
2910 bool InsertParagraphsWithUndo(wxRichTextBuffer* buffer, long pos, const wxRichTextParagraphLayoutBox& paragraphs, wxRichTextCtrl* ctrl, int flags = 0);
2911
2912 /**
2913 Submits a command to insert the given text.
2914 */
2915 bool InsertTextWithUndo(wxRichTextBuffer* buffer, long pos, const wxString& text, wxRichTextCtrl* ctrl, int flags = 0);
2916
2917 /**
2918 Submits a command to insert the given text.
2919 */
2920 bool InsertNewlineWithUndo(wxRichTextBuffer* buffer, long pos, wxRichTextCtrl* ctrl, int flags = 0);
2921
2922 /**
2923 Submits a command to insert the given image.
2924 */
2925 bool InsertImageWithUndo(wxRichTextBuffer* buffer, long pos, const wxRichTextImageBlock& imageBlock,
2926 wxRichTextCtrl* ctrl, int flags, const wxRichTextAttr& textAttr);
2927
2928 /**
2929 Submits a command to insert the given field. Field data can be included in properties.
2930
2931 @see wxRichTextField, wxRichTextFieldType, wxRichTextFieldTypeStandard
2932 */
2933 wxRichTextField* InsertFieldWithUndo(wxRichTextBuffer* buffer, long pos, const wxString& fieldType,
2934 const wxRichTextProperties& properties,
2935 wxRichTextCtrl* ctrl, int flags,
2936 const wxRichTextAttr& textAttr);
2937
2938 /**
2939 Returns the style that is appropriate for a new paragraph at this position.
2940 If the previous paragraph has a paragraph style name, looks up the next-paragraph
2941 style.
2942 */
2943 wxRichTextAttr GetStyleForNewParagraph(wxRichTextBuffer* buffer, long pos, bool caretPosition = false, bool lookUpNewParaStyle=false) const;
2944
2945 /**
2946 Inserts an object.
2947 */
2948 wxRichTextObject* InsertObjectWithUndo(wxRichTextBuffer* buffer, long pos, wxRichTextObject *object, wxRichTextCtrl* ctrl, int flags = 0);
2949
2950 /**
2951 Submits a command to delete this range.
2952 */
2953 bool DeleteRangeWithUndo(const wxRichTextRange& range, wxRichTextCtrl* ctrl, wxRichTextBuffer* buffer);
2954
2955 /**
2956 Draws the floating objects in this buffer.
2957 */
2958 void DrawFloats(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
2959
2960 /**
2961 Moves an anchored object to another paragraph.
2962 */
2963 void MoveAnchoredObjectToParagraph(wxRichTextParagraph* from, wxRichTextParagraph* to, wxRichTextObject* obj);
2964
2965 /**
2966 Initializes the object.
2967 */
2968 void Init();
2969
2970 /**
2971 Clears all the children.
2972 */
2973 virtual void Clear();
2974
2975 /**
2976 Clears and initializes with one blank paragraph.
2977 */
2978 virtual void Reset();
2979
2980 /**
2981 Convenience function to add a paragraph of text.
2982 */
2983 virtual wxRichTextRange AddParagraph(const wxString& text, wxRichTextAttr* paraStyle = NULL);
2984
2985 /**
2986 Convenience function to add an image.
2987 */
2988 virtual wxRichTextRange AddImage(const wxImage& image, wxRichTextAttr* paraStyle = NULL);
2989
2990 /**
2991 Adds multiple paragraphs, based on newlines.
2992 */
2993 virtual wxRichTextRange AddParagraphs(const wxString& text, wxRichTextAttr* paraStyle = NULL);
2994
2995 /**
2996 Returns the line at the given position. If @a caretPosition is true, the position is
2997 a caret position, which is normally a smaller number.
2998 */
2999 virtual wxRichTextLine* GetLineAtPosition(long pos, bool caretPosition = false) const;
3000
3001 /**
3002 Returns the line at the given y pixel position, or the last line.
3003 */
3004 virtual wxRichTextLine* GetLineAtYPosition(int y) const;
3005
3006 /**
3007 Returns the paragraph at the given character or caret position.
3008 */
3009 virtual wxRichTextParagraph* GetParagraphAtPosition(long pos, bool caretPosition = false) const;
3010
3011 /**
3012 Returns the line size at the given position.
3013 */
3014 virtual wxSize GetLineSizeAtPosition(long pos, bool caretPosition = false) const;
3015
3016 /**
3017 Given a position, returns the number of the visible line (potentially many to a paragraph),
3018 starting from zero at the start of the buffer. We also have to pass a bool (@a startOfLine)
3019 that indicates whether the caret is being shown at the end of the previous line or at the start
3020 of the next, since the caret can be shown at two visible positions for the same underlying
3021 position.
3022 */
3023 virtual long GetVisibleLineNumber(long pos, bool caretPosition = false, bool startOfLine = false) const;
3024
3025 /**
3026 Given a line number, returns the corresponding wxRichTextLine object.
3027 */
3028 virtual wxRichTextLine* GetLineForVisibleLineNumber(long lineNumber) const;
3029
3030 /**
3031 Returns the leaf object in a paragraph at this position.
3032 */
3033 virtual wxRichTextObject* GetLeafObjectAtPosition(long position) const;
3034
3035 /**
3036 Returns the paragraph by number.
3037 */
3038 virtual wxRichTextParagraph* GetParagraphAtLine(long paragraphNumber) const;
3039
3040 /**
3041 Returns the paragraph for a given line.
3042 */
3043 virtual wxRichTextParagraph* GetParagraphForLine(wxRichTextLine* line) const;
3044
3045 /**
3046 Returns the length of the paragraph.
3047 */
3048 virtual int GetParagraphLength(long paragraphNumber) const;
3049
3050 /**
3051 Returns the number of paragraphs.
3052 */
3053 virtual int GetParagraphCount() const { return static_cast<int>(GetChildCount()); }
3054
3055 /**
3056 Returns the number of visible lines.
3057 */
3058 virtual int GetLineCount() const;
3059
3060 /**
3061 Returns the text of the paragraph.
3062 */
3063 virtual wxString GetParagraphText(long paragraphNumber) const;
3064
3065 /**
3066 Converts zero-based line column and paragraph number to a position.
3067 */
3068 virtual long XYToPosition(long x, long y) const;
3069
3070 /**
3071 Converts a zero-based position to line column and paragraph number.
3072 */
3073 virtual bool PositionToXY(long pos, long* x, long* y) const;
3074
3075 /**
3076 Sets the attributes for the given range. Pass flags to determine how the
3077 attributes are set.
3078
3079 The end point of range is specified as the last character position of the span
3080 of text. So, for example, to set the style for a character at position 5,
3081 use the range (5,5).
3082 This differs from the wxRichTextCtrl API, where you would specify (5,6).
3083
3084 @a flags may contain a bit list of the following values:
3085 - wxRICHTEXT_SETSTYLE_NONE: no style flag.
3086 - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this operation should be
3087 undoable.
3088 - wxRICHTEXT_SETSTYLE_OPTIMIZE: specifies that the style should not be applied
3089 if the combined style at this point is already the style in question.
3090 - wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY: specifies that the style should only be
3091 applied to paragraphs, and not the content.
3092 This allows content styling to be preserved independently from that
3093 of e.g. a named paragraph style.
3094 - wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY: specifies that the style should only be
3095 applied to characters, and not the paragraph.
3096 This allows content styling to be preserved independently from that
3097 of e.g. a named paragraph style.
3098 - wxRICHTEXT_SETSTYLE_RESET: resets (clears) the existing style before applying
3099 the new style.
3100 - wxRICHTEXT_SETSTYLE_REMOVE: removes the specified style.
3101 Only the style flags are used in this operation.
3102 */
3103 virtual bool SetStyle(const wxRichTextRange& range, const wxRichTextAttr& style, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
3104
3105 /**
3106 Sets the attributes for the given object only, for example the box attributes for a text box.
3107 */
3108 virtual void SetStyle(wxRichTextObject *obj, const wxRichTextAttr& textAttr, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
3109
3110 /**
3111 Returns the combined text attributes for this position.
3112
3113 This function gets the @e uncombined style - that is, the attributes associated
3114 with the paragraph or character content, and not necessarily the combined
3115 attributes you see on the screen. To get the combined attributes, use GetStyle().
3116 If you specify (any) paragraph attribute in @e style's flags, this function
3117 will fetch the paragraph attributes.
3118 Otherwise, it will return the character attributes.
3119 */
3120 virtual bool GetStyle(long position, wxRichTextAttr& style);
3121
3122 /**
3123 Returns the content (uncombined) attributes for this position.
3124 */
3125 virtual bool GetUncombinedStyle(long position, wxRichTextAttr& style);
3126
3127 /**
3128 Implementation helper for GetStyle. If combineStyles is true, combine base, paragraph and
3129 context attributes.
3130 */
3131 virtual bool DoGetStyle(long position, wxRichTextAttr& style, bool combineStyles = true);
3132
3133 /**
3134 This function gets a style representing the common, combined attributes in the
3135 given range.
3136 Attributes which have different values within the specified range will not be
3137 included the style flags.
3138
3139 The function is used to get the attributes to display in the formatting dialog:
3140 the user can edit the attributes common to the selection, and optionally specify the
3141 values of further attributes to be applied uniformly.
3142
3143 To apply the edited attributes, you can use SetStyle() specifying
3144 the wxRICHTEXT_SETSTYLE_OPTIMIZE flag, which will only apply attributes that
3145 are different from the @e combined attributes within the range.
3146 So, the user edits the effective, displayed attributes for the range,
3147 but his choice won't be applied unnecessarily to content. As an example,
3148 say the style for a paragraph specifies bold, but the paragraph text doesn't
3149 specify a weight.
3150 The combined style is bold, and this is what the user will see on-screen and
3151 in the formatting dialog. The user now specifies red text, in addition to bold.
3152 When applying with SetStyle(), the content font weight attributes won't be
3153 changed to bold because this is already specified by the paragraph.
3154 However the text colour attributes @e will be changed to show red.
3155 */
3156 virtual bool GetStyleForRange(const wxRichTextRange& range, wxRichTextAttr& style);
3157
3158 /**
3159 Combines @a style with @a currentStyle for the purpose of summarising the attributes of a range of
3160 content.
3161 */
3162 bool CollectStyle(wxRichTextAttr& currentStyle, const wxRichTextAttr& style, wxRichTextAttr& clashingAttr, wxRichTextAttr& absentAttr);
3163
3164 //@{
3165 /**
3166 Sets the list attributes for the given range, passing flags to determine how
3167 the attributes are set.
3168 Either the style definition or the name of the style definition (in the current
3169 sheet) can be passed.
3170
3171 @a flags is a bit list of the following:
3172 - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
3173 - wxRICHTEXT_SETSTYLE_RENUMBER: specifies that numbering should start from
3174 @a startFrom, otherwise existing attributes are used.
3175 - wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL: specifies that @a listLevel should be used
3176 as the level for all paragraphs, otherwise the current indentation will be used.
3177
3178 @see NumberList(), PromoteList(), ClearListStyle().
3179 */
3180 virtual bool SetListStyle(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
3181 virtual bool SetListStyle(const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
3182 //@}
3183
3184 /**
3185 Clears the list style from the given range, clearing list-related attributes
3186 and applying any named paragraph style associated with each paragraph.
3187
3188 @a flags is a bit list of the following:
3189 - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
3190
3191 @see SetListStyle(), PromoteList(), NumberList()
3192 */
3193 virtual bool ClearListStyle(const wxRichTextRange& range, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
3194
3195 //@{
3196 /**
3197 Numbers the paragraphs in the given range.
3198
3199 Pass flags to determine how the attributes are set.
3200 Either the style definition or the name of the style definition (in the current
3201 sheet) can be passed.
3202
3203 @a flags is a bit list of the following:
3204 - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
3205 - wxRICHTEXT_SETSTYLE_RENUMBER: specifies that numbering should start from
3206 @a startFrom, otherwise existing attributes are used.
3207 - wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL: specifies that @a listLevel should be used
3208 as the level for all paragraphs, otherwise the current indentation will be used.
3209
3210 @a def can be NULL to indicate that the existing list style should be used.
3211
3212 @see SetListStyle(), PromoteList(), ClearListStyle()
3213 */
3214 virtual bool NumberList(const wxRichTextRange& range, wxRichTextListStyleDefinition* def = NULL, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
3215 virtual bool NumberList(const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
3216 //@}
3217
3218 //@{
3219 /**
3220 Promotes the list items within the given range.
3221 A positive @a promoteBy produces a smaller indent, and a negative number
3222 produces a larger indent. Pass flags to determine how the attributes are set.
3223 Either the style definition or the name of the style definition (in the current
3224 sheet) can be passed.
3225
3226 @a flags is a bit list of the following:
3227 - wxRICHTEXT_SETSTYLE_WITH_UNDO: specifies that this command will be undoable.
3228 - wxRICHTEXT_SETSTYLE_RENUMBER: specifies that numbering should start from
3229 @a startFrom, otherwise existing attributes are used.
3230 - wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL: specifies that @a listLevel should be used
3231 as the level for all paragraphs, otherwise the current indentation will be used.
3232
3233 @see SetListStyle(), SetListStyle(), ClearListStyle()
3234 */
3235 virtual bool PromoteList(int promoteBy, const wxRichTextRange& range, wxRichTextListStyleDefinition* def = NULL, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int specifiedLevel = -1);
3236 virtual bool PromoteList(int promoteBy, const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int specifiedLevel = -1);
3237 //@}
3238
3239 /**
3240 Helper for NumberList and PromoteList, that does renumbering and promotion simultaneously
3241 @a def can be NULL/empty to indicate that the existing list style should be used.
3242 */
3243 virtual bool DoNumberList(const wxRichTextRange& range, const wxRichTextRange& promotionRange, int promoteBy, wxRichTextListStyleDefinition* def, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
3244
3245 /**
3246 Fills in the attributes for numbering a paragraph after previousParagraph.
3247 */
3248 virtual bool FindNextParagraphNumber(wxRichTextParagraph* previousParagraph, wxRichTextAttr& attr) const;
3249
3250 /**
3251 Sets the properties for the given range, passing flags to determine how the
3252 attributes are set. You can merge properties or replace them.
3253
3254 The end point of range is specified as the last character position of the span
3255 of text, plus one. So, for example, to set the properties for a character at
3256 position 5, use the range (5,6).
3257
3258 @a flags may contain a bit list of the following values:
3259 - wxRICHTEXT_SETPROPERTIES_NONE: no flag.
3260 - wxRICHTEXT_SETPROPERTIES_WITH_UNDO: specifies that this operation should be
3261 undoable.
3262 - wxRICHTEXT_SETPROPERTIES_PARAGRAPHS_ONLY: specifies that the properties should only be
3263 applied to paragraphs, and not the content.
3264 - wxRICHTEXT_SETPROPERTIES_CHARACTERS_ONLY: specifies that the properties should only be
3265 applied to characters, and not the paragraph.
3266 - wxRICHTEXT_SETPROPERTIES_RESET: resets (clears) the existing properties before applying
3267 the new properties.
3268 - wxRICHTEXT_SETPROPERTIES_REMOVE: removes the specified properties.
3269 */
3270 virtual bool SetProperties(const wxRichTextRange& range, const wxRichTextProperties& properties, int flags = wxRICHTEXT_SETPROPERTIES_WITH_UNDO);
3271
3272 /**
3273 Test if this whole range has character attributes of the specified kind. If any
3274 of the attributes are different within the range, the test fails. You
3275 can use this to implement, for example, bold button updating. style must have
3276 flags indicating which attributes are of interest.
3277 */
3278 virtual bool HasCharacterAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const;
3279
3280 /**
3281 Test if this whole range has paragraph attributes of the specified kind. If any
3282 of the attributes are different within the range, the test fails. You
3283 can use this to implement, for example, centering button updating. style must have
3284 flags indicating which attributes are of interest.
3285 */
3286 virtual bool HasParagraphAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const;
3287
3288 virtual wxRichTextObject* Clone() const { return new wxRichTextParagraphLayoutBox(*this); }
3289
3290 /**
3291 Prepares the content just before insertion (or after buffer reset).
3292 Currently is only called if undo mode is on.
3293 */
3294 virtual void PrepareContent(wxRichTextParagraphLayoutBox& container);
3295
3296 /**
3297 Insert fragment into this box at the given position. If partialParagraph is true,
3298 it is assumed that the last (or only) paragraph is just a piece of data with no paragraph
3299 marker.
3300 */
3301 virtual bool InsertFragment(long position, wxRichTextParagraphLayoutBox& fragment);
3302
3303 /**
3304 Make a copy of the fragment corresponding to the given range, putting it in @a fragment.
3305 */
3306 virtual bool CopyFragment(const wxRichTextRange& range, wxRichTextParagraphLayoutBox& fragment);
3307
3308 /**
3309 Apply the style sheet to the buffer, for example if the styles have changed.
3310 */
3311 virtual bool ApplyStyleSheet(wxRichTextStyleSheet* styleSheet);
3312
3313 void Copy(const wxRichTextParagraphLayoutBox& obj);
3314
3315 void operator= (const wxRichTextParagraphLayoutBox& obj) { Copy(obj); }
3316
3317 /**
3318 Calculate ranges.
3319 */
3320 virtual void UpdateRanges();
3321
3322 /**
3323 Get all the text.
3324 */
3325 virtual wxString GetText() const;
3326
3327 /**
3328 Sets the default style, affecting the style currently being applied
3329 (for example, setting the default style to bold will cause subsequently
3330 inserted text to be bold).
3331
3332 This is not cumulative - setting the default style will replace the previous
3333 default style.
3334
3335 Setting it to a default attribute object makes new content take on the 'basic' style.
3336 */
3337 virtual bool SetDefaultStyle(const wxRichTextAttr& style);
3338
3339 /**
3340 Returns the current default style, affecting the style currently being applied
3341 (for example, setting the default style to bold will cause subsequently
3342 inserted text to be bold).
3343 */
3344 virtual const wxRichTextAttr& GetDefaultStyle() const { return m_defaultAttributes; }
3345
3346 /**
3347 Sets the basic (overall) style. This is the style of the whole
3348 buffer before further styles are applied, unlike the default style, which
3349 only affects the style currently being applied (for example, setting the default
3350 style to bold will cause subsequently inserted text to be bold).
3351 */
3352 virtual void SetBasicStyle(const wxRichTextAttr& style) { m_attributes = style; }
3353
3354 /**
3355 Returns the basic (overall) style.
3356
3357 This is the style of the whole buffer before further styles are applied,
3358 unlike the default style, which only affects the style currently being
3359 applied (for example, setting the default style to bold will cause
3360 subsequently inserted text to be bold).
3361 */
3362 virtual const wxRichTextAttr& GetBasicStyle() const { return m_attributes; }
3363
3364 /**
3365 Invalidates the buffer. With no argument, invalidates whole buffer.
3366 */
3367 virtual void Invalidate(const wxRichTextRange& invalidRange = wxRICHTEXT_ALL);
3368
3369 /**
3370 Do the (in)validation for this object only.
3371 */
3372 virtual void DoInvalidate(const wxRichTextRange& invalidRange);
3373
3374 /**
3375 Do the (in)validation both up and down the hierarchy.
3376 */
3377 virtual void InvalidateHierarchy(const wxRichTextRange& invalidRange = wxRICHTEXT_ALL);
3378
3379 /**
3380 Gather information about floating objects. If untilObj is non-NULL,
3381 will stop getting information if the current object is this, since we
3382 will collect the rest later.
3383 */
3384 virtual bool UpdateFloatingObjects(const wxRect& availableRect, wxRichTextObject* untilObj = NULL);
3385
3386 /**
3387 Get invalid range, rounding to entire paragraphs if argument is true.
3388 */
3389 wxRichTextRange GetInvalidRange(bool wholeParagraphs = false) const;
3390
3391 /**
3392 Returns @true if this object needs layout.
3393 */
3394 bool IsDirty() const { return m_invalidRange != wxRICHTEXT_NONE; }
3395
3396 /**
3397 Returns the wxRichTextFloatCollector of this object.
3398 */
3399 wxRichTextFloatCollector* GetFloatCollector() { return m_floatCollector; }
3400
3401 /**
3402 Returns the number of floating objects at this level.
3403 */
3404 int GetFloatingObjectCount() const;
3405
3406 /**
3407 Returns a list of floating objects.
3408 */
3409 bool GetFloatingObjects(wxRichTextObjectList& objects) const;
3410
3411 protected:
3412 wxRichTextCtrl* m_ctrl;
3413 wxRichTextAttr m_defaultAttributes;
3414
3415 // The invalidated range that will need full layout
3416 wxRichTextRange m_invalidRange;
3417
3418 // Is the last paragraph partial or complete?
3419 bool m_partialParagraph;
3420
3421 // The floating layout state
3422 wxRichTextFloatCollector* m_floatCollector;
3423 };
3424
3425 /**
3426 @class wxRichTextBox
3427
3428 This class implements a floating or inline text box, containing paragraphs.
3429
3430 @library{wxrichtext}
3431 @category{richtext}
3432
3433 @see wxRichTextParagraphLayoutBox, wxRichTextObject, wxRichTextBuffer, wxRichTextCtrl
3434 */
3435
3436 class WXDLLIMPEXP_RICHTEXT wxRichTextBox: public wxRichTextParagraphLayoutBox
3437 {
3438 DECLARE_DYNAMIC_CLASS(wxRichTextBox)
3439 public:
3440 // Constructors
3441
3442 /**
3443 Default constructor; optionally pass the parent object.
3444 */
3445
3446 wxRichTextBox(wxRichTextObject* parent = NULL);
3447
3448 /**
3449 Copy constructor.
3450 */
3451
3452 wxRichTextBox(const wxRichTextBox& obj): wxRichTextParagraphLayoutBox() { Copy(obj); }
3453
3454 // Overridables
3455
3456 virtual bool Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
3457
3458 virtual wxString GetXMLNodeName() const { return wxT("textbox"); }
3459
3460 virtual bool CanEditProperties() const { return true; }
3461
3462 virtual bool EditProperties(wxWindow* parent, wxRichTextBuffer* buffer);
3463
3464 virtual wxString GetPropertiesMenuLabel() const { return _("&Box"); }
3465
3466 // Accessors
3467
3468 // Operations
3469
3470 virtual wxRichTextObject* Clone() const { return new wxRichTextBox(*this); }
3471
3472 void Copy(const wxRichTextBox& obj);
3473
3474 protected:
3475 };
3476
3477 /**
3478 @class wxRichTextField
3479
3480 This class implements the general concept of a field, an object that represents
3481 additional functionality such as a footnote, a bookmark, a page number, a table
3482 of contents, and so on. Extra information (such as a bookmark name) can be stored
3483 in the object properties.
3484
3485 Drawing, layout, and property editing is delegated to classes derived
3486 from wxRichTextFieldType, such as instances of wxRichTextFieldTypeStandard; this makes
3487 the use of fields an efficient method of introducing extra functionality, since
3488 most of the information required to draw a field (such as a bitmap) is kept centrally
3489 in a single field type definition.
3490
3491 The FieldType property, accessed by SetFieldType/GetFieldType, is used to retrieve
3492 the field type definition. So be careful not to overwrite this property.
3493
3494 wxRichTextField is derived from wxRichTextParagraphLayoutBox, which means that it
3495 can contain its own read-only content, refreshed when the application calls the UpdateField
3496 function. Whether a field is treated as a composite or a single graphic is determined
3497 by the field type definition. If using wxRichTextFieldTypeStandard, passing the display
3498 type wxRICHTEXT_FIELD_STYLE_COMPOSITE to the field type definition causes the field
3499 to behave like a composite; the other display styles display a simple graphic.
3500 When implementing a composite field, you will still need to derive from wxRichTextFieldTypeStandard
3501 or wxRichTextFieldType, if only to implement UpdateField to refresh the field content
3502 appropriately. wxRichTextFieldTypeStandard is only one possible implementation, but
3503 covers common needs especially for simple, static fields using text or a bitmap.
3504
3505 Register field types on application initialisation with the static function
3506 wxRichTextParagraphLayoutBox::AddFieldType. They will be deleted automatically
3507 on application exit.
3508
3509 An application can write a field to a control with wxRichTextCtrl::WriteField,
3510 taking a field type, the properties for the field, and optional attributes.
3511
3512 @library{wxrichtext}
3513 @category{richtext}
3514
3515 @see wxRichTextFieldTypeStandard, wxRichTextFieldType, wxRichTextParagraphLayoutBox, wxRichTextProperties, wxRichTextCtrl
3516 */
3517
3518 class WXDLLIMPEXP_RICHTEXT wxRichTextField: public wxRichTextParagraphLayoutBox
3519 {
3520 DECLARE_DYNAMIC_CLASS(wxRichTextField)
3521 public:
3522 // Constructors
3523
3524 /**
3525 Default constructor; optionally pass the parent object.
3526 */
3527
3528 wxRichTextField(const wxString& fieldType = wxEmptyString, wxRichTextObject* parent = NULL);
3529
3530 /**
3531 Copy constructor.
3532 */
3533
3534 wxRichTextField(const wxRichTextField& obj): wxRichTextParagraphLayoutBox() { Copy(obj); }
3535
3536 // Overridables
3537
3538 virtual bool Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
3539
3540 virtual bool Layout(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, const wxRect& parentRect, int style);
3541
3542 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
3543
3544 virtual wxString GetXMLNodeName() const { return wxT("field"); }
3545
3546 virtual bool CanEditProperties() const;
3547
3548 virtual bool EditProperties(wxWindow* parent, wxRichTextBuffer* buffer);
3549
3550 virtual wxString GetPropertiesMenuLabel() const;
3551
3552 virtual bool AcceptsFocus() const { return false; }
3553
3554 virtual void CalculateRange(long start, long& end);
3555
3556 /**
3557 If a field has children, we don't want the user to be able to edit it.
3558 */
3559 virtual bool IsAtomic() const { return true; }
3560
3561 virtual bool IsEmpty() const { return false; }
3562
3563 virtual bool IsTopLevel() const;
3564
3565 // Accessors
3566
3567 void SetFieldType(const wxString& fieldType) { GetProperties().SetProperty(wxT("FieldType"), fieldType); }
3568 wxString GetFieldType() const { return GetProperties().GetPropertyString(wxT("FieldType")); }
3569
3570 // Operations
3571
3572 /**
3573 Update the field; delegated to the associated field type. This would typically expand the field to its value,
3574 if this is a dynamically changing and/or composite field.
3575 */
3576 virtual bool UpdateField(wxRichTextBuffer* buffer);
3577
3578 virtual wxRichTextObject* Clone() const { return new wxRichTextField(*this); }
3579
3580 void Copy(const wxRichTextField& obj);
3581
3582 protected:
3583 };
3584
3585 /**
3586 @class wxRichTextFieldType
3587
3588 The base class for custom field types. Each type definition handles one
3589 field type. Override functions to provide drawing, layout, updating and
3590 property editing functionality for a field.
3591
3592 Register field types on application initialisation with the static function
3593 wxRichTextParagraphLayoutBox::AddFieldType. They will be deleted automatically
3594 on application exit.
3595
3596 @library{wxrichtext}
3597 @category{richtext}
3598
3599 @see wxRichTextFieldTypeStandard, wxRichTextField, wxRichTextCtrl
3600 */
3601
3602 class WXDLLIMPEXP_RICHTEXT wxRichTextFieldType: public wxObject
3603 {
3604 DECLARE_CLASS(wxRichTextFieldType)
3605 public:
3606 /**
3607 Creates a field type definition.
3608 */
3609 wxRichTextFieldType(const wxString& name = wxEmptyString)
3610 : m_name(name)
3611 { }
3612
3613 /**
3614 Copy constructor.
3615 */
3616 wxRichTextFieldType(const wxRichTextFieldType& fieldType)
3617 : wxObject(fieldType)
3618 { Copy(fieldType); }
3619
3620 void Copy(const wxRichTextFieldType& fieldType) { m_name = fieldType.m_name; }
3621
3622 /**
3623 Draw the item, within the given range. Some objects may ignore the range (for
3624 example paragraphs) while others must obey it (lines, to implement wrapping)
3625 */
3626 virtual bool Draw(wxRichTextField* obj, wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style) = 0;
3627
3628 /**
3629 Lay the item out at the specified position with the given size constraint.
3630 Layout must set the cached size. @rect is the available space for the object,
3631 and @a parentRect is the container that is used to determine a relative size
3632 or position (for example if a text box must be 50% of the parent text box).
3633 */
3634 virtual bool Layout(wxRichTextField* obj, wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, const wxRect& parentRect, int style) = 0;
3635
3636 /**
3637 Returns the object size for the given range. Returns @false if the range
3638 is invalid for this object.
3639 */
3640 virtual bool GetRangeSize(wxRichTextField* obj, const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const = 0;
3641
3642 /**
3643 Returns @true if we can edit the object's properties via a GUI.
3644 */
3645 virtual bool CanEditProperties(wxRichTextField* WXUNUSED(obj)) const { return false; }
3646
3647 /**
3648 Edits the object's properties via a GUI.
3649 */
3650 virtual bool EditProperties(wxRichTextField* WXUNUSED(obj), wxWindow* WXUNUSED(parent), wxRichTextBuffer* WXUNUSED(buffer)) { return false; }
3651
3652 /**
3653 Returns the label to be used for the properties context menu item.
3654 */
3655 virtual wxString GetPropertiesMenuLabel(wxRichTextField* WXUNUSED(obj)) const { return wxEmptyString; }
3656
3657 /**
3658 Update the field. This would typically expand the field to its value,
3659 if this is a dynamically changing and/or composite field.
3660 */
3661 virtual bool UpdateField(wxRichTextBuffer* WXUNUSED(buffer), wxRichTextField* WXUNUSED(obj)) { return false; }
3662
3663 /**
3664 Returns @true if this object is top-level, i.e. contains its own paragraphs, such as a text box.
3665 */
3666 virtual bool IsTopLevel(wxRichTextField* WXUNUSED(obj)) const { return true; }
3667
3668 /**
3669 Sets the field type name. There should be a unique name per field type object.
3670 */
3671 void SetName(const wxString& name) { m_name = name; }
3672
3673 /**
3674 Returns the field type name. There should be a unique name per field type object.
3675 */
3676 wxString GetName() const { return m_name; }
3677
3678 protected:
3679
3680 wxString m_name;
3681 };
3682
3683 WX_DECLARE_STRING_HASH_MAP(wxRichTextFieldType*, wxRichTextFieldTypeHashMap);
3684
3685 /**
3686 @class wxRichTextFieldTypeStandard
3687
3688 A field type that can handle fields with text or bitmap labels, with a small range
3689 of styles for implementing rectangular fields and fields that can be used for start
3690 and end tags.
3691
3692 The border, text and background colours can be customised; the default is
3693 white text on a black background.
3694
3695 The following display styles can be used.
3696
3697 @beginStyleTable
3698 @style{wxRICHTEXT_FIELD_STYLE_COMPOSITE}
3699 Creates a composite field; you will probably need to derive a new class to implement UpdateField.
3700 @style{wxRICHTEXT_FIELD_STYLE_RECTANGLE}
3701 Shows a rounded rectangle background.
3702 @style{wxRICHTEXT_FIELD_STYLE_NO_BORDER}
3703 Suppresses the background and border; mostly used with a bitmap label.
3704 @style{wxRICHTEXT_FIELD_STYLE_START_TAG}
3705 Shows a start tag background, with the pointy end facing right.
3706 @style{wxRICHTEXT_FIELD_STYLE_END_TAG}
3707 Shows an end tag background, with the pointy end facing left.
3708 @endStyleTable
3709
3710 @library{wxrichtext}
3711 @category{richtext}
3712
3713 @see wxRichTextFieldType, wxRichTextField, wxRichTextBuffer, wxRichTextCtrl
3714 */
3715
3716 class WXDLLIMPEXP_RICHTEXT wxRichTextFieldTypeStandard: public wxRichTextFieldType
3717 {
3718 DECLARE_CLASS(wxRichTextFieldTypeStandard)
3719 public:
3720
3721 // Display style types
3722 enum { wxRICHTEXT_FIELD_STYLE_COMPOSITE = 0x01,
3723 wxRICHTEXT_FIELD_STYLE_RECTANGLE = 0x02,
3724 wxRICHTEXT_FIELD_STYLE_NO_BORDER = 0x04,
3725 wxRICHTEXT_FIELD_STYLE_START_TAG = 0x08,
3726 wxRICHTEXT_FIELD_STYLE_END_TAG = 0x10
3727 };
3728
3729 /**
3730 Constructor, creating a field type definition with a text label.
3731
3732 @param parent
3733 The name of the type definition. This must be unique, and is the type
3734 name used when adding a field to a control.
3735 @param label
3736 The text label to be shown on the field.
3737 @param displayStyle
3738 The display style: one of wxRICHTEXT_FIELD_STYLE_RECTANGLE,
3739 wxRICHTEXT_FIELD_STYLE_NO_BORDER, wxRICHTEXT_FIELD_STYLE_START_TAG,
3740 wxRICHTEXT_FIELD_STYLE_END_TAG.
3741
3742 */
3743 wxRichTextFieldTypeStandard(const wxString& name, const wxString& label, int displayStyle = wxRICHTEXT_FIELD_STYLE_RECTANGLE);
3744
3745 /**
3746 Constructor, creating a field type definition with a bitmap label.
3747
3748 @param parent
3749 The name of the type definition. This must be unique, and is the type
3750 name used when adding a field to a control.
3751 @param label
3752 The bitmap label to be shown on the field.
3753 @param displayStyle
3754 The display style: one of wxRICHTEXT_FIELD_STYLE_RECTANGLE,
3755 wxRICHTEXT_FIELD_STYLE_NO_BORDER, wxRICHTEXT_FIELD_STYLE_START_TAG,
3756 wxRICHTEXT_FIELD_STYLE_END_TAG.
3757
3758 */
3759 wxRichTextFieldTypeStandard(const wxString& name, const wxBitmap& bitmap, int displayStyle = wxRICHTEXT_FIELD_STYLE_NO_BORDER);
3760
3761 /**
3762 The default constructor.
3763
3764 */
3765 wxRichTextFieldTypeStandard() { Init(); }
3766
3767 /**
3768 The copy constructor.
3769
3770 */
3771 wxRichTextFieldTypeStandard(const wxRichTextFieldTypeStandard& field)
3772 : wxRichTextFieldType(field)
3773 { Copy(field); }
3774
3775 /**
3776 Initialises the object.
3777 */
3778 void Init();
3779
3780 /**
3781 Copies the object.
3782 */
3783 void Copy(const wxRichTextFieldTypeStandard& field);
3784
3785 /**
3786 The assignment operator.
3787 */
3788 void operator=(const wxRichTextFieldTypeStandard& field) { Copy(field); }
3789
3790 /**
3791 Draw the item, within the given range. Some objects may ignore the range (for
3792 example paragraphs) while others must obey it (lines, to implement wrapping)
3793 */
3794 virtual bool Draw(wxRichTextField* obj, wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
3795
3796 /**
3797 Lay the item out at the specified position with the given size constraint.
3798 Layout must set the cached size. @rect is the available space for the object,
3799 and @a parentRect is the container that is used to determine a relative size
3800 or position (for example if a text box must be 50% of the parent text box).
3801 */
3802 virtual bool Layout(wxRichTextField* obj, wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, const wxRect& parentRect, int style);
3803
3804 /**
3805 Returns the object size for the given range. Returns @false if the range
3806 is invalid for this object.
3807 */
3808 virtual bool GetRangeSize(wxRichTextField* obj, const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
3809
3810 /**
3811 Get the size of the field, given the label, font size, and so on.
3812 */
3813 wxSize GetSize(wxRichTextField* obj, wxDC& dc, wxRichTextDrawingContext& context, int style) const;
3814
3815 /**
3816 Returns @true if the display type is wxRICHTEXT_FIELD_STYLE_COMPOSITE, @false otherwise.
3817 */
3818 virtual bool IsTopLevel(wxRichTextField* WXUNUSED(obj)) const { return (GetDisplayStyle() & wxRICHTEXT_FIELD_STYLE_COMPOSITE) != 0; }
3819
3820 /**
3821 Sets the text label for fields of this type.
3822 */
3823 void SetLabel(const wxString& label) { m_label = label; }
3824
3825 /**
3826 Returns the text label for fields of this type.
3827 */
3828 const wxString& GetLabel() const { return m_label; }
3829
3830 /**
3831 Sets the bitmap label for fields of this type.
3832 */
3833 void SetBitmap(const wxBitmap& bitmap) { m_bitmap = bitmap; }
3834
3835 /**
3836 Gets the bitmap label for fields of this type.
3837 */
3838 const wxBitmap& GetBitmap() const { return m_bitmap; }
3839
3840 /**
3841 Gets the display style for fields of this type.
3842 */
3843 int GetDisplayStyle() const { return m_displayStyle; }
3844
3845 /**
3846 Sets the display style for fields of this type.
3847 */
3848 void SetDisplayStyle(int displayStyle) { m_displayStyle = displayStyle; }
3849
3850 /**
3851 Gets the font used for drawing the text label.
3852 */
3853 const wxFont& GetFont() const { return m_font; }
3854
3855 /**
3856 Sets the font used for drawing the text label.
3857 */
3858 void SetFont(const wxFont& font) { m_font = font; }
3859
3860 /**
3861 Gets the colour used for drawing the text label.
3862 */
3863 const wxColour& GetTextColour() const { return m_textColour; }
3864
3865 /**
3866 Sets the colour used for drawing the text label.
3867 */
3868 void SetTextColour(const wxColour& colour) { m_textColour = colour; }
3869
3870 /**
3871 Gets the colour used for drawing the field border.
3872 */
3873 const wxColour& GetBorderColour() const { return m_borderColour; }
3874
3875 /**
3876 Sets the colour used for drawing the field border.
3877 */
3878 void SetBorderColour(const wxColour& colour) { m_borderColour = colour; }
3879
3880 /**
3881 Gets the colour used for drawing the field background.
3882 */
3883 const wxColour& GetBackgroundColour() const { return m_backgroundColour; }
3884
3885 /**
3886 Sets the colour used for drawing the field background.
3887 */
3888 void SetBackgroundColour(const wxColour& colour) { m_backgroundColour = colour; }
3889
3890 /**
3891 Sets the vertical padding (the distance between the border and the text).
3892 */
3893 void SetVerticalPadding(int padding) { m_verticalPadding = padding; }
3894
3895 /**
3896 Gets the vertical padding (the distance between the border and the text).
3897 */
3898 int GetVerticalPadding() const { return m_verticalPadding; }
3899
3900 /**
3901 Sets the horizontal padding (the distance between the border and the text).
3902 */
3903 void SetHorizontalPadding(int padding) { m_horizontalPadding = padding; }
3904
3905 /**
3906 Sets the horizontal padding (the distance between the border and the text).
3907 */
3908 int GetHorizontalPadding() const { return m_horizontalPadding; }
3909
3910 /**
3911 Sets the horizontal margin surrounding the field object.
3912 */
3913 void SetHorizontalMargin(int margin) { m_horizontalMargin = margin; }
3914
3915 /**
3916 Gets the horizontal margin surrounding the field object.
3917 */
3918 int GetHorizontalMargin() const { return m_horizontalMargin; }
3919
3920 /**
3921 Sets the vertical margin surrounding the field object.
3922 */
3923 void SetVerticalMargin(int margin) { m_verticalMargin = margin; }
3924
3925 /**
3926 Gets the vertical margin surrounding the field object.
3927 */
3928 int GetVerticalMargin() const { return m_verticalMargin; }
3929
3930 protected:
3931
3932 wxString m_label;
3933 int m_displayStyle;
3934 wxFont m_font;
3935 wxColour m_textColour;
3936 wxColour m_borderColour;
3937 wxColour m_backgroundColour;
3938 int m_verticalPadding;
3939 int m_horizontalPadding;
3940 int m_horizontalMargin;
3941 int m_verticalMargin;
3942 wxBitmap m_bitmap;
3943 };
3944
3945 /**
3946 @class wxRichTextLine
3947
3948 This object represents a line in a paragraph, and stores
3949 offsets from the start of the paragraph representing the
3950 start and end positions of the line.
3951
3952 @library{wxrichtext}
3953 @category{richtext}
3954
3955 @see wxRichTextBuffer, wxRichTextCtrl
3956 */
3957
3958 class WXDLLIMPEXP_RICHTEXT wxRichTextLine
3959 {
3960 public:
3961 // Constructors
3962
3963 wxRichTextLine(wxRichTextParagraph* parent);
3964 wxRichTextLine(const wxRichTextLine& obj) { Init( NULL); Copy(obj); }
3965 virtual ~wxRichTextLine() {}
3966
3967 // Overridables
3968
3969 // Accessors
3970
3971 /**
3972 Sets the range associated with this line.
3973 */
3974 void SetRange(const wxRichTextRange& range) { m_range = range; }
3975 /**
3976 Sets the range associated with this line.
3977 */
3978 void SetRange(long from, long to) { m_range = wxRichTextRange(from, to); }
3979
3980 /**
3981 Returns the parent paragraph.
3982 */
3983 wxRichTextParagraph* GetParent() { return m_parent; }
3984
3985 /**
3986 Returns the range.
3987 */
3988 const wxRichTextRange& GetRange() const { return m_range; }
3989 /**
3990 Returns the range.
3991 */
3992 wxRichTextRange& GetRange() { return m_range; }
3993
3994 /**
3995 Returns the absolute range.
3996 */
3997 wxRichTextRange GetAbsoluteRange() const;
3998
3999 /**
4000 Returns the line size as calculated by Layout.
4001 */
4002 virtual wxSize GetSize() const { return m_size; }
4003
4004 /**
4005 Sets the line size as calculated by Layout.
4006 */
4007 virtual void SetSize(const wxSize& sz) { m_size = sz; }
4008
4009 /**
4010 Returns the object position relative to the parent.
4011 */
4012 virtual wxPoint GetPosition() const { return m_pos; }
4013
4014 /**
4015 Sets the object position relative to the parent.
4016 */
4017 virtual void SetPosition(const wxPoint& pos) { m_pos = pos; }
4018
4019 /**
4020 Returns the absolute object position.
4021 */
4022 virtual wxPoint GetAbsolutePosition() const;
4023
4024 /**
4025 Returns the rectangle enclosing the line.
4026 */
4027 virtual wxRect GetRect() const { return wxRect(GetAbsolutePosition(), GetSize()); }
4028
4029 /**
4030 Sets the stored descent.
4031 */
4032 void SetDescent(int descent) { m_descent = descent; }
4033
4034 /**
4035 Returns the stored descent.
4036 */
4037 int GetDescent() const { return m_descent; }
4038
4039 #if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING
4040 wxArrayInt& GetObjectSizes() { return m_objectSizes; }
4041 const wxArrayInt& GetObjectSizes() const { return m_objectSizes; }
4042 #endif
4043
4044 // Operations
4045
4046 /**
4047 Initialises the object.
4048 */
4049 void Init(wxRichTextParagraph* parent);
4050
4051 /**
4052 Copies from @a obj.
4053 */
4054 void Copy(const wxRichTextLine& obj);
4055
4056 virtual wxRichTextLine* Clone() const { return new wxRichTextLine(*this); }
4057
4058 protected:
4059
4060 // The range of the line (start position to end position)
4061 // This is relative to the parent paragraph.
4062 wxRichTextRange m_range;
4063
4064 // Size and position measured relative to top of paragraph
4065 wxPoint m_pos;
4066 wxSize m_size;
4067
4068 // Maximum descent for this line (location of text baseline)
4069 int m_descent;
4070
4071 // The parent object
4072 wxRichTextParagraph* m_parent;
4073
4074 #if wxRICHTEXT_USE_OPTIMIZED_LINE_DRAWING
4075 wxArrayInt m_objectSizes;
4076 #endif
4077 };
4078
4079 WX_DECLARE_LIST_WITH_DECL( wxRichTextLine, wxRichTextLineList , class WXDLLIMPEXP_RICHTEXT );
4080
4081 /**
4082 @class wxRichTextParagraph
4083
4084 This object represents a single paragraph containing various objects such as text content, images, and further paragraph layout objects.
4085
4086 @library{wxrichtext}
4087 @category{richtext}
4088
4089 @see wxRichTextBuffer, wxRichTextCtrl
4090 */
4091
4092 class WXDLLIMPEXP_RICHTEXT wxRichTextParagraph: public wxRichTextCompositeObject
4093 {
4094 DECLARE_DYNAMIC_CLASS(wxRichTextParagraph)
4095 public:
4096 // Constructors
4097
4098 /**
4099 Constructor taking a parent and style.
4100 */
4101 wxRichTextParagraph(wxRichTextObject* parent = NULL, wxRichTextAttr* style = NULL);
4102 /**
4103 Constructor taking a text string, a parent and paragraph and character attributes.
4104 */
4105 wxRichTextParagraph(const wxString& text, wxRichTextObject* parent = NULL, wxRichTextAttr* paraStyle = NULL, wxRichTextAttr* charStyle = NULL);
4106 virtual ~wxRichTextParagraph();
4107 wxRichTextParagraph(const wxRichTextParagraph& obj): wxRichTextCompositeObject() { Copy(obj); }
4108
4109 // Overridables
4110
4111 virtual bool Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
4112
4113 virtual bool Layout(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, const wxRect& parentRect, int style);
4114
4115 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
4116
4117 virtual bool FindPosition(wxDC& dc, wxRichTextDrawingContext& context, long index, wxPoint& pt, int* height, bool forceLineStart);
4118
4119 virtual int HitTest(wxDC& dc, wxRichTextDrawingContext& context, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags = 0);
4120
4121 virtual void CalculateRange(long start, long& end);
4122
4123 virtual wxString GetXMLNodeName() const { return wxT("paragraph"); }
4124
4125 // Accessors
4126
4127 /**
4128 Returns the cached lines.
4129 */
4130 wxRichTextLineList& GetLines() { return m_cachedLines; }
4131
4132 // Operations
4133
4134 /**
4135 Copies the object.
4136 */
4137 void Copy(const wxRichTextParagraph& obj);
4138
4139 virtual wxRichTextObject* Clone() const { return new wxRichTextParagraph(*this); }
4140
4141 /**
4142 Clears the cached lines.
4143 */
4144 void ClearLines();
4145
4146 // Implementation
4147
4148 /**
4149 Applies paragraph styles such as centering to the wrapped lines.
4150 */
4151 virtual void ApplyParagraphStyle(wxRichTextLine* line, const wxRichTextAttr& attr, const wxRect& rect, wxDC& dc);
4152
4153 /**
4154 Inserts text at the given position.
4155 */
4156 virtual bool InsertText(long pos, const wxString& text);
4157
4158 /**
4159 Splits an object at this position if necessary, and returns
4160 the previous object, or NULL if inserting at the beginning.
4161 */
4162 virtual wxRichTextObject* SplitAt(long pos, wxRichTextObject** previousObject = NULL);
4163
4164 /**
4165 Moves content to a list from this point.
4166 */
4167 virtual void MoveToList(wxRichTextObject* obj, wxList& list);
4168
4169 /**
4170 Adds content back from a list.
4171 */
4172 virtual void MoveFromList(wxList& list);
4173
4174 /**
4175 Returns the plain text searching from the start or end of the range.
4176 The resulting string may be shorter than the range given.
4177 */
4178 bool GetContiguousPlainText(wxString& text, const wxRichTextRange& range, bool fromStart = true);
4179
4180 /**
4181 Finds a suitable wrap position. @a wrapPosition is the last position in the line to the left
4182 of the split.
4183 */
4184 bool FindWrapPosition(const wxRichTextRange& range, wxDC& dc, wxRichTextDrawingContext& context, int availableSpace, long& wrapPosition, wxArrayInt* partialExtents);
4185
4186 /**
4187 Finds the object at the given position.
4188 */
4189 wxRichTextObject* FindObjectAtPosition(long position);
4190
4191 /**
4192 Returns the bullet text for this paragraph.
4193 */
4194 wxString GetBulletText();
4195
4196 /**
4197 Allocates or reuses a line object.
4198 */
4199 wxRichTextLine* AllocateLine(int pos);
4200
4201 /**
4202 Clears remaining unused line objects, if any.
4203 */
4204 bool ClearUnusedLines(int lineCount);
4205
4206 /**
4207 Returns combined attributes of the base style, paragraph style and character style. We use this to dynamically
4208 retrieve the actual style.
4209 */
4210 wxRichTextAttr GetCombinedAttributes(const wxRichTextAttr& contentStyle, bool includingBoxAttr = false) const;
4211
4212 /**
4213 Returns the combined attributes of the base style and paragraph style.
4214 */
4215 wxRichTextAttr GetCombinedAttributes(bool includingBoxAttr = false) const;
4216
4217 /**
4218 Returns the first position from pos that has a line break character.
4219 */
4220 long GetFirstLineBreakPosition(long pos);
4221
4222 /**
4223 Creates a default tabstop array.
4224 */
4225 static void InitDefaultTabs();
4226
4227 /**
4228 Clears the default tabstop array.
4229 */
4230 static void ClearDefaultTabs();
4231
4232 /**
4233 Returns the default tabstop array.
4234 */
4235 static const wxArrayInt& GetDefaultTabs() { return sm_defaultTabs; }
4236
4237 /**
4238 Lays out the floating objects.
4239 */
4240 void LayoutFloat(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, const wxRect& parentRect, int style, wxRichTextFloatCollector* floatCollector);
4241
4242 protected:
4243
4244 // The lines that make up the wrapped paragraph
4245 wxRichTextLineList m_cachedLines;
4246
4247 // Default tabstops
4248 static wxArrayInt sm_defaultTabs;
4249
4250 friend class wxRichTextFloatCollector;
4251 };
4252
4253 /**
4254 @class wxRichTextPlainText
4255
4256 This object represents a single piece of text.
4257
4258 @library{wxrichtext}
4259 @category{richtext}
4260
4261 @see wxRichTextBuffer, wxRichTextCtrl
4262 */
4263
4264 class WXDLLIMPEXP_RICHTEXT wxRichTextPlainText: public wxRichTextObject
4265 {
4266 DECLARE_DYNAMIC_CLASS(wxRichTextPlainText)
4267 public:
4268 // Constructors
4269
4270 /**
4271 Constructor.
4272 */
4273 wxRichTextPlainText(const wxString& text = wxEmptyString, wxRichTextObject* parent = NULL, wxRichTextAttr* style = NULL);
4274
4275 /**
4276 Copy constructor.
4277 */
4278 wxRichTextPlainText(const wxRichTextPlainText& obj): wxRichTextObject() { Copy(obj); }
4279
4280 // Overridables
4281
4282 virtual bool Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
4283
4284 virtual bool Layout(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, const wxRect& parentRect, int style);
4285
4286 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
4287
4288 virtual wxString GetTextForRange(const wxRichTextRange& range) const;
4289
4290 virtual wxRichTextObject* DoSplit(long pos);
4291
4292 virtual void CalculateRange(long start, long& end);
4293
4294 virtual bool DeleteRange(const wxRichTextRange& range);
4295
4296 virtual bool IsEmpty() const { return m_text.empty(); }
4297
4298 virtual bool CanMerge(wxRichTextObject* object) const;
4299
4300 virtual bool Merge(wxRichTextObject* object);
4301
4302 virtual void Dump(wxTextOutputStream& stream);
4303
4304 /**
4305 Get the first position from pos that has a line break character.
4306 */
4307 long GetFirstLineBreakPosition(long pos);
4308
4309 /// Does this object take note of paragraph attributes? Text and image objects don't.
4310 virtual bool UsesParagraphAttributes() const { return false; }
4311
4312 #if wxUSE_XML
4313 virtual bool ImportFromXML(wxRichTextBuffer* buffer, wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse);
4314 #endif
4315
4316 #if wxRICHTEXT_HAVE_DIRECT_OUTPUT
4317 virtual bool ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler);
4318 #endif
4319
4320 #if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
4321 virtual bool ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler);
4322 #endif
4323
4324 virtual wxString GetXMLNodeName() const { return wxT("text"); }
4325
4326 // Accessors
4327
4328 /**
4329 Returns the text.
4330 */
4331 const wxString& GetText() const { return m_text; }
4332
4333 /**
4334 Sets the text.
4335 */
4336 void SetText(const wxString& text) { m_text = text; }
4337
4338 // Operations
4339
4340 // Copies the text object,
4341 void Copy(const wxRichTextPlainText& obj);
4342
4343 // Clones the text object.
4344 virtual wxRichTextObject* Clone() const { return new wxRichTextPlainText(*this); }
4345
4346 private:
4347 bool DrawTabbedString(wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect, wxString& str, wxCoord& x, wxCoord& y, bool selected);
4348
4349 protected:
4350 wxString m_text;
4351 };
4352
4353 /**
4354 @class wxRichTextImageBlock
4355
4356 This class stores information about an image, in binary in-memory form.
4357
4358 @library{wxrichtext}
4359 @category{richtext}
4360
4361 @see wxRichTextBuffer, wxRichTextCtrl
4362 */
4363
4364 class WXDLLIMPEXP_RICHTEXT wxRichTextImageBlock: public wxObject
4365 {
4366 public:
4367 /**
4368 Constructor.
4369 */
4370 wxRichTextImageBlock();
4371
4372 /**
4373 Copy constructor.
4374 */
4375 wxRichTextImageBlock(const wxRichTextImageBlock& block);
4376 virtual ~wxRichTextImageBlock();
4377
4378 /**
4379 Initialises the block.
4380 */
4381 void Init();
4382
4383 /**
4384 Clears the block.
4385 */
4386
4387 void Clear();
4388
4389 /**
4390 Load the original image into a memory block.
4391 If the image is not a JPEG, we must convert it into a JPEG
4392 to conserve space.
4393 If it's not a JPEG we can make use of @a image, already scaled, so we don't have to
4394 load the image a second time.
4395 */
4396 virtual bool MakeImageBlock(const wxString& filename, wxBitmapType imageType,
4397 wxImage& image, bool convertToJPEG = true);
4398
4399 /**
4400 Make an image block from the wxImage in the given
4401 format.
4402 */
4403 virtual bool MakeImageBlock(wxImage& image, wxBitmapType imageType, int quality = 80);
4404
4405 /**
4406 Uses a const wxImage for efficiency, but can't set quality (only relevant for JPEG)
4407 */
4408 virtual bool MakeImageBlockDefaultQuality(const wxImage& image, wxBitmapType imageType);
4409
4410 /**
4411 Makes the image block.
4412 */
4413 virtual bool DoMakeImageBlock(const wxImage& image, wxBitmapType imageType);
4414
4415 /**
4416 Writes the block to a file.
4417 */
4418 bool Write(const wxString& filename);
4419
4420 /**
4421 Writes the data in hex to a stream.
4422 */
4423 bool WriteHex(wxOutputStream& stream);
4424
4425 /**
4426 Reads the data in hex from a stream.
4427 */
4428 bool ReadHex(wxInputStream& stream, int length, wxBitmapType imageType);
4429
4430 /**
4431 Copy from @a block.
4432 */
4433 void Copy(const wxRichTextImageBlock& block);
4434
4435 // Load a wxImage from the block
4436 /**
4437 */
4438 bool Load(wxImage& image);
4439
4440 // Operators
4441
4442 /**
4443 Assignment operation.
4444 */
4445 void operator=(const wxRichTextImageBlock& block);
4446
4447 // Accessors
4448
4449 /**
4450 Returns the raw data.
4451 */
4452 unsigned char* GetData() const { return m_data; }
4453
4454 /**
4455 Returns the data size in bytes.
4456 */
4457 size_t GetDataSize() const { return m_dataSize; }
4458
4459 /**
4460 Returns the image type.
4461 */
4462 wxBitmapType GetImageType() const { return m_imageType; }
4463
4464 /**
4465 */
4466 void SetData(unsigned char* image) { m_data = image; }
4467
4468 /**
4469 Sets the data size.
4470 */
4471 void SetDataSize(size_t size) { m_dataSize = size; }
4472
4473 /**
4474 Sets the image type.
4475 */
4476 void SetImageType(wxBitmapType imageType) { m_imageType = imageType; }
4477
4478 /**
4479 Returns @true if the data is non-NULL.
4480 */
4481 bool IsOk() const { return GetData() != NULL; }
4482 bool Ok() const { return IsOk(); }
4483
4484 /**
4485 Gets the extension for the block's type.
4486 */
4487 wxString GetExtension() const;
4488
4489 /// Implementation
4490
4491 /**
4492 Allocates and reads from a stream as a block of memory.
4493 */
4494 static unsigned char* ReadBlock(wxInputStream& stream, size_t size);
4495
4496 /**
4497 Allocates and reads from a file as a block of memory.
4498 */
4499 static unsigned char* ReadBlock(const wxString& filename, size_t size);
4500
4501 /**
4502 Writes a memory block to stream.
4503 */
4504 static bool WriteBlock(wxOutputStream& stream, unsigned char* block, size_t size);
4505
4506 /**
4507 Writes a memory block to a file.
4508 */
4509 static bool WriteBlock(const wxString& filename, unsigned char* block, size_t size);
4510
4511 protected:
4512 // Size in bytes of the image stored.
4513 // This is in the raw, original form such as a JPEG file.
4514 unsigned char* m_data;
4515 size_t m_dataSize;
4516 wxBitmapType m_imageType;
4517 };
4518
4519 /**
4520 @class wxRichTextImage
4521
4522 This class implements a graphic object.
4523
4524 @library{wxrichtext}
4525 @category{richtext}
4526
4527 @see wxRichTextBuffer, wxRichTextCtrl, wxRichTextImageBlock
4528 */
4529
4530 class WXDLLIMPEXP_RICHTEXT wxRichTextImage: public wxRichTextObject
4531 {
4532 DECLARE_DYNAMIC_CLASS(wxRichTextImage)
4533 public:
4534 // Constructors
4535
4536 /**
4537 Default constructor.
4538 */
4539 wxRichTextImage(wxRichTextObject* parent = NULL): wxRichTextObject(parent) { Init(); }
4540
4541 /**
4542 Creates a wxRichTextImage from a wxImage.
4543 */
4544 wxRichTextImage(const wxImage& image, wxRichTextObject* parent = NULL, wxRichTextAttr* charStyle = NULL);
4545
4546 /**
4547 Creates a wxRichTextImage from an image block.
4548 */
4549 wxRichTextImage(const wxRichTextImageBlock& imageBlock, wxRichTextObject* parent = NULL, wxRichTextAttr* charStyle = NULL);
4550
4551 /**
4552 Copy constructor.
4553 */
4554 wxRichTextImage(const wxRichTextImage& obj): wxRichTextObject(obj) { Copy(obj); }
4555
4556 /**
4557 Initialisation.
4558 */
4559 void Init();
4560
4561 // Overridables
4562
4563 virtual bool Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
4564
4565 virtual bool Layout(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, const wxRect& parentRect, int style);
4566
4567 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
4568
4569 /**
4570 Returns the 'natural' size for this object - the image size.
4571 */
4572 virtual wxTextAttrSize GetNaturalSize() const;
4573
4574 virtual bool IsEmpty() const { return false; /* !m_imageBlock.IsOk(); */ }
4575
4576 virtual bool CanEditProperties() const { return true; }
4577
4578 virtual bool EditProperties(wxWindow* parent, wxRichTextBuffer* buffer);
4579
4580 virtual wxString GetPropertiesMenuLabel() const { return _("&Picture"); }
4581
4582 virtual bool UsesParagraphAttributes() const { return false; }
4583
4584 #if wxUSE_XML
4585 virtual bool ImportFromXML(wxRichTextBuffer* buffer, wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse);
4586 #endif
4587
4588 #if wxRICHTEXT_HAVE_DIRECT_OUTPUT
4589 virtual bool ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler);
4590 #endif
4591
4592 #if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
4593 virtual bool ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler);
4594 #endif
4595
4596 // Images can be floatable (optionally).
4597 virtual bool IsFloatable() const { return true; }
4598
4599 virtual wxString GetXMLNodeName() const { return wxT("image"); }
4600
4601 // Accessors
4602
4603 /**
4604 Returns the image cache (a scaled bitmap).
4605 */
4606 const wxBitmap& GetImageCache() const { return m_imageCache; }
4607
4608 /**
4609 Sets the image cache.
4610 */
4611 void SetImageCache(const wxBitmap& bitmap) { m_imageCache = bitmap; m_originalImageSize = wxSize(bitmap.GetWidth(), bitmap.GetHeight()); }
4612
4613 /**
4614 Resets the image cache.
4615 */
4616 void ResetImageCache() { m_imageCache = wxNullBitmap; m_originalImageSize = wxSize(-1, -1); }
4617
4618 /**
4619 Returns the image block containing the raw data.
4620 */
4621 wxRichTextImageBlock& GetImageBlock() { return m_imageBlock; }
4622
4623 // Operations
4624
4625 /**
4626 Copies the image object.
4627 */
4628 void Copy(const wxRichTextImage& obj);
4629
4630 /**
4631 Clones the image object.
4632 */
4633 virtual wxRichTextObject* Clone() const { return new wxRichTextImage(*this); }
4634
4635 /**
4636 Creates a cached image at the required size.
4637 */
4638 virtual bool LoadImageCache(wxDC& dc, bool resetCache = false);
4639
4640 /**
4641 Gets the original image size.
4642 */
4643 wxSize GetOriginalImageSize() const { return m_originalImageSize; }
4644
4645 /**
4646 Sets the original image size.
4647 */
4648 void SetOriginalImageSize(const wxSize& sz) { m_originalImageSize = sz; }
4649
4650 protected:
4651 wxRichTextImageBlock m_imageBlock;
4652 wxBitmap m_imageCache;
4653 wxSize m_originalImageSize;
4654 };
4655
4656 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextCommand;
4657 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextAction;
4658
4659 /**
4660 @class wxRichTextBuffer
4661
4662 This is a kind of paragraph layout box, used to represent the whole buffer.
4663
4664 @library{wxrichtext}
4665 @category{richtext}
4666
4667 @see wxRichTextParagraphLayoutBox, wxRichTextCtrl
4668 */
4669
4670 class WXDLLIMPEXP_RICHTEXT wxRichTextBuffer: public wxRichTextParagraphLayoutBox
4671 {
4672 DECLARE_DYNAMIC_CLASS(wxRichTextBuffer)
4673 public:
4674 // Constructors
4675
4676 /**
4677 Default constructor.
4678 */
4679 wxRichTextBuffer() { Init(); }
4680
4681 /**
4682 Copy constructor.
4683 */
4684 wxRichTextBuffer(const wxRichTextBuffer& obj): wxRichTextParagraphLayoutBox() { Init(); Copy(obj); }
4685
4686 virtual ~wxRichTextBuffer() ;
4687
4688 // Accessors
4689
4690 /**
4691 Returns the command processor.
4692 A text buffer always creates its own command processor when it is initialized.
4693 */
4694 wxCommandProcessor* GetCommandProcessor() const { return m_commandProcessor; }
4695
4696 /**
4697 Sets style sheet, if any. This will allow the application to use named character and paragraph
4698 styles found in the style sheet.
4699
4700 Neither the buffer nor the control owns the style sheet so must be deleted by the application.
4701 */
4702 void SetStyleSheet(wxRichTextStyleSheet* styleSheet) { m_styleSheet = styleSheet; }
4703
4704 /**
4705 Returns the style sheet.
4706 */
4707 virtual wxRichTextStyleSheet* GetStyleSheet() const { return m_styleSheet; }
4708
4709 /**
4710 Sets the style sheet and sends a notification of the change.
4711 */
4712 bool SetStyleSheetAndNotify(wxRichTextStyleSheet* sheet);
4713
4714 /**
4715 Pushes the style sheet to the top of the style sheet stack.
4716 */
4717 bool PushStyleSheet(wxRichTextStyleSheet* styleSheet);
4718
4719 /**
4720 Pops the style sheet from the top of the style sheet stack.
4721 */
4722 wxRichTextStyleSheet* PopStyleSheet();
4723
4724 /**
4725 Returns the table storing fonts, for quick access and font reuse.
4726 */
4727 wxRichTextFontTable& GetFontTable() { return m_fontTable; }
4728
4729 /**
4730 Returns the table storing fonts, for quick access and font reuse.
4731 */
4732 const wxRichTextFontTable& GetFontTable() const { return m_fontTable; }
4733
4734 /**
4735 Sets table storing fonts, for quick access and font reuse.
4736 */
4737 void SetFontTable(const wxRichTextFontTable& table) { m_fontTable = table; }
4738
4739 /**
4740 Sets the scale factor for displaying fonts, for example for more comfortable
4741 editing.
4742 */
4743 void SetFontScale(double fontScale);
4744
4745 /**
4746 Returns the scale factor for displaying fonts, for example for more comfortable
4747 editing.
4748 */
4749 double GetFontScale() const { return m_fontScale; }
4750
4751 /**
4752 Sets the scale factor for displaying certain dimensions such as indentation and
4753 inter-paragraph spacing. This can be useful when editing in a small control
4754 where you still want legible text, but a minimum of wasted white space.
4755 */
4756 void SetDimensionScale(double dimScale);
4757
4758 /**
4759 Returns the scale factor for displaying certain dimensions such as indentation
4760 and inter-paragraph spacing.
4761 */
4762 double GetDimensionScale() const { return m_dimensionScale; }
4763
4764 // Operations
4765
4766 /**
4767 Initialisation.
4768 */
4769 void Init();
4770
4771 /**
4772 Clears the buffer, adds an empty paragraph, and clears the command processor.
4773 */
4774 virtual void ResetAndClearCommands();
4775
4776 //@{
4777 /**
4778 Loads content from a stream or file.
4779 Not all handlers will implement file loading.
4780 */
4781 virtual bool LoadFile(const wxString& filename, wxRichTextFileType type = wxRICHTEXT_TYPE_ANY);
4782 virtual bool LoadFile(wxInputStream& stream, wxRichTextFileType type = wxRICHTEXT_TYPE_ANY);
4783 //@}
4784
4785 //@{
4786 /**
4787 Saves content to a stream or file.
4788 Not all handlers will implement file saving.
4789 */
4790 virtual bool SaveFile(const wxString& filename, wxRichTextFileType type = wxRICHTEXT_TYPE_ANY);
4791 virtual bool SaveFile(wxOutputStream& stream, wxRichTextFileType type = wxRICHTEXT_TYPE_ANY);
4792 //@}
4793
4794 /**
4795 Sets the handler flags, controlling loading and saving.
4796 */
4797 void SetHandlerFlags(int flags) { m_handlerFlags = flags; }
4798
4799 /**
4800 Gets the handler flags, controlling loading and saving.
4801 */
4802 int GetHandlerFlags() const { return m_handlerFlags; }
4803
4804 /**
4805 Convenience function to add a paragraph of text.
4806 */
4807 virtual wxRichTextRange AddParagraph(const wxString& text, wxRichTextAttr* paraStyle = NULL) { Modify(); return wxRichTextParagraphLayoutBox::AddParagraph(text, paraStyle); }
4808
4809 /**
4810 Begin collapsing undo/redo commands. Note that this may not work properly
4811 if combining commands that delete or insert content, changing ranges for
4812 subsequent actions.
4813
4814 @a cmdName should be the name of the combined command that will appear
4815 next to Undo and Redo in the edit menu.
4816 */
4817 virtual bool BeginBatchUndo(const wxString& cmdName);
4818
4819 /**
4820 End collapsing undo/redo commands.
4821 */
4822 virtual bool EndBatchUndo();
4823
4824 /**
4825 Returns @true if we are collapsing commands.
4826 */
4827 virtual bool BatchingUndo() const { return m_batchedCommandDepth > 0; }
4828
4829 /**
4830 Submit the action immediately, or delay according to whether collapsing is on.
4831 */
4832 virtual bool SubmitAction(wxRichTextAction* action);
4833
4834 /**
4835 Returns the collapsed command.
4836 */
4837 virtual wxRichTextCommand* GetBatchedCommand() const { return m_batchedCommand; }
4838
4839 /**
4840 Begin suppressing undo/redo commands. The way undo is suppressed may be implemented
4841 differently by each command. If not dealt with by a command implementation, then
4842 it will be implemented automatically by not storing the command in the undo history
4843 when the action is submitted to the command processor.
4844 */
4845 virtual bool BeginSuppressUndo();
4846
4847 /**
4848 End suppressing undo/redo commands.
4849 */
4850 virtual bool EndSuppressUndo();
4851
4852 /**
4853 Are we suppressing undo??
4854 */
4855 virtual bool SuppressingUndo() const { return m_suppressUndo > 0; }
4856
4857 /**
4858 Copy the range to the clipboard.
4859 */
4860 virtual bool CopyToClipboard(const wxRichTextRange& range);
4861
4862 /**
4863 Paste the clipboard content to the buffer.
4864 */
4865 virtual bool PasteFromClipboard(long position);
4866
4867 /**
4868 Returns @true if we can paste from the clipboard.
4869 */
4870 virtual bool CanPasteFromClipboard() const;
4871
4872 /**
4873 Begin using a style.
4874 */
4875 virtual bool BeginStyle(const wxRichTextAttr& style);
4876
4877 /**
4878 End the style.
4879 */
4880 virtual bool EndStyle();
4881
4882 /**
4883 End all styles.
4884 */
4885 virtual bool EndAllStyles();
4886
4887 /**
4888 Clears the style stack.
4889 */
4890 virtual void ClearStyleStack();
4891
4892 /**
4893 Returns the size of the style stack, for example to check correct nesting.
4894 */
4895 virtual size_t GetStyleStackSize() const { return m_attributeStack.GetCount(); }
4896
4897 /**
4898 Begins using bold.
4899 */
4900 bool BeginBold();
4901
4902 /**
4903 Ends using bold.
4904 */
4905 bool EndBold() { return EndStyle(); }
4906
4907 /**
4908 Begins using italic.
4909 */
4910 bool BeginItalic();
4911
4912 /**
4913 Ends using italic.
4914 */
4915 bool EndItalic() { return EndStyle(); }
4916
4917 /**
4918 Begins using underline.
4919 */
4920 bool BeginUnderline();
4921
4922 /**
4923 Ends using underline.
4924 */
4925 bool EndUnderline() { return EndStyle(); }
4926
4927 /**
4928 Begins using point size.
4929 */
4930 bool BeginFontSize(int pointSize);
4931
4932 /**
4933 Ends using point size.
4934 */
4935 bool EndFontSize() { return EndStyle(); }
4936
4937 /**
4938 Begins using this font.
4939 */
4940 bool BeginFont(const wxFont& font);
4941
4942 /**
4943 Ends using a font.
4944 */
4945 bool EndFont() { return EndStyle(); }
4946
4947 /**
4948 Begins using this colour.
4949 */
4950 bool BeginTextColour(const wxColour& colour);
4951
4952 /**
4953 Ends using a colour.
4954 */
4955 bool EndTextColour() { return EndStyle(); }
4956
4957 /**
4958 Begins using alignment.
4959 */
4960 bool BeginAlignment(wxTextAttrAlignment alignment);
4961
4962 /**
4963 Ends alignment.
4964 */
4965 bool EndAlignment() { return EndStyle(); }
4966
4967 /**
4968 Begins using @a leftIndent for the left indent, and optionally @a leftSubIndent for
4969 the sub-indent. Both are expressed in tenths of a millimetre.
4970
4971 The sub-indent is an offset from the left of the paragraph, and is used for all
4972 but the first line in a paragraph. A positive value will cause the first line to appear
4973 to the left of the subsequent lines, and a negative value will cause the first line to be
4974 indented relative to the subsequent lines.
4975 */
4976 bool BeginLeftIndent(int leftIndent, int leftSubIndent = 0);
4977
4978 /**
4979 Ends left indent.
4980 */
4981 bool EndLeftIndent() { return EndStyle(); }
4982
4983 /**
4984 Begins a right indent, specified in tenths of a millimetre.
4985 */
4986 bool BeginRightIndent(int rightIndent);
4987
4988 /**
4989 Ends right indent.
4990 */
4991 bool EndRightIndent() { return EndStyle(); }
4992
4993 /**
4994 Begins paragraph spacing; pass the before-paragraph and after-paragraph spacing
4995 in tenths of a millimetre.
4996 */
4997 bool BeginParagraphSpacing(int before, int after);
4998
4999 /**
5000 Ends paragraph spacing.
5001 */
5002 bool EndParagraphSpacing() { return EndStyle(); }
5003
5004 /**
5005 Begins line spacing using the specified value. @e spacing is a multiple, where
5006 10 means single-spacing, 15 means 1.5 spacing, and 20 means double spacing.
5007
5008 The ::wxTextAttrLineSpacing enumeration values are defined for convenience.
5009 */
5010 bool BeginLineSpacing(int lineSpacing);
5011
5012 /**
5013 Ends line spacing.
5014 */
5015 bool EndLineSpacing() { return EndStyle(); }
5016
5017 /**
5018 Begins numbered bullet.
5019
5020 This call will be needed for each item in the list, and the
5021 application should take care of incrementing the numbering.
5022
5023 @a bulletNumber is a number, usually starting with 1.
5024 @a leftIndent and @a leftSubIndent are values in tenths of a millimetre.
5025 @a bulletStyle is a bitlist of the following values:
5026
5027 wxRichTextBuffer uses indentation to render a bulleted item.
5028 The left indent is the distance between the margin and the bullet.
5029 The content of the paragraph, including the first line, starts
5030 at leftMargin + leftSubIndent.
5031 So the distance between the left edge of the bullet and the
5032 left of the actual paragraph is leftSubIndent.
5033 */
5034 bool BeginNumberedBullet(int bulletNumber, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_ARABIC|wxTEXT_ATTR_BULLET_STYLE_PERIOD);
5035
5036 /**
5037 Ends numbered bullet.
5038 */
5039 bool EndNumberedBullet() { return EndStyle(); }
5040
5041 /**
5042 Begins applying a symbol bullet, using a character from the current font.
5043
5044 See BeginNumberedBullet() for an explanation of how indentation is used
5045 to render the bulleted paragraph.
5046 */
5047 bool BeginSymbolBullet(const wxString& symbol, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_SYMBOL);
5048
5049 /**
5050 Ends symbol bullet.
5051 */
5052 bool EndSymbolBullet() { return EndStyle(); }
5053
5054 /**
5055 Begins applying a standard bullet, using one of the standard bullet names
5056 (currently @c standard/circle or @c standard/square.
5057
5058 See BeginNumberedBullet() for an explanation of how indentation is used to
5059 render the bulleted paragraph.
5060 */
5061 bool BeginStandardBullet(const wxString& bulletName, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_STANDARD);
5062
5063 /**
5064 Ends standard bullet.
5065 */
5066 bool EndStandardBullet() { return EndStyle(); }
5067
5068 /**
5069 Begins named character style.
5070 */
5071 bool BeginCharacterStyle(const wxString& characterStyle);
5072
5073 /**
5074 Ends named character style.
5075 */
5076 bool EndCharacterStyle() { return EndStyle(); }
5077
5078 /**
5079 Begins named paragraph style.
5080 */
5081 bool BeginParagraphStyle(const wxString& paragraphStyle);
5082
5083 /**
5084 Ends named character style.
5085 */
5086 bool EndParagraphStyle() { return EndStyle(); }
5087
5088 /**
5089 Begins named list style.
5090
5091 Optionally, you can also pass a level and a number.
5092 */
5093 bool BeginListStyle(const wxString& listStyle, int level = 1, int number = 1);
5094
5095 /**
5096 Ends named character style.
5097 */
5098 bool EndListStyle() { return EndStyle(); }
5099
5100 /**
5101 Begins applying wxTEXT_ATTR_URL to the content.
5102
5103 Pass a URL and optionally, a character style to apply, since it is common
5104 to mark a URL with a familiar style such as blue text with underlining.
5105 */
5106 bool BeginURL(const wxString& url, const wxString& characterStyle = wxEmptyString);
5107
5108 /**
5109 Ends URL.
5110 */
5111 bool EndURL() { return EndStyle(); }
5112
5113 // Event handling
5114
5115 /**
5116 Adds an event handler.
5117
5118 A buffer associated with a control has the control as the only event handler,
5119 but the application is free to add more if further notification is required.
5120 All handlers are notified of an event originating from the buffer, such as
5121 the replacement of a style sheet during loading.
5122
5123 The buffer never deletes any of the event handlers, unless RemoveEventHandler()
5124 is called with @true as the second argument.
5125 */
5126 bool AddEventHandler(wxEvtHandler* handler);
5127
5128 /**
5129 Removes an event handler from the buffer's list of handlers, deleting the
5130 object if @a deleteHandler is @true.
5131 */
5132 bool RemoveEventHandler(wxEvtHandler* handler, bool deleteHandler = false);
5133
5134 /**
5135 Clear event handlers.
5136 */
5137 void ClearEventHandlers();
5138
5139 /**
5140 Send event to event handlers. If sendToAll is true, will send to all event handlers,
5141 otherwise will stop at the first successful one.
5142 */
5143 bool SendEvent(wxEvent& event, bool sendToAll = true);
5144
5145 // Implementation
5146
5147 virtual int HitTest(wxDC& dc, wxRichTextDrawingContext& context, const wxPoint& pt, long& textPosition, wxRichTextObject** obj, wxRichTextObject** contextObj, int flags = 0);
5148
5149 /**
5150 Copies the buffer.
5151 */
5152 void Copy(const wxRichTextBuffer& obj);
5153
5154 /**
5155 Assignment operator.
5156 */
5157 void operator= (const wxRichTextBuffer& obj) { Copy(obj); }
5158
5159 /**
5160 Clones the buffer.
5161 */
5162 virtual wxRichTextObject* Clone() const { return new wxRichTextBuffer(*this); }
5163
5164 /**
5165 Submits a command to insert paragraphs.
5166 */
5167 bool InsertParagraphsWithUndo(long pos, const wxRichTextParagraphLayoutBox& paragraphs, wxRichTextCtrl* ctrl, int flags = 0);
5168
5169 /**
5170 Submits a command to insert the given text.
5171 */
5172 bool InsertTextWithUndo(long pos, const wxString& text, wxRichTextCtrl* ctrl, int flags = 0);
5173
5174 /**
5175 Submits a command to insert a newline.
5176 */
5177 bool InsertNewlineWithUndo(long pos, wxRichTextCtrl* ctrl, int flags = 0);
5178
5179 /**
5180 Submits a command to insert the given image.
5181 */
5182 bool InsertImageWithUndo(long pos, const wxRichTextImageBlock& imageBlock, wxRichTextCtrl* ctrl, int flags = 0,
5183 const wxRichTextAttr& textAttr = wxRichTextAttr());
5184
5185 /**
5186 Submits a command to insert an object.
5187 */
5188 wxRichTextObject* InsertObjectWithUndo(long pos, wxRichTextObject *object, wxRichTextCtrl* ctrl, int flags);
5189
5190 /**
5191 Submits a command to delete this range.
5192 */
5193 bool DeleteRangeWithUndo(const wxRichTextRange& range, wxRichTextCtrl* ctrl);
5194
5195 /**
5196 Mark modified.
5197 */
5198 void Modify(bool modify = true) { m_modified = modify; }
5199
5200 /**
5201 Returns @true if the buffer was modified.
5202 */
5203 bool IsModified() const { return m_modified; }
5204
5205 //@{
5206 /**
5207 Dumps contents of buffer for debugging purposes.
5208 */
5209 virtual void Dump();
5210 virtual void Dump(wxTextOutputStream& stream) { wxRichTextParagraphLayoutBox::Dump(stream); }
5211 //@}
5212
5213 /**
5214 Returns the file handlers.
5215 */
5216 static wxList& GetHandlers() { return sm_handlers; }
5217
5218 /**
5219 Adds a file handler to the end.
5220 */
5221 static void AddHandler(wxRichTextFileHandler *handler);
5222
5223 /**
5224 Inserts a file handler at the front.
5225 */
5226 static void InsertHandler(wxRichTextFileHandler *handler);
5227
5228 /**
5229 Removes a file handler.
5230 */
5231 static bool RemoveHandler(const wxString& name);
5232
5233 /**
5234 Finds a file handler by name.
5235 */
5236 static wxRichTextFileHandler *FindHandler(const wxString& name);
5237
5238 /**
5239 Finds a file handler by extension and type.
5240 */
5241 static wxRichTextFileHandler *FindHandler(const wxString& extension, wxRichTextFileType imageType);
5242
5243 /**
5244 Finds a handler by filename or, if supplied, type.
5245 */
5246 static wxRichTextFileHandler *FindHandlerFilenameOrType(const wxString& filename,
5247 wxRichTextFileType imageType);
5248
5249 /**
5250 Finds a handler by type.
5251 */
5252 static wxRichTextFileHandler *FindHandler(wxRichTextFileType imageType);
5253
5254 /**
5255 Gets a wildcard incorporating all visible handlers. If @a types is present,
5256 it will be filled with the file type corresponding to each filter. This can be
5257 used to determine the type to pass to LoadFile given a selected filter.
5258 */
5259 static wxString GetExtWildcard(bool combine = false, bool save = false, wxArrayInt* types = NULL);
5260
5261 /**
5262 Clean up file handlers.
5263 */
5264 static void CleanUpHandlers();
5265
5266 /**
5267 Initialise the standard file handlers.
5268 Currently, only the plain text loading/saving handler is initialised by default.
5269 */
5270 static void InitStandardHandlers();
5271
5272 /**
5273 Returns the drawing handlers.
5274 */
5275 static wxList& GetDrawingHandlers() { return sm_drawingHandlers; }
5276
5277 /**
5278 Adds a drawing handler to the end.
5279 */
5280 static void AddDrawingHandler(wxRichTextDrawingHandler *handler);
5281
5282 /**
5283 Inserts a drawing handler at the front.
5284 */
5285 static void InsertDrawingHandler(wxRichTextDrawingHandler *handler);
5286
5287 /**
5288 Removes a drawing handler.
5289 */
5290 static bool RemoveDrawingHandler(const wxString& name);
5291
5292 /**
5293 Finds a drawing handler by name.
5294 */
5295 static wxRichTextDrawingHandler *FindDrawingHandler(const wxString& name);
5296
5297 /**
5298 Clean up drawing handlers.
5299 */
5300 static void CleanUpDrawingHandlers();
5301
5302 /**
5303 Returns the field types.
5304 */
5305 static wxRichTextFieldTypeHashMap& GetFieldTypes() { return sm_fieldTypes; }
5306
5307 /**
5308 Adds a field type.
5309
5310 @see RemoveFieldType(), FindFieldType(), wxRichTextField, wxRichTextFieldType, wxRichTextFieldTypeStandard
5311
5312 */
5313 static void AddFieldType(wxRichTextFieldType *fieldType);
5314
5315 /**
5316 Removes a field type by name.
5317
5318 @see AddFieldType(), FindFieldType(), wxRichTextField, wxRichTextFieldType, wxRichTextFieldTypeStandard
5319 */
5320 static bool RemoveFieldType(const wxString& name);
5321
5322 /**
5323 Finds a field type by name.
5324
5325 @see RemoveFieldType(), AddFieldType(), wxRichTextField, wxRichTextFieldType, wxRichTextFieldTypeStandard
5326 */
5327 static wxRichTextFieldType *FindFieldType(const wxString& name);
5328
5329 /**
5330 Cleans up field types.
5331 */
5332 static void CleanUpFieldTypes();
5333
5334 /**
5335 Returns the renderer object.
5336 */
5337 static wxRichTextRenderer* GetRenderer() { return sm_renderer; }
5338
5339 /**
5340 Sets @a renderer as the object to be used to render certain aspects of the
5341 content, such as bullets.
5342
5343 You can override default rendering by deriving a new class from
5344 wxRichTextRenderer or wxRichTextStdRenderer, overriding one or more
5345 virtual functions, and setting an instance of the class using this function.
5346 */
5347 static void SetRenderer(wxRichTextRenderer* renderer);
5348
5349 /**
5350 Returns the minimum margin between bullet and paragraph in 10ths of a mm.
5351 */
5352 static int GetBulletRightMargin() { return sm_bulletRightMargin; }
5353
5354 /**
5355 Sets the minimum margin between bullet and paragraph in 10ths of a mm.
5356 */
5357 static void SetBulletRightMargin(int margin) { sm_bulletRightMargin = margin; }
5358
5359 /**
5360 Returns the factor to multiply by character height to get a reasonable bullet size.
5361 */
5362 static float GetBulletProportion() { return sm_bulletProportion; }
5363
5364 /**
5365 Sets the factor to multiply by character height to get a reasonable bullet size.
5366 */
5367 static void SetBulletProportion(float prop) { sm_bulletProportion = prop; }
5368
5369 /**
5370 Returns the scale factor for calculating dimensions.
5371 */
5372 double GetScale() const { return m_scale; }
5373
5374 /**
5375 Sets the scale factor for calculating dimensions.
5376 */
5377 void SetScale(double scale) { m_scale = scale; }
5378
5379 protected:
5380
5381 /// Command processor
5382 wxCommandProcessor* m_commandProcessor;
5383
5384 /// Table storing fonts
5385 wxRichTextFontTable m_fontTable;
5386
5387 /// Has been modified?
5388 bool m_modified;
5389
5390 /// Collapsed command stack
5391 int m_batchedCommandDepth;
5392
5393 /// Name for collapsed command
5394 wxString m_batchedCommandsName;
5395
5396 /// Current collapsed command accumulating actions
5397 wxRichTextCommand* m_batchedCommand;
5398
5399 /// Whether to suppress undo
5400 int m_suppressUndo;
5401
5402 /// Style sheet, if any
5403 wxRichTextStyleSheet* m_styleSheet;
5404
5405 /// List of event handlers that will be notified of events
5406 wxList m_eventHandlers;
5407
5408 /// Stack of attributes for convenience functions
5409 wxList m_attributeStack;
5410
5411 /// Flags to be passed to handlers
5412 int m_handlerFlags;
5413
5414 /// File handlers
5415 static wxList sm_handlers;
5416
5417 /// Drawing handlers
5418 static wxList sm_drawingHandlers;
5419
5420 /// Field types
5421 static wxRichTextFieldTypeHashMap sm_fieldTypes;
5422
5423 /// Renderer
5424 static wxRichTextRenderer* sm_renderer;
5425
5426 /// Minimum margin between bullet and paragraph in 10ths of a mm
5427 static int sm_bulletRightMargin;
5428
5429 /// Factor to multiply by character height to get a reasonable bullet size
5430 static float sm_bulletProportion;
5431
5432 /// Scaling factor in use: needed to calculate correct dimensions when printing
5433 double m_scale;
5434
5435 /// Font scale for adjusting the text size when editing
5436 double m_fontScale;
5437
5438 /// Dimension scale for reducing redundant whitespace when editing
5439 double m_dimensionScale;
5440 };
5441
5442 /**
5443 @class wxRichTextCell
5444
5445 wxRichTextCell is the cell in a table.
5446 */
5447
5448 class WXDLLIMPEXP_RICHTEXT wxRichTextCell: public wxRichTextBox
5449 {
5450 DECLARE_DYNAMIC_CLASS(wxRichTextCell)
5451 public:
5452 // Constructors
5453
5454 /**
5455 Default constructor; optionally pass the parent object.
5456 */
5457
5458 wxRichTextCell(wxRichTextObject* parent = NULL);
5459
5460 /**
5461 Copy constructor.
5462 */
5463
5464 wxRichTextCell(const wxRichTextCell& obj): wxRichTextBox() { Copy(obj); }
5465
5466 // Overridables
5467
5468 virtual bool Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
5469
5470 virtual wxString GetXMLNodeName() const { return wxT("cell"); }
5471
5472 virtual bool CanEditProperties() const { return true; }
5473
5474 virtual bool EditProperties(wxWindow* parent, wxRichTextBuffer* buffer);
5475
5476 virtual wxString GetPropertiesMenuLabel() const { return _("&Cell"); }
5477
5478 // Accessors
5479
5480 // Operations
5481
5482 virtual wxRichTextObject* Clone() const { return new wxRichTextCell(*this); }
5483
5484 void Copy(const wxRichTextCell& obj);
5485
5486 protected:
5487 };
5488
5489 /**
5490 @class wxRichTextTable
5491
5492 wxRichTextTable represents a table with arbitrary columns and rows.
5493 */
5494
5495 WX_DEFINE_ARRAY_PTR(wxRichTextObject*, wxRichTextObjectPtrArray);
5496 WX_DECLARE_OBJARRAY(wxRichTextObjectPtrArray, wxRichTextObjectPtrArrayArray);
5497
5498 class WXDLLIMPEXP_RICHTEXT wxRichTextTable: public wxRichTextBox
5499 {
5500 DECLARE_DYNAMIC_CLASS(wxRichTextTable)
5501 public:
5502
5503 // Constructors
5504
5505 /**
5506 Default constructor; optionally pass the parent object.
5507 */
5508
5509 wxRichTextTable(wxRichTextObject* parent = NULL);
5510
5511 /**
5512 Copy constructor.
5513 */
5514
5515 wxRichTextTable(const wxRichTextTable& obj): wxRichTextBox() { Copy(obj); }
5516
5517 // Overridables
5518
5519 virtual bool Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);
5520
5521 virtual wxString GetXMLNodeName() const { return wxT("table"); }
5522
5523 virtual bool Layout(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, const wxRect& parentRect, int style);
5524
5525 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int flags, wxPoint position = wxPoint(0,0), wxArrayInt* partialExtents = NULL) const;
5526
5527 virtual bool DeleteRange(const wxRichTextRange& range);
5528
5529 virtual wxString GetTextForRange(const wxRichTextRange& range) const;
5530
5531 #if wxUSE_XML
5532 virtual bool ImportFromXML(wxRichTextBuffer* buffer, wxXmlNode* node, wxRichTextXMLHandler* handler, bool* recurse);
5533 #endif
5534
5535 #if wxRICHTEXT_HAVE_DIRECT_OUTPUT
5536 virtual bool ExportXML(wxOutputStream& stream, int indent, wxRichTextXMLHandler* handler);
5537 #endif
5538
5539 #if wxRICHTEXT_HAVE_XMLDOCUMENT_OUTPUT
5540 virtual bool ExportXML(wxXmlNode* parent, wxRichTextXMLHandler* handler);
5541 #endif
5542
5543 virtual bool FindPosition(wxDC& dc, wxRichTextDrawingContext& context, long index, wxPoint& pt, int* height, bool forceLineStart);
5544
5545 virtual void CalculateRange(long start, long& end);
5546
5547 // Can this object handle the selections of its children? FOr example, a table.
5548 virtual bool HandlesChildSelections() const { return true; }
5549
5550 /// Returns a selection object specifying the selections between start and end character positions.
5551 /// For example, a table would deduce what cells (of range length 1) are selected when dragging across the table.
5552 virtual wxRichTextSelection GetSelection(long start, long end) const;
5553
5554 virtual bool CanEditProperties() const { return true; }
5555
5556 virtual bool EditProperties(wxWindow* parent, wxRichTextBuffer* buffer);
5557
5558 virtual wxString GetPropertiesMenuLabel() const { return _("&Table"); }
5559
5560 // Returns true if objects of this class can accept the focus, i.e. a call to SetFocusObject
5561 // is possible. For example, containers supporting text, such as a text box object, can accept the focus,
5562 // but a table can't (set the focus to individual cells instead).
5563 virtual bool AcceptsFocus() const { return false; }
5564
5565 // Accessors
5566
5567 /**
5568 Returns the cells array.
5569 */
5570 const wxRichTextObjectPtrArrayArray& GetCells() const { return m_cells; }
5571
5572 /**
5573 Returns the cells array.
5574 */
5575 wxRichTextObjectPtrArrayArray& GetCells() { return m_cells; }
5576
5577 /**
5578 Returns the row count.
5579 */
5580 int GetRowCount() const { return m_rowCount; }
5581
5582 /**
5583 Returns the column count.
5584 */
5585 int GetColumnCount() const { return m_colCount; }
5586
5587 /**
5588 Returns the cell at the given row/column position.
5589 */
5590 virtual wxRichTextCell* GetCell(int row, int col) const;
5591
5592 /**
5593 Returns the cell at the given character position (in the range of the table).
5594 */
5595 virtual wxRichTextCell* GetCell(long pos) const;
5596
5597 /**
5598 Returns the row/column for a given character position.
5599 */
5600 virtual bool GetCellRowColumnPosition(long pos, int& row, int& col) const;
5601
5602 // Operations
5603
5604 /**
5605 Clears the table.
5606 */
5607
5608 virtual void ClearTable();
5609
5610 /**
5611 Creates a table of the given dimensions.
5612 */
5613
5614 virtual bool CreateTable(int rows, int cols);
5615
5616 /**
5617 Sets the attributes for the cells specified by the selection.
5618 */
5619
5620 virtual bool SetCellStyle(const wxRichTextSelection& selection, const wxRichTextAttr& style, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
5621
5622 /**
5623 Deletes rows from the given row position.
5624 */
5625
5626 virtual bool DeleteRows(int startRow, int noRows = 1);
5627
5628 /**
5629 Deletes columns from the given column position.
5630 */
5631
5632 virtual bool DeleteColumns(int startCol, int noCols = 1);
5633
5634 /**
5635 Adds rows from the given row position.
5636 */
5637
5638 virtual bool AddRows(int startRow, int noRows = 1, const wxRichTextAttr& attr = wxRichTextAttr());
5639
5640 /**
5641 Adds columns from the given column position.
5642 */
5643
5644 virtual bool AddColumns(int startCol, int noCols = 1, const wxRichTextAttr& attr = wxRichTextAttr());
5645
5646 // Makes a clone of this object.
5647 virtual wxRichTextObject* Clone() const { return new wxRichTextTable(*this); }
5648
5649 // Copies this object.
5650 void Copy(const wxRichTextTable& obj);
5651
5652 protected:
5653
5654 int m_rowCount;
5655 int m_colCount;
5656
5657 // An array of rows, each of which is a wxRichTextObjectPtrArray containing
5658 // the cell objects. The cell objects are also children of this object.
5659 // Problem: if boxes are immediate children of a box, this will cause problems
5660 // with wxRichTextParagraphLayoutBox functions (and functions elsewhere) that
5661 // expect to find just paragraphs. May have to adjust the way we handle the
5662 // hierarchy to accept non-paragraph objects in a paragraph layout box.
5663 // We'll be overriding much wxRichTextParagraphLayoutBox functionality so this
5664 // may not be such a problem. Perhaps the table should derive from a different
5665 // class?
5666 wxRichTextObjectPtrArrayArray m_cells;
5667 };
5668
5669
5670 /**
5671 The command identifiers for Do/Undo.
5672 */
5673
5674 enum wxRichTextCommandId
5675 {
5676 wxRICHTEXT_INSERT,
5677 wxRICHTEXT_DELETE,
5678 wxRICHTEXT_CHANGE_ATTRIBUTES,
5679 wxRICHTEXT_CHANGE_STYLE,
5680 wxRICHTEXT_CHANGE_PROPERTIES,
5681 wxRICHTEXT_CHANGE_OBJECT
5682 };
5683
5684 /**
5685 @class wxRichTextObjectAddress
5686
5687 A class for specifying an object anywhere in an object hierarchy,
5688 without using a pointer, necessary since wxRTC commands may delete
5689 and recreate sub-objects so physical object addresses change. An array
5690 of positions (one per hierarchy level) is used.
5691
5692 @library{wxrichtext}
5693 @category{richtext}
5694
5695 @see wxRichTextCommand
5696 */
5697
5698 class WXDLLIMPEXP_RICHTEXT wxRichTextObjectAddress
5699 {
5700 public:
5701 /**
5702 Creates the address given a container and an object.
5703 */
5704 wxRichTextObjectAddress(wxRichTextParagraphLayoutBox* topLevelContainer, wxRichTextObject* obj) { Create(topLevelContainer, obj); }
5705 /**
5706 */
5707 wxRichTextObjectAddress() { Init(); }
5708 /**
5709 */
5710 wxRichTextObjectAddress(const wxRichTextObjectAddress& address) { Copy(address); }
5711
5712 void Init() {}
5713
5714 /**
5715 Copies the address.
5716 */
5717 void Copy(const wxRichTextObjectAddress& address) { m_address = address.m_address; }
5718
5719 /**
5720 Assignment operator.
5721 */
5722 void operator=(const wxRichTextObjectAddress& address) { Copy(address); }
5723
5724 /**
5725 Returns the object specified by the address, given a top level container.
5726 */
5727 wxRichTextObject* GetObject(wxRichTextParagraphLayoutBox* topLevelContainer) const;
5728
5729 /**
5730 Creates the address given a container and an object.
5731 */
5732 bool Create(wxRichTextParagraphLayoutBox* topLevelContainer, wxRichTextObject* obj);
5733
5734 /**
5735 Returns the array of integers representing the object address.
5736 */
5737 wxArrayInt& GetAddress() { return m_address; }
5738
5739 /**
5740 Returns the array of integers representing the object address.
5741 */
5742 const wxArrayInt& GetAddress() const { return m_address; }
5743
5744 /**
5745 Sets the address from an array of integers.
5746 */
5747 void SetAddress(const wxArrayInt& address) { m_address = address; }
5748
5749 protected:
5750
5751 wxArrayInt m_address;
5752 };
5753
5754 class WXDLLIMPEXP_FWD_RICHTEXT wxRichTextAction;
5755
5756 /**
5757 @class wxRichTextCommand
5758
5759 Implements a command on the undo/redo stack. A wxRichTextCommand object contains one or more wxRichTextAction
5760 objects, allowing aggregation of a number of operations into one command.
5761
5762 @library{wxrichtext}
5763 @category{richtext}
5764
5765 @see wxRichTextAction
5766 */
5767
5768 class WXDLLIMPEXP_RICHTEXT wxRichTextCommand: public wxCommand
5769 {
5770 public:
5771 /**
5772 Constructor for one action.
5773 */
5774 wxRichTextCommand(const wxString& name, wxRichTextCommandId id, wxRichTextBuffer* buffer,
5775 wxRichTextParagraphLayoutBox* container, wxRichTextCtrl* ctrl, bool ignoreFirstTime = false);
5776
5777 /**
5778 Constructor for multiple actions.
5779 */
5780 wxRichTextCommand(const wxString& name);
5781
5782 virtual ~wxRichTextCommand();
5783
5784 /**
5785 Performs the command.
5786 */
5787 bool Do();
5788
5789 /**
5790 Undoes the command.
5791 */
5792 bool Undo();
5793
5794 /**
5795 Adds an action to the action list.
5796 */
5797 void AddAction(wxRichTextAction* action);
5798
5799 /**
5800 Clears the action list.
5801 */
5802 void ClearActions();
5803
5804 /**
5805 Returns the action list.
5806 */
5807 wxList& GetActions() { return m_actions; }
5808
5809 protected:
5810
5811 wxList m_actions;
5812 };
5813
5814 /**
5815 @class wxRichTextAction
5816
5817 Implements a part of a command.
5818
5819 @library{wxrichtext}
5820 @category{richtext}
5821
5822 @see wxRichTextCommand
5823 */
5824
5825 class WXDLLIMPEXP_RICHTEXT wxRichTextAction: public wxObject
5826 {
5827 public:
5828 /**
5829 Constructor. @a buffer is the top-level buffer, while @a container is the object within
5830 which the action is taking place. In the simplest case, they are the same.
5831 */
5832 wxRichTextAction(wxRichTextCommand* cmd, const wxString& name, wxRichTextCommandId id,
5833 wxRichTextBuffer* buffer, wxRichTextParagraphLayoutBox* container,
5834 wxRichTextCtrl* ctrl, bool ignoreFirstTime = false);
5835
5836 virtual ~wxRichTextAction();
5837
5838 /**
5839 Performs the action.
5840 */
5841 bool Do();
5842
5843 /**
5844 Undoes the action.
5845 */
5846 bool Undo();
5847
5848 /**
5849 Updates the control appearance, optimizing if possible given information from the call to Layout.
5850 */
5851 void UpdateAppearance(long caretPosition, bool sendUpdateEvent = false,
5852 wxArrayInt* optimizationLineCharPositions = NULL, wxArrayInt* optimizationLineYPositions = NULL, bool isDoCmd = true);
5853
5854 /**
5855 Replaces the buffer paragraphs with the given fragment.
5856 */
5857 void ApplyParagraphs(const wxRichTextParagraphLayoutBox& fragment);
5858
5859 /**
5860 Returns the new fragments.
5861 */
5862 wxRichTextParagraphLayoutBox& GetNewParagraphs() { return m_newParagraphs; }
5863
5864 /**
5865 Returns the old fragments.
5866 */
5867 wxRichTextParagraphLayoutBox& GetOldParagraphs() { return m_oldParagraphs; }
5868
5869 /**
5870 Returns the attributes, for single-object commands.
5871 */
5872 wxRichTextAttr& GetAttributes() { return m_attributes; }
5873
5874 /**
5875 Returns the object to replace the one at the position defined by the container address
5876 and the action's range start position.
5877 */
5878 wxRichTextObject* GetObject() const { return m_object; }
5879
5880 /**
5881 Sets the object to replace the one at the position defined by the container address
5882 and the action's range start position.
5883 */
5884 void SetObject(wxRichTextObject* obj) { m_object = obj; m_objectAddress.Create(m_buffer, m_object); }
5885
5886 /**
5887 Makes an address from the given object.
5888 */
5889 void MakeObject(wxRichTextObject* obj) { m_objectAddress.Create(m_buffer, obj); }
5890
5891 /**
5892 Calculate arrays for refresh optimization.
5893 */
5894 void CalculateRefreshOptimizations(wxArrayInt& optimizationLineCharPositions, wxArrayInt& optimizationLineYPositions);
5895
5896 /**
5897 Sets the position used for e.g. insertion.
5898 */
5899 void SetPosition(long pos) { m_position = pos; }
5900
5901 /**
5902 Returns the position used for e.g. insertion.
5903 */
5904 long GetPosition() const { return m_position; }
5905
5906 /**
5907 Sets the range for e.g. deletion.
5908 */
5909 void SetRange(const wxRichTextRange& range) { m_range = range; }
5910
5911 /**
5912 Returns the range for e.g. deletion.
5913 */
5914 const wxRichTextRange& GetRange() const { return m_range; }
5915
5916 /**
5917 Returns the address (nested position) of the container within the buffer being manipulated.
5918 */
5919 wxRichTextObjectAddress& GetContainerAddress() { return m_containerAddress; }
5920
5921 /**
5922 Returns the address (nested position) of the container within the buffer being manipulated.
5923 */
5924 const wxRichTextObjectAddress& GetContainerAddress() const { return m_containerAddress; }
5925
5926 /**
5927 Sets the address (nested position) of the container within the buffer being manipulated.
5928 */
5929 void SetContainerAddress(const wxRichTextObjectAddress& address) { m_containerAddress = address; }
5930
5931 /**
5932 Sets the address (nested position) of the container within the buffer being manipulated.
5933 */
5934 void SetContainerAddress(wxRichTextParagraphLayoutBox* container, wxRichTextObject* obj) { m_containerAddress.Create(container, obj); }
5935
5936 /**
5937 Returns the container that this action refers to, using the container address and top-level buffer.
5938 */
5939 wxRichTextParagraphLayoutBox* GetContainer() const;
5940
5941 /**
5942 Returns the action name.
5943 */
5944 const wxString& GetName() const { return m_name; }
5945
5946 protected:
5947 // Action name
5948 wxString m_name;
5949
5950 // Buffer
5951 wxRichTextBuffer* m_buffer;
5952
5953 // The address (nested position) of the container being manipulated.
5954 // This is necessary because objects are deleted, and we can't
5955 // therefore store actual pointers.
5956 wxRichTextObjectAddress m_containerAddress;
5957
5958 // Control
5959 wxRichTextCtrl* m_ctrl;
5960
5961 // Stores the new paragraphs
5962 wxRichTextParagraphLayoutBox m_newParagraphs;
5963
5964 // Stores the old paragraphs
5965 wxRichTextParagraphLayoutBox m_oldParagraphs;
5966
5967 // Stores an object to replace the one at the position
5968 // defined by the container address and the action's range start position.
5969 wxRichTextObject* m_object;
5970
5971 // Stores the attributes
5972 wxRichTextAttr m_attributes;
5973
5974 // The address of the object being manipulated (used for changing an individual object or its attributes)
5975 wxRichTextObjectAddress m_objectAddress;
5976
5977 // Stores the old attributes
5978 // wxRichTextAttr m_oldAttributes;
5979
5980 // The affected range
5981 wxRichTextRange m_range;
5982
5983 // The insertion point for this command
5984 long m_position;
5985
5986 // Ignore 1st 'Do' operation because we already did it
5987 bool m_ignoreThis;
5988
5989 // The command identifier
5990 wxRichTextCommandId m_cmdId;
5991 };
5992
5993 /*!
5994 * Handler flags
5995 */
5996
5997 // Include style sheet when loading and saving
5998 #define wxRICHTEXT_HANDLER_INCLUDE_STYLESHEET 0x0001
5999
6000 // Save images to memory file system in HTML handler
6001 #define wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_MEMORY 0x0010
6002
6003 // Save images to files in HTML handler
6004 #define wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_FILES 0x0020
6005
6006 // Save images as inline base64 data in HTML handler
6007 #define wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_BASE64 0x0040
6008
6009 // Don't write header and footer (or BODY), so we can include the fragment
6010 // in a larger document
6011 #define wxRICHTEXT_HANDLER_NO_HEADER_FOOTER 0x0080
6012
6013 // Convert the more common face names to names that will work on the current platform
6014 // in a larger document
6015 #define wxRICHTEXT_HANDLER_CONVERT_FACENAMES 0x0100
6016
6017 /**
6018 @class wxRichTextFileHandler
6019
6020 The base class for file handlers.
6021
6022 @library{wxrichtext}
6023 @category{richtext}
6024
6025 @see wxRichTextBuffer, wxRichTextCtrl
6026 */
6027
6028 class WXDLLIMPEXP_RICHTEXT wxRichTextFileHandler: public wxObject
6029 {
6030 DECLARE_CLASS(wxRichTextFileHandler)
6031 public:
6032 /**
6033 Creates a file handler object.
6034 */
6035 wxRichTextFileHandler(const wxString& name = wxEmptyString, const wxString& ext = wxEmptyString, int type = 0)
6036 : m_name(name), m_extension(ext), m_type(type), m_flags(0), m_visible(true)
6037 { }
6038
6039 #if wxUSE_STREAMS
6040 /**
6041 Loads the buffer from a stream.
6042 Not all handlers will implement file loading.
6043 */
6044 bool LoadFile(wxRichTextBuffer *buffer, wxInputStream& stream)
6045 { return DoLoadFile(buffer, stream); }
6046
6047 /**
6048 Saves the buffer to a stream.
6049 Not all handlers will implement file saving.
6050 */
6051 bool SaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream)
6052 { return DoSaveFile(buffer, stream); }
6053 #endif
6054
6055 #if wxUSE_FFILE && wxUSE_STREAMS
6056 /**
6057 Loads the buffer from a file.
6058 */
6059 virtual bool LoadFile(wxRichTextBuffer *buffer, const wxString& filename);
6060
6061 /**
6062 Saves the buffer to a file.
6063 */
6064 virtual bool SaveFile(wxRichTextBuffer *buffer, const wxString& filename);
6065 #endif // wxUSE_STREAMS && wxUSE_STREAMS
6066
6067 /**
6068 Returns @true if we handle this filename (if using files). By default, checks the extension.
6069 */
6070 virtual bool CanHandle(const wxString& filename) const;
6071
6072 /**
6073 Returns @true if we can save using this handler.
6074 */
6075 virtual bool CanSave() const { return false; }
6076
6077 /**
6078 Returns @true if we can load using this handler.
6079 */
6080 virtual bool CanLoad() const { return false; }
6081
6082 /**
6083 Returns @true if this handler should be visible to the user.
6084 */
6085 virtual bool IsVisible() const { return m_visible; }
6086
6087 /**
6088 Sets whether the handler should be visible to the user (via the application's
6089 load and save dialogs).
6090 */
6091 virtual void SetVisible(bool visible) { m_visible = visible; }
6092
6093 /**
6094 Sets the name of the handler.
6095 */
6096 void SetName(const wxString& name) { m_name = name; }
6097
6098 /**
6099 Returns the name of the handler.
6100 */
6101 wxString GetName() const { return m_name; }
6102
6103 /**
6104 Sets the default extension to recognise.
6105 */
6106 void SetExtension(const wxString& ext) { m_extension = ext; }
6107
6108 /**
6109 Returns the default extension to recognise.
6110 */
6111 wxString GetExtension() const { return m_extension; }
6112
6113 /**
6114 Sets the handler type.
6115 */
6116 void SetType(int type) { m_type = type; }
6117
6118 /**
6119 Returns the handler type.
6120 */
6121 int GetType() const { return m_type; }
6122
6123 /**
6124 Sets flags that change the behaviour of loading or saving.
6125 See the documentation for each handler class to see what flags are relevant
6126 for each handler.
6127
6128 You call this function directly if you are using a file handler explicitly
6129 (without going through the text control or buffer LoadFile/SaveFile API).
6130 Or, you can call the control or buffer's SetHandlerFlags function to set
6131 the flags that will be used for subsequent load and save operations.
6132 */
6133 void SetFlags(int flags) { m_flags = flags; }
6134
6135 /**
6136 Returns flags controlling how loading and saving is done.
6137 */
6138 int GetFlags() const { return m_flags; }
6139
6140 /**
6141 Sets the encoding to use when saving a file. If empty, a suitable encoding is chosen.
6142 */
6143 void SetEncoding(const wxString& encoding) { m_encoding = encoding; }
6144
6145 /**
6146 Returns the encoding to use when saving a file. If empty, a suitable encoding is chosen.
6147 */
6148 const wxString& GetEncoding() const { return m_encoding; }
6149
6150 protected:
6151
6152 #if wxUSE_STREAMS
6153 /**
6154 Override to load content from @a stream into @a buffer.
6155 */
6156 virtual bool DoLoadFile(wxRichTextBuffer *buffer, wxInputStream& stream) = 0;
6157
6158 /**
6159 Override to save content to @a stream from @a buffer.
6160 */
6161 virtual bool DoSaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream) = 0;
6162 #endif
6163
6164 wxString m_name;
6165 wxString m_encoding;
6166 wxString m_extension;
6167 int m_type;
6168 int m_flags;
6169 bool m_visible;
6170 };
6171
6172 /**
6173 @class wxRichTextPlainTextHandler
6174
6175 Implements saving a buffer to plain text.
6176
6177 @library{wxrichtext}
6178 @category{richtext}
6179
6180 @see wxRichTextFileHandler, wxRichTextBuffer, wxRichTextCtrl
6181 */
6182
6183 class WXDLLIMPEXP_RICHTEXT wxRichTextPlainTextHandler: public wxRichTextFileHandler
6184 {
6185 DECLARE_CLASS(wxRichTextPlainTextHandler)
6186 public:
6187 wxRichTextPlainTextHandler(const wxString& name = wxT("Text"),
6188 const wxString& ext = wxT("txt"),
6189 wxRichTextFileType type = wxRICHTEXT_TYPE_TEXT)
6190 : wxRichTextFileHandler(name, ext, type)
6191 { }
6192
6193 // Can we save using this handler?
6194 virtual bool CanSave() const { return true; }
6195
6196 // Can we load using this handler?
6197 virtual bool CanLoad() const { return true; }
6198
6199 protected:
6200
6201 #if wxUSE_STREAMS
6202 virtual bool DoLoadFile(wxRichTextBuffer *buffer, wxInputStream& stream);
6203 virtual bool DoSaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream);
6204 #endif
6205
6206 };
6207
6208 /**
6209 @class wxRichTextDrawingHandler
6210
6211 The base class for custom drawing handlers.
6212 Currently, drawing handlers can provide virtual attributes.
6213
6214 @library{wxrichtext}
6215 @category{richtext}
6216
6217 @see wxRichTextBuffer, wxRichTextCtrl
6218 */
6219
6220 class WXDLLIMPEXP_RICHTEXT wxRichTextDrawingHandler: public wxObject
6221 {
6222 DECLARE_CLASS(wxRichTextDrawingHandler)
6223 public:
6224 /**
6225 Creates a drawing handler object.
6226 */
6227 wxRichTextDrawingHandler(const wxString& name = wxEmptyString)
6228 : m_name(name)
6229 { }
6230
6231 /**
6232 Returns @true if this object has virtual attributes that we can provide.
6233 */
6234 virtual bool HasVirtualAttributes(wxRichTextObject* obj) const = 0;
6235
6236 /**
6237 Provides virtual attributes that we can provide.
6238 */
6239 virtual bool GetVirtualAttributes(wxRichTextAttr& attr, wxRichTextObject* obj) const = 0;
6240
6241 /**
6242 Sets the name of the handler.
6243 */
6244 void SetName(const wxString& name) { m_name = name; }
6245
6246 /**
6247 Returns the name of the handler.
6248 */
6249 wxString GetName() const { return m_name; }
6250
6251 protected:
6252
6253 wxString m_name;
6254 };
6255
6256 #if wxUSE_DATAOBJ
6257
6258 /**
6259 @class wxRichTextBufferDataObject
6260
6261 Implements a rich text data object for clipboard transfer.
6262
6263 @library{wxrichtext}
6264 @category{richtext}
6265
6266 @see wxDataObjectSimple, wxRichTextBuffer, wxRichTextCtrl
6267 */
6268
6269 class WXDLLIMPEXP_RICHTEXT wxRichTextBufferDataObject: public wxDataObjectSimple
6270 {
6271 public:
6272 /**
6273 The constructor doesn't copy the pointer, so it shouldn't go away while this object
6274 is alive.
6275 */
6276 wxRichTextBufferDataObject(wxRichTextBuffer* richTextBuffer = NULL);
6277 virtual ~wxRichTextBufferDataObject();
6278
6279 /**
6280 After a call to this function, the buffer is owned by the caller and it
6281 is responsible for deleting it.
6282 */
6283 wxRichTextBuffer* GetRichTextBuffer();
6284
6285 /**
6286 Returns the id for the new data format.
6287 */
6288 static const wxChar* GetRichTextBufferFormatId() { return ms_richTextBufferFormatId; }
6289
6290 // base class pure virtuals
6291
6292 virtual wxDataFormat GetPreferredFormat(Direction dir) const;
6293 virtual size_t GetDataSize() const;
6294 virtual bool GetDataHere(void *pBuf) const;
6295 virtual bool SetData(size_t len, const void *buf);
6296
6297 // prevent warnings
6298
6299 virtual size_t GetDataSize(const wxDataFormat&) const { return GetDataSize(); }
6300 virtual bool GetDataHere(const wxDataFormat&, void *buf) const { return GetDataHere(buf); }
6301 virtual bool SetData(const wxDataFormat&, size_t len, const void *buf) { return SetData(len, buf); }
6302
6303 private:
6304 wxDataFormat m_formatRichTextBuffer; // our custom format
6305 wxRichTextBuffer* m_richTextBuffer; // our data
6306 static const wxChar* ms_richTextBufferFormatId; // our format id
6307 };
6308
6309 #endif
6310
6311 /**
6312 @class wxRichTextRenderer
6313
6314 This class isolates some common drawing functionality.
6315
6316 @library{wxrichtext}
6317 @category{richtext}
6318
6319 @see wxRichTextBuffer, wxRichTextCtrl
6320 */
6321
6322 class WXDLLIMPEXP_RICHTEXT wxRichTextRenderer: public wxObject
6323 {
6324 public:
6325 /**
6326 Constructor.
6327 */
6328 wxRichTextRenderer() {}
6329 virtual ~wxRichTextRenderer() {}
6330
6331 /**
6332 Draws a standard bullet, as specified by the value of GetBulletName. This function should be overridden.
6333 */
6334 virtual bool DrawStandardBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect) = 0;
6335
6336 /**
6337 Draws a bullet that can be described by text, such as numbered or symbol bullets. This function should be overridden.
6338 */
6339 virtual bool DrawTextBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect, const wxString& text) = 0;
6340
6341 /**
6342 Draws a bitmap bullet, where the bullet bitmap is specified by the value of GetBulletName. This function should be overridden.
6343 */
6344 virtual bool DrawBitmapBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect) = 0;
6345
6346 /**
6347 Enumerate the standard bullet names currently supported. This function should be overridden.
6348 */
6349 virtual bool EnumerateStandardBulletNames(wxArrayString& bulletNames) = 0;
6350 };
6351
6352 /**
6353 @class wxRichTextStdRenderer
6354
6355 The standard renderer for drawing bullets.
6356
6357 @library{wxrichtext}
6358 @category{richtext}
6359
6360 @see wxRichTextRenderer, wxRichTextBuffer, wxRichTextCtrl
6361 */
6362
6363 class WXDLLIMPEXP_RICHTEXT wxRichTextStdRenderer: public wxRichTextRenderer
6364 {
6365 public:
6366 /**
6367 Constructor.
6368 */
6369 wxRichTextStdRenderer() {}
6370
6371 // Draw a standard bullet, as specified by the value of GetBulletName
6372 virtual bool DrawStandardBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect);
6373
6374 // Draw a bullet that can be described by text, such as numbered or symbol bullets
6375 virtual bool DrawTextBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect, const wxString& text);
6376
6377 // Draw a bitmap bullet, where the bullet bitmap is specified by the value of GetBulletName
6378 virtual bool DrawBitmapBullet(wxRichTextParagraph* paragraph, wxDC& dc, const wxRichTextAttr& attr, const wxRect& rect);
6379
6380 // Enumerate the standard bullet names currently supported
6381 virtual bool EnumerateStandardBulletNames(wxArrayString& bulletNames);
6382 };
6383
6384 /*!
6385 * Utilities
6386 *
6387 */
6388
6389 inline bool wxRichTextHasStyle(int flags, int style)
6390 {
6391 return ((flags & style) == style);
6392 }
6393
6394 /// Compare two attribute objects
6395 WXDLLIMPEXP_RICHTEXT bool wxTextAttrEq(const wxRichTextAttr& attr1, const wxRichTextAttr& attr2);
6396 WXDLLIMPEXP_RICHTEXT bool wxTextAttrEq(const wxRichTextAttr& attr1, const wxRichTextAttr& attr2);
6397
6398 /// Apply one style to another
6399 WXDLLIMPEXP_RICHTEXT bool wxRichTextApplyStyle(wxRichTextAttr& destStyle, const wxRichTextAttr& style, wxRichTextAttr* compareWith = NULL);
6400
6401 // Remove attributes
6402 WXDLLIMPEXP_RICHTEXT bool wxRichTextRemoveStyle(wxRichTextAttr& destStyle, const wxRichTextAttr& style);
6403
6404 /// Combine two bitlists
6405 WXDLLIMPEXP_RICHTEXT bool wxRichTextCombineBitlists(int& valueA, int valueB, int& flagsA, int flagsB);
6406
6407 /// Compare two bitlists
6408 WXDLLIMPEXP_RICHTEXT bool wxRichTextBitlistsEqPartial(int valueA, int valueB, int flags);
6409
6410 /// Split into paragraph and character styles
6411 WXDLLIMPEXP_RICHTEXT bool wxRichTextSplitParaCharStyles(const wxRichTextAttr& style, wxRichTextAttr& parStyle, wxRichTextAttr& charStyle);
6412
6413 /// Compare tabs
6414 WXDLLIMPEXP_RICHTEXT bool wxRichTextTabsEq(const wxArrayInt& tabs1, const wxArrayInt& tabs2);
6415
6416 /// Convert a decimal to Roman numerals
6417 WXDLLIMPEXP_RICHTEXT wxString wxRichTextDecimalToRoman(long n);
6418
6419 // Collects the attributes that are common to a range of content, building up a note of
6420 // which attributes are absent in some objects and which clash in some objects.
6421 WXDLLIMPEXP_RICHTEXT void wxTextAttrCollectCommonAttributes(wxTextAttr& currentStyle, const wxTextAttr& attr, wxTextAttr& clashingAttr, wxTextAttr& absentAttr);
6422
6423 WXDLLIMPEXP_RICHTEXT void wxRichTextModuleInit();
6424
6425 #endif
6426 // wxUSE_RICHTEXT
6427
6428 #endif
6429 // _WX_RICHTEXTBUFFER_H_
6430