]> git.saurik.com Git - wxWidgets.git/blob - include/wx/richtext/richtextbuffer.h
Fixed bug introduced by compiler compatibility fix
[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 will be a single box representing the document,
26 and this box will a wxRichTextParagraphLayoutBox which contains further
27 wxRichTextParagraph 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 Layout
38 ======
39
40 When Layout is called on an object, it is given a size which the object
41 must limit itself to, or one or more flexible directions (vertical
42 or horizontal). So for example a centered paragraph is given the page
43 width to play with (minus any margins), but can extend indefinitely
44 in the vertical direction. The implementation of Layout can then
45 cache the calculated size and position within the parent.
46
47 Note that position and size should be calculated separately, because
48 for example inserting a paragraph may result in the following paragraphs
49 moving down, but not changing in size.
50
51 Need to determine how objects specify their position. Absolute coordinates,
52 or relative to last object? May be hard to determine that. So should probably
53 be in absolute coordinates, in which case we'll need a Move virtual function
54 that allows quick movement of all elements without layout.
55
56 Let's work through a simple example of layout. Say we're laying out
57 a document with the buffer as the top box, with a wxRichTextParagraphLayoutBox
58 inside that that consists of wxRichTextParagraph objects.
59
60 We're in a mode whereby changes of window size change the width of the
61 page (useful for text editors, as opposed to word processors). The
62 window width is 600.
63
64 We pass (600, -1) to the top-level Layout (i.e. restrict size in horizontal
65 direction only). The wxRichTextBuffer box doesn't currently have
66 well-defined layout behaviour so we simply assume it has one child
67 that fills its parent (later we can define sizer-like box layout behaviour).
68 So it passes the same dimensions to the child, which is a wxRichTextParagraphLayoutBox.
69 This then looks at each child in turn (wxRichTextParagraph) and determines
70 the size the paragraph will take up, setting the cached size, and
71 splitting the paragraph into lines.
72
73 When the layout for one paragraph returns, the next paragraph is
74 fed the position of the previous, so it can position itself.
75
76 Each time Layout is called, the cached list of lines for each paragraph
77 is recreated, since it can change for example if the parent object width
78 changes.
79
80 Reporting size
81 ==============
82
83 Each object can report its size for a given range. It's important that
84 it can report a partial size, so that wrapping can be implemented,
85 hit test calculations performed, etc. So GetRangeSize must be implemented
86 for each object.
87
88 */
89
90 /*!
91 * Includes
92 */
93
94 #include "wx/defs.h"
95
96 #if wxUSE_RICHTEXT
97
98 #include "wx/list.h"
99 #include "wx/textctrl.h"
100 #include "wx/bitmap.h"
101 #include "wx/image.h"
102 #include "wx/cmdproc.h"
103 #include "wx/txtstrm.h"
104
105 /*!
106 * File types
107 */
108
109 #define wxRICHTEXT_TYPE_ANY 0
110 #define wxRICHTEXT_TYPE_TEXT 1
111 #define wxRICHTEXT_TYPE_XML 2
112 #define wxRICHTEXT_TYPE_HTML 3
113 #define wxRICHTEXT_TYPE_RTF 4
114 #define wxRICHTEXT_TYPE_PDF 5
115
116 /*!
117 * Forward declarations
118 */
119
120 class WXDLLIMPEXP_ADV wxRichTextCtrl;
121 class WXDLLIMPEXP_ADV wxRichTextObject;
122 class WXDLLIMPEXP_ADV wxRichTextCacheObject;
123 class WXDLLIMPEXP_ADV wxRichTextObjectList;
124 class WXDLLIMPEXP_ADV wxRichTextLine;
125 class WXDLLIMPEXP_ADV wxRichTextParagraph;
126 class WXDLLIMPEXP_ADV wxRichTextFragment;
127 class WXDLLIMPEXP_ADV wxRichTextFileHandler;
128 class WXDLLIMPEXP_ADV wxRichTextStyleSheet;
129 class WXDLLIMPEXP_ADV wxTextAttrEx;
130
131 /*!
132 * Flags determining the available space, passed to Layout
133 */
134
135 #define wxRICHTEXT_FIXED_WIDTH 0x01
136 #define wxRICHTEXT_FIXED_HEIGHT 0x02
137 #define wxRICHTEXT_VARIABLE_WIDTH 0x04
138 #define wxRICHTEXT_VARIABLE_HEIGHT 0x08
139
140 // Only lay out the part of the buffer that lies within
141 // the rect passed to Layout.
142 #define wxRICHTEXT_LAYOUT_SPECIFIED_RECT 0x10
143
144 /*!
145 * Flags returned from hit-testing
146 */
147
148 // The point was not on this object
149 #define wxRICHTEXT_HITTEST_NONE 0x01
150 // The point was before the position returned from HitTest
151 #define wxRICHTEXT_HITTEST_BEFORE 0x02
152 // The point was after the position returned from HitTest
153 #define wxRICHTEXT_HITTEST_AFTER 0x04
154 // The point was on the position returned from HitTest
155 #define wxRICHTEXT_HITTEST_ON 0x08
156
157 /*!
158 * Flags for GetRangeSize
159 */
160
161 #define wxRICHTEXT_FORMATTED 0x01
162 #define wxRICHTEXT_UNFORMATTED 0x02
163
164 /*!
165 * Extra formatting flags not in wxTextAttr
166 */
167
168 #define wxTEXT_ATTR_PARA_SPACING_AFTER 0x00000800
169 #define wxTEXT_ATTR_PARA_SPACING_BEFORE 0x00001000
170 #define wxTEXT_ATTR_LINE_SPACING 0x00002000
171 #define wxTEXT_ATTR_CHARACTER_STYLE_NAME 0x00004000
172 #define wxTEXT_ATTR_PARAGRAPH_STYLE_NAME 0x00008000
173 #define wxTEXT_ATTR_BULLET_STYLE 0x00010000
174 #define wxTEXT_ATTR_BULLET_NUMBER 0x00020000
175 #define wxTEXT_ATTR_BULLET_SYMBOL 0x00040000
176
177 /*!
178 * Styles for wxTextAttrEx::SetBulletStyle
179 */
180
181 #define wxTEXT_ATTR_BULLET_STYLE_NONE 0x0000
182 #define wxTEXT_ATTR_BULLET_STYLE_ARABIC 0x0001
183 #define wxTEXT_ATTR_BULLET_STYLE_LETTERS_UPPER 0x0002
184 #define wxTEXT_ATTR_BULLET_STYLE_LETTERS_LOWER 0x0004
185 #define wxTEXT_ATTR_BULLET_STYLE_ROMAN_UPPER 0x0008
186 #define wxTEXT_ATTR_BULLET_STYLE_ROMAN_LOWER 0x0010
187 #define wxTEXT_ATTR_BULLET_STYLE_SYMBOL 0x0020
188 #define wxTEXT_ATTR_BULLET_STYLE_BITMAP 0x0040
189 #define wxTEXT_ATTR_BULLET_STYLE_PARENTHESES 0x0080
190 #define wxTEXT_ATTR_BULLET_STYLE_PERIOD 0x0100
191
192 /*!
193 * Line spacing values
194 */
195
196 #define wxTEXT_ATTR_LINE_SPACING_NORMAL 10
197 #define wxTEXT_ATTR_LINE_SPACING_HALF 15
198 #define wxTEXT_ATTR_LINE_SPACING_TWICE 20
199
200 /*!
201 * wxRichTextRange class declaration
202 * This stores beginning and end positions for a range of data.
203 */
204
205 class WXDLLIMPEXP_ADV wxRichTextRange
206 {
207 public:
208 // Constructors
209
210 wxRichTextRange() { m_start = 0; m_end = 0; }
211 wxRichTextRange(long start, long end) { m_start = start; m_end = end; }
212 wxRichTextRange(const wxRichTextRange& range) { m_start = range.m_start; m_end = range.m_end; }
213 ~wxRichTextRange() {}
214
215 void operator =(const wxRichTextRange& range) { m_start = range.m_start; m_end = range.m_end; }
216 bool operator ==(const wxRichTextRange& range) const { return (m_start == range.m_start && m_end == range.m_end); }
217 wxRichTextRange operator -(const wxRichTextRange& range) const { return wxRichTextRange(m_start - range.m_start, m_end - range.m_end); }
218 wxRichTextRange operator +(const wxRichTextRange& range) const { return wxRichTextRange(m_start + range.m_start, m_end + range.m_end); }
219
220 void SetRange(long start, long end) { m_start = start; m_end = end; }
221
222 void SetStart(long start) { m_start = start; }
223 long GetStart() const { return m_start; }
224
225 void SetEnd(long end) { m_end = end; }
226 long GetEnd() const { return m_end; }
227
228 /// Returns true if this range is completely outside 'range'
229 bool IsOutside(const wxRichTextRange& range) const { return range.m_start > m_end || range.m_end < m_start; }
230
231 /// Returns true if this range is completely within 'range'
232 bool IsWithin(const wxRichTextRange& range) const { return m_start >= range.m_start && m_end <= range.m_end; }
233
234 /// Returns true if the given position is within this range. Allow
235 /// for the possibility of an empty range - assume the position
236 /// is within this empty range. NO, I think we should not match with an empty range.
237 // bool Contains(long pos) const { return pos >= m_start && (pos <= m_end || GetLength() == 0); }
238 bool Contains(long pos) const { return pos >= m_start && pos <= m_end ; }
239
240 /// Limit this range to be within 'range'
241 bool LimitTo(const wxRichTextRange& range) ;
242
243 /// Gets the length of the range
244 long GetLength() const { return m_end - m_start + 1; }
245
246 /// Swaps the start and end
247 void Swap() { long tmp = m_start; m_start = m_end; m_end = tmp; }
248
249 protected:
250 long m_start;
251 long m_end;
252 };
253
254 #define wxRICHTEXT_ALL wxRichTextRange(-2, -2)
255 #define wxRICHTEXT_NONE wxRichTextRange(-1, -1)
256
257 /*!
258 * wxTextAttrEx is an extended version of wxTextAttr with more paragraph attributes.
259 */
260
261 class WXDLLIMPEXP_ADV wxTextAttrEx: public wxTextAttr
262 {
263 public:
264 // ctors
265 wxTextAttrEx(const wxTextAttrEx& attr);
266 wxTextAttrEx() { Init(); }
267
268 // Initialise this object.
269 void Init();
270
271 // Assignment from a wxTextAttrEx object
272 void operator= (const wxTextAttrEx& attr);
273
274 // Assignment from a wxTextAttr object.
275 void operator= (const wxTextAttr& attr);
276
277 // setters
278 void SetCharacterStyleName(const wxString& name) { m_characterStyleName = name; }
279 void SetParagraphStyleName(const wxString& name) { m_paragraphStyleName = name; }
280 void SetParagraphSpacingAfter(int spacing) { m_paragraphSpacingAfter = spacing; }
281 void SetParagraphSpacingBefore(int spacing) { m_paragraphSpacingBefore = spacing; }
282 void SetLineSpacing(int spacing) { m_lineSpacing = spacing; }
283 void SetBulletStyle(int style) { m_bulletStyle = style; }
284 void SetBulletNumber(int n) { m_bulletNumber = n; }
285 void SetBulletSymbol(wxChar symbol) { m_bulletSymbol = symbol; }
286
287 const wxString& GetCharacterStyleName() const { return m_characterStyleName; }
288 const wxString& GetParagraphStyleName() const { return m_paragraphStyleName; }
289 int GetParagraphSpacingAfter() const { return m_paragraphSpacingAfter; }
290 int GetParagraphSpacingBefore() const { return m_paragraphSpacingBefore; }
291 int GetLineSpacing() const { return m_lineSpacing; }
292 int GetBulletStyle() const { return m_bulletStyle; }
293 int GetBulletNumber() const { return m_bulletNumber; }
294 wxChar GetBulletSymbol() const { return m_bulletSymbol; }
295
296 bool HasParagraphSpacingAfter() const { return HasFlag(wxTEXT_ATTR_PARA_SPACING_AFTER); }
297 bool HasParagraphSpacingBefore() const { return HasFlag(wxTEXT_ATTR_PARA_SPACING_BEFORE); }
298 bool HasLineSpacing() const { return HasFlag(wxTEXT_ATTR_LINE_SPACING); }
299 bool HasCharacterStyleName() const { return HasFlag(wxTEXT_ATTR_CHARACTER_STYLE_NAME); }
300 bool HasParagraphStyleName() const { return HasFlag(wxTEXT_ATTR_PARAGRAPH_STYLE_NAME); }
301 bool HasBulletStyle() const { return HasFlag(wxTEXT_ATTR_BULLET_STYLE); }
302 bool HasBulletNumber() const { return HasFlag(wxTEXT_ATTR_BULLET_NUMBER); }
303 bool HasBulletSymbol() const { return HasFlag(wxTEXT_ATTR_BULLET_SYMBOL); }
304
305 // Is this a character style?
306 bool IsCharacterStyle() const { return (0 != (GetFlags() & (wxTEXT_ATTR_FONT | wxTEXT_ATTR_BACKGROUND_COLOUR | wxTEXT_ATTR_TEXT_COLOUR))); }
307 bool IsParagraphStyle() const { return (0 != (GetFlags() & (wxTEXT_ATTR_ALIGNMENT|wxTEXT_ATTR_LEFT_INDENT|wxTEXT_ATTR_RIGHT_INDENT|wxTEXT_ATTR_TABS|
308 wxTEXT_ATTR_PARA_SPACING_BEFORE|wxTEXT_ATTR_PARA_SPACING_AFTER|wxTEXT_ATTR_LINE_SPACING|
309 wxTEXT_ATTR_BULLET_STYLE|wxTEXT_ATTR_BULLET_NUMBER))); }
310
311 // returns false if we have any attributes set, true otherwise
312 bool IsDefault() const
313 {
314 return !HasTextColour() && !HasBackgroundColour() && !HasFont() && !HasAlignment() &&
315 !HasTabs() && !HasLeftIndent() && !HasRightIndent() &&
316 !HasParagraphSpacingAfter() && !HasParagraphSpacingBefore() && !HasLineSpacing() &&
317 !HasCharacterStyleName() && !HasParagraphStyleName() && !HasBulletNumber() && !HasBulletStyle() && !HasBulletSymbol();
318 }
319 private:
320 // Paragraph styles
321 int m_paragraphSpacingAfter;
322 int m_paragraphSpacingBefore;
323 int m_lineSpacing;
324 int m_bulletStyle;
325 int m_bulletNumber;
326 wxChar m_bulletSymbol;
327
328 // Character style
329 wxString m_characterStyleName;
330
331 // Paragraph style
332 wxString m_paragraphStyleName;
333 };
334
335 /*!
336 * wxRichTextAttr stores attributes without a wxFont object, so is a much more
337 * efficient way to query styles.
338 */
339
340 class WXDLLIMPEXP_ADV wxRichTextAttr
341 {
342 public:
343 // ctors
344 wxRichTextAttr(const wxTextAttrEx& attr);
345 wxRichTextAttr() { Init(); }
346 wxRichTextAttr(const wxColour& colText,
347 const wxColour& colBack = wxNullColour,
348 wxTextAttrAlignment alignment = wxTEXT_ALIGNMENT_DEFAULT);
349
350 // Initialise this object.
351 void Init();
352
353 // Assignment from a wxRichTextAttr object.
354 void operator= (const wxRichTextAttr& attr);
355
356 // Assignment from a wxTextAttrEx object.
357 void operator= (const wxTextAttrEx& attr);
358
359 // Making a wxTextAttrEx object.
360 operator wxTextAttrEx () const ;
361
362 // Copy to a wxTextAttr
363 void CopyTo(wxTextAttrEx& attr) const;
364
365 // Create font from font attributes.
366 wxFont CreateFont() const;
367
368 // Get attributes from font.
369 bool GetFontAttributes(const wxFont& font);
370
371 // setters
372 void SetTextColour(const wxColour& colText) { m_colText = colText; m_flags |= wxTEXT_ATTR_TEXT_COLOUR; }
373 void SetBackgroundColour(const wxColour& colBack) { m_colBack = colBack; m_flags |= wxTEXT_ATTR_BACKGROUND_COLOUR; }
374 void SetAlignment(wxTextAttrAlignment alignment) { m_textAlignment = alignment; m_flags |= wxTEXT_ATTR_ALIGNMENT; }
375 void SetTabs(const wxArrayInt& tabs) { m_tabs = tabs; m_flags |= wxTEXT_ATTR_TABS; }
376 void SetLeftIndent(int indent, int subIndent = 0) { m_leftIndent = indent; m_leftSubIndent = subIndent; m_flags |= wxTEXT_ATTR_LEFT_INDENT; }
377 void SetRightIndent(int indent) { m_rightIndent = indent; m_flags |= wxTEXT_ATTR_RIGHT_INDENT; }
378
379 void SetFontSize(int pointSize) { m_fontSize = pointSize; m_flags |= wxTEXT_ATTR_FONT_SIZE; }
380 void SetFontStyle(int fontStyle) { m_fontStyle = fontStyle; m_flags |= wxTEXT_ATTR_FONT_ITALIC; }
381 void SetFontWeight(int fontWeight) { m_fontWeight = fontWeight; m_flags |= wxTEXT_ATTR_FONT_WEIGHT; }
382 void SetFontFaceName(const wxString& faceName) { m_fontFaceName = faceName; m_flags |= wxTEXT_ATTR_FONT_FACE; }
383 void SetFontUnderlined(bool underlined) { m_fontUnderlined = underlined; m_flags |= wxTEXT_ATTR_FONT_UNDERLINE; }
384
385 void SetFlags(long flags) { m_flags = flags; }
386
387 void SetCharacterStyleName(const wxString& name) { m_characterStyleName = name; }
388 void SetParagraphStyleName(const wxString& name) { m_paragraphStyleName = name; }
389 void SetParagraphSpacingAfter(int spacing) { m_paragraphSpacingAfter = spacing; }
390 void SetParagraphSpacingBefore(int spacing) { m_paragraphSpacingBefore = spacing; }
391 void SetLineSpacing(int spacing) { m_lineSpacing = spacing; }
392 void SetBulletStyle(int style) { m_bulletStyle = style; }
393 void SetBulletNumber(int n) { m_bulletNumber = n; }
394 void SetBulletSymbol(wxChar symbol) { m_bulletSymbol = symbol; }
395
396 const wxColour& GetTextColour() const { return m_colText; }
397 const wxColour& GetBackgroundColour() const { return m_colBack; }
398 wxTextAttrAlignment GetAlignment() const { return m_textAlignment; }
399 const wxArrayInt& GetTabs() const { return m_tabs; }
400 long GetLeftIndent() const { return m_leftIndent; }
401 long GetLeftSubIndent() const { return m_leftSubIndent; }
402 long GetRightIndent() const { return m_rightIndent; }
403 long GetFlags() const { return m_flags; }
404
405 int GetFontSize() const { return m_fontSize; }
406 int GetFontStyle() const { return m_fontStyle; }
407 int GetFontWeight() const { return m_fontWeight; }
408 bool GetFontUnderlined() const { return m_fontUnderlined; }
409 const wxString& GetFontFaceName() const { return m_fontFaceName; }
410
411 const wxString& GetCharacterStyleName() const { return m_characterStyleName; }
412 const wxString& GetParagraphStyleName() const { return m_paragraphStyleName; }
413 int GetParagraphSpacingAfter() const { return m_paragraphSpacingAfter; }
414 int GetParagraphSpacingBefore() const { return m_paragraphSpacingBefore; }
415 int GetLineSpacing() const { return m_lineSpacing; }
416 int GetBulletStyle() const { return m_bulletStyle; }
417 int GetBulletNumber() const { return m_bulletNumber; }
418 wxChar GetBulletSymbol() const { return m_bulletSymbol; }
419
420 // accessors
421 bool HasTextColour() const { return m_colText.Ok() && HasFlag(wxTEXT_ATTR_TEXT_COLOUR) ; }
422 bool HasBackgroundColour() const { return m_colBack.Ok() && HasFlag(wxTEXT_ATTR_BACKGROUND_COLOUR) ; }
423 bool HasAlignment() const { return (m_textAlignment != wxTEXT_ALIGNMENT_DEFAULT) || ((m_flags & wxTEXT_ATTR_ALIGNMENT) != 0) ; }
424 bool HasTabs() const { return (m_flags & wxTEXT_ATTR_TABS) != 0 ; }
425 bool HasLeftIndent() const { return (m_flags & wxTEXT_ATTR_LEFT_INDENT) != 0 ; }
426 bool HasRightIndent() const { return (m_flags & wxTEXT_ATTR_RIGHT_INDENT) != 0 ; }
427 bool HasWeight() const { return (m_flags & wxTEXT_ATTR_FONT_WEIGHT) != 0; }
428 bool HasSize() const { return (m_flags & wxTEXT_ATTR_FONT_SIZE) != 0; }
429 bool HasItalic() const { return (m_flags & wxTEXT_ATTR_FONT_ITALIC) != 0; }
430 bool HasUnderlined() const { return (m_flags & wxTEXT_ATTR_FONT_UNDERLINE) != 0; }
431 bool HasFaceName() const { return (m_flags & wxTEXT_ATTR_FONT_FACE) != 0; }
432 bool HasFont() const { return (m_flags & (wxTEXT_ATTR_FONT)) != 0; }
433
434 bool HasParagraphSpacingAfter() const { return (m_flags & wxTEXT_ATTR_PARA_SPACING_AFTER) != 0; }
435 bool HasParagraphSpacingBefore() const { return (m_flags & wxTEXT_ATTR_PARA_SPACING_BEFORE) != 0; }
436 bool HasLineSpacing() const { return (m_flags & wxTEXT_ATTR_LINE_SPACING) != 0; }
437 bool HasCharacterStyleName() const { return (m_flags & wxTEXT_ATTR_CHARACTER_STYLE_NAME) != 0; }
438 bool HasParagraphStyleName() const { return (m_flags & wxTEXT_ATTR_PARAGRAPH_STYLE_NAME) != 0; }
439 bool HasBulletStyle() const { return (m_flags & wxTEXT_ATTR_BULLET_STYLE) != 0; }
440 bool HasBulletNumber() const { return (m_flags & wxTEXT_ATTR_BULLET_NUMBER) != 0; }
441 bool HasBulletSymbol() const { return (m_flags & wxTEXT_ATTR_BULLET_SYMBOL) != 0; }
442
443 bool HasFlag(long flag) const { return (m_flags & flag) != 0; }
444
445 // Is this a character style?
446 bool IsCharacterStyle() const { return (0 != (GetFlags() & (wxTEXT_ATTR_FONT | wxTEXT_ATTR_BACKGROUND_COLOUR | wxTEXT_ATTR_TEXT_COLOUR))); }
447 bool IsParagraphStyle() const { return (0 != (GetFlags() & (wxTEXT_ATTR_ALIGNMENT|wxTEXT_ATTR_LEFT_INDENT|wxTEXT_ATTR_RIGHT_INDENT|wxTEXT_ATTR_TABS|
448 wxTEXT_ATTR_PARA_SPACING_BEFORE|wxTEXT_ATTR_PARA_SPACING_AFTER|wxTEXT_ATTR_LINE_SPACING|
449 wxTEXT_ATTR_BULLET_STYLE|wxTEXT_ATTR_BULLET_NUMBER))); }
450
451 // returns false if we have any attributes set, true otherwise
452 bool IsDefault() const
453 {
454 return !HasTextColour() && !HasBackgroundColour() && !HasFont() && !HasAlignment() &&
455 !HasTabs() && !HasLeftIndent() && !HasRightIndent() &&
456 !HasParagraphSpacingAfter() && !HasParagraphSpacingBefore() && !HasLineSpacing() &&
457 !HasCharacterStyleName() && !HasParagraphStyleName() && !HasBulletNumber() && !HasBulletStyle() && !HasBulletSymbol();
458 }
459
460 private:
461 long m_flags;
462
463 // Paragraph styles
464 wxArrayInt m_tabs; // array of int: tab stops in 1/10 mm
465 int m_leftIndent; // left indent in 1/10 mm
466 int m_leftSubIndent; // left indent for all but the first
467 // line in a paragraph relative to the
468 // first line, in 1/10 mm
469 int m_rightIndent; // right indent in 1/10 mm
470 wxTextAttrAlignment m_textAlignment;
471
472 int m_paragraphSpacingAfter;
473 int m_paragraphSpacingBefore;
474 int m_lineSpacing;
475 int m_bulletStyle;
476 int m_bulletNumber;
477 wxChar m_bulletSymbol;
478
479 // Character styles
480 wxColour m_colText,
481 m_colBack;
482 int m_fontSize;
483 int m_fontStyle;
484 int m_fontWeight;
485 bool m_fontUnderlined;
486 wxString m_fontFaceName;
487
488 // Character style
489 wxString m_characterStyleName;
490
491 // Paragraph style
492 wxString m_paragraphStyleName;
493 };
494
495 #define wxTEXT_ATTR_CHARACTER (wxTEXT_ATTR_FONT | wxTEXT_ATTR_BACKGROUND_COLOUR | wxTEXT_ATTR_TEXT_COLOUR)
496
497 #define wxTEXT_ATTR_PARAGRAPH (wxTEXT_ATTR_ALIGNMENT|wxTEXT_ATTR_LEFT_INDENT|wxTEXT_ATTR_RIGHT_INDENT|wxTEXT_ATTR_TABS|\
498 wxTEXT_ATTR_PARA_SPACING_BEFORE|wxTEXT_ATTR_PARA_SPACING_AFTER|wxTEXT_ATTR_LINE_SPACING|\
499 wxTEXT_ATTR_BULLET_STYLE|wxTEXT_ATTR_BULLET_NUMBER|wxTEXT_ATTR_BULLET_SYMBOL)
500
501 #define wxTEXT_ATTR_ALL (wxTEXT_ATTR_CHARACTER|wxTEXT_ATTR_PARAGRAPH)
502
503 /*!
504 * wxRichTextObject class declaration
505 * This is the base for drawable objects.
506 */
507
508 class WXDLLIMPEXP_ADV wxRichTextObject: public wxObject
509 {
510 DECLARE_CLASS(wxRichTextObject)
511 public:
512 // Constructors
513
514 wxRichTextObject(wxRichTextObject* parent = NULL);
515 ~wxRichTextObject();
516
517 // Overrideables
518
519 /// Draw the item, within the given range. Some objects may ignore the range (for
520 /// example paragraphs) while others must obey it (lines, to implement wrapping)
521 virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style) = 0;
522
523 /// Lay the item out at the specified position with the given size constraint.
524 /// Layout must set the cached size.
525 virtual bool Layout(wxDC& dc, const wxRect& rect, int style) = 0;
526
527 /// Hit-testing: returns a flag indicating hit test details, plus
528 /// information about position
529 virtual int HitTest(wxDC& WXUNUSED(dc), const wxPoint& WXUNUSED(pt), long& WXUNUSED(textPosition)) { return false; }
530
531 /// Finds the absolute position and row height for the given character position
532 virtual bool FindPosition(wxDC& WXUNUSED(dc), long WXUNUSED(index), wxPoint& WXUNUSED(pt), int* WXUNUSED(height), bool WXUNUSED(forceLineStart)) { return false; }
533
534 /// Get the best size, i.e. the ideal starting size for this object irrespective
535 /// of available space. For a short text string, it will be the size that exactly encloses
536 /// the text. For a longer string, it might use the parent width for example.
537 virtual wxSize GetBestSize() const { return m_size; }
538
539 /// Get the object size for the given range. Returns false if the range
540 /// is invalid for this object.
541 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags) const = 0;
542
543 /// Do a split, returning an object containing the second part, and setting
544 /// the first part in 'this'.
545 virtual wxRichTextObject* DoSplit(long WXUNUSED(pos)) { return NULL; }
546
547 /// Calculate range. By default, guess that the object is 1 unit long.
548 virtual void CalculateRange(long start, long& end) { end = start ; m_range.SetRange(start, end); }
549
550 /// Delete range
551 virtual bool DeleteRange(const wxRichTextRange& WXUNUSED(range)) { return false; }
552
553 /// Returns true if the object is empty
554 virtual bool IsEmpty() const { return false; }
555
556 /// Get any text in this object for the given range
557 virtual wxString GetTextForRange(const wxRichTextRange& WXUNUSED(range)) const { return wxEmptyString; }
558
559 /// Returns true if this object can merge itself with the given one.
560 virtual bool CanMerge(wxRichTextObject* WXUNUSED(object)) const { return false; }
561
562 /// Returns true if this object merged itself with the given one.
563 /// The calling code will then delete the given object.
564 virtual bool Merge(wxRichTextObject* WXUNUSED(object)) { return false; }
565
566 /// Dump to output stream for debugging
567 virtual void Dump(wxTextOutputStream& stream);
568
569 // Accessors
570
571 /// Get/set the cached object size as calculated by Layout.
572 virtual wxSize GetCachedSize() const { return m_size; }
573 virtual void SetCachedSize(const wxSize& sz) { m_size = sz; }
574
575 /// Get/set the object position
576 virtual wxPoint GetPosition() const { return m_pos; }
577 virtual void SetPosition(const wxPoint& pos) { m_pos = pos; }
578
579 /// Get the rectangle enclosing the object
580 virtual wxRect GetRect() const { return wxRect(GetPosition(), GetCachedSize()); }
581
582 /// Set the range
583 void SetRange(const wxRichTextRange& range) { m_range = range; }
584
585 /// Get the range
586 const wxRichTextRange& GetRange() const { return m_range; }
587 wxRichTextRange& GetRange() { return m_range; }
588
589 /// Get/set dirty flag (whether the object needs Layout to be called)
590 virtual bool GetDirty() const { return m_dirty; }
591 virtual void SetDirty(bool dirty) { m_dirty = dirty; }
592
593 /// Is this composite?
594 virtual bool IsComposite() const { return false; }
595
596 /// Get/set the parent.
597 virtual wxRichTextObject* GetParent() const { return m_parent; }
598 virtual void SetParent(wxRichTextObject* parent) { m_parent = parent; }
599
600 /// Set the margin around the object
601 virtual void SetMargins(int margin);
602 virtual void SetMargins(int leftMargin, int rightMargin, int topMargin, int bottomMargin);
603 virtual int GetLeftMargin() const { return m_leftMargin; }
604 virtual int GetRightMargin() const { return m_rightMargin; }
605 virtual int GetTopMargin() const { return m_topMargin; }
606 virtual int GetBottomMargin() const { return m_bottomMargin; }
607
608 /// Set attributes object
609 void SetAttributes(const wxTextAttrEx& attr) { m_attributes = attr; }
610 const wxTextAttrEx& GetAttributes() const { return m_attributes; }
611 wxTextAttrEx& GetAttributes() { return m_attributes; }
612
613 /// Set/get stored descent
614 void SetDescent(int descent) { m_descent = descent; }
615 int GetDescent() const { return m_descent; }
616
617 // Operations
618
619 /// Clone the object
620 virtual wxRichTextObject* Clone() const { return NULL; }
621
622 /// Copy
623 void Copy(const wxRichTextObject& obj);
624
625 /// Reference-counting allows us to use the same object in multiple
626 /// lists (not yet used)
627 void Reference() { m_refCount ++; }
628 void Dereference();
629
630 /// Convert units in tends of a millimetre to device units
631 int ConvertTenthsMMToPixels(wxDC& dc, int units);
632
633 protected:
634 wxSize m_size;
635 wxPoint m_pos;
636 int m_descent; // Descent for this object (if any)
637 bool m_dirty;
638 int m_refCount;
639 wxRichTextObject* m_parent;
640
641 /// The range of this object (start position to end position)
642 wxRichTextRange m_range;
643
644 /// Margins
645 int m_leftMargin;
646 int m_rightMargin;
647 int m_topMargin;
648 int m_bottomMargin;
649
650 /// Attributes
651 wxTextAttrEx m_attributes;
652 };
653
654 WX_DECLARE_LIST_WITH_DECL( wxRichTextObject, wxRichTextObjectList, class WXDLLIMPEXP_ADV );
655
656 /*!
657 * wxRichTextCompositeObject class declaration
658 * Objects of this class can contain other objects.
659 */
660
661 class WXDLLIMPEXP_ADV wxRichTextCompositeObject: public wxRichTextObject
662 {
663 DECLARE_CLASS(wxRichTextCompositeObject)
664 public:
665 // Constructors
666
667 wxRichTextCompositeObject(wxRichTextObject* parent = NULL);
668 ~wxRichTextCompositeObject();
669
670 // Overrideables
671
672 /// Hit-testing: returns a flag indicating hit test details, plus
673 /// information about position
674 virtual int HitTest(wxDC& dc, const wxPoint& pt, long& textPosition);
675
676 /// Finds the absolute position and row height for the given character position
677 virtual bool FindPosition(wxDC& dc, long index, wxPoint& pt, int* height, bool forceLineStart);
678
679 /// Calculate range
680 virtual void CalculateRange(long start, long& end);
681
682 /// Delete range
683 virtual bool DeleteRange(const wxRichTextRange& range);
684
685 /// Get any text in this object for the given range
686 virtual wxString GetTextForRange(const wxRichTextRange& range) const;
687
688 /// Dump to output stream for debugging
689 virtual void Dump(wxTextOutputStream& stream);
690
691 // Accessors
692
693 /// Get the children
694 wxRichTextObjectList& GetChildren() { return m_children; }
695 const wxRichTextObjectList& GetChildren() const { return m_children; }
696
697 /// Get the child count
698 size_t GetChildCount() const ;
699
700 /// Get the nth child
701 wxRichTextObject* GetChild(size_t n) const ;
702
703 /// Get/set dirty flag
704 virtual bool GetDirty() const { return m_dirty; }
705 virtual void SetDirty(bool dirty) { m_dirty = dirty; }
706
707 /// Is this composite?
708 virtual bool IsComposite() const { return true; }
709
710 /// Returns true if the buffer is empty
711 virtual bool IsEmpty() const { return GetChildCount() == 0; }
712
713 // Operations
714
715 /// Copy
716 void Copy(const wxRichTextCompositeObject& obj);
717
718 /// Append a child, returning the position
719 size_t AppendChild(wxRichTextObject* child) ;
720
721 /// Insert the child in front of the given object, or at the beginning
722 bool InsertChild(wxRichTextObject* child, wxRichTextObject* inFrontOf) ;
723
724 /// Delete the child
725 bool RemoveChild(wxRichTextObject* child, bool deleteChild = false) ;
726
727 /// Delete all children
728 bool DeleteChildren() ;
729
730 /// Recursively merge all pieces that can be merged.
731 bool Defragment();
732
733 protected:
734 wxRichTextObjectList m_children;
735 };
736
737 /*!
738 * wxRichTextBox class declaration
739 * This defines a 2D space to lay out objects
740 */
741
742 class WXDLLIMPEXP_ADV wxRichTextBox: public wxRichTextCompositeObject
743 {
744 DECLARE_DYNAMIC_CLASS(wxRichTextBox)
745 public:
746 // Constructors
747
748 wxRichTextBox(wxRichTextObject* parent = NULL);
749 wxRichTextBox(const wxRichTextBox& obj): wxRichTextCompositeObject() { Copy(obj); }
750
751 // Overrideables
752
753 /// Draw the item
754 virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style);
755
756 /// Lay the item out
757 virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
758
759 /// Get/set the object size for the given range. Returns false if the range
760 /// is invalid for this object.
761 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags) const;
762
763 // Accessors
764
765 // Operations
766
767 /// Clone
768 virtual wxRichTextObject* Clone() const { return new wxRichTextBox(*this); }
769
770 /// Copy
771 void Copy(const wxRichTextBox& obj);
772
773 protected:
774 };
775
776 /*!
777 * wxRichTextParagraphBox class declaration
778 * This box knows how to lay out paragraphs.
779 */
780
781 class WXDLLIMPEXP_ADV wxRichTextParagraphLayoutBox: public wxRichTextBox
782 {
783 DECLARE_DYNAMIC_CLASS(wxRichTextParagraphLayoutBox)
784 public:
785 // Constructors
786
787 wxRichTextParagraphLayoutBox(wxRichTextObject* parent = NULL);
788 wxRichTextParagraphLayoutBox(const wxRichTextParagraphLayoutBox& obj):wxRichTextBox() { Init(); Copy(obj); }
789
790 // Overrideables
791
792 /// Draw the item
793 virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style);
794
795 /// Lay the item out
796 virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
797
798 /// Get/set the object size for the given range. Returns false if the range
799 /// is invalid for this object.
800 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags) const;
801
802 /// Delete range
803 virtual bool DeleteRange(const wxRichTextRange& range);
804
805 /// Get any text in this object for the given range
806 virtual wxString GetTextForRange(const wxRichTextRange& range) const;
807
808 // Accessors
809
810 /// Associate a control with the buffer, for operations that for example require refreshing the window.
811 void SetRichTextCtrl(wxRichTextCtrl* ctrl) { m_ctrl = ctrl; }
812
813 /// Get the associated control.
814 wxRichTextCtrl* GetRichTextCtrl() const { return m_ctrl; }
815
816 // Operations
817
818 /// Initialize the object.
819 void Init();
820
821 /// Clear all children
822 virtual void Clear();
823
824 /// Clear and initialize with one blank paragraph
825 virtual void Reset();
826
827 /// Convenience function to add a paragraph of text
828 virtual wxRichTextRange AddParagraph(const wxString& text);
829
830 /// Convenience function to add an image
831 virtual wxRichTextRange AddImage(const wxImage& image);
832
833 /// Adds multiple paragraphs, based on newlines.
834 virtual wxRichTextRange AddParagraphs(const wxString& text);
835
836 /// Get the line at the given position. If caretPosition is true, the position is
837 /// a caret position, which is normally a smaller number.
838 virtual wxRichTextLine* GetLineAtPosition(long pos, bool caretPosition = false) const;
839
840 /// Get the line at the given y pixel position, or the last line.
841 virtual wxRichTextLine* GetLineAtYPosition(int y) const;
842
843 /// Get the paragraph at the given character or caret position
844 virtual wxRichTextParagraph* GetParagraphAtPosition(long pos, bool caretPosition = false) const;
845
846 /// Get the line size at the given position
847 virtual wxSize GetLineSizeAtPosition(long pos, bool caretPosition = false) const;
848
849 /// Given a position, get the number of the visible line (potentially many to a paragraph),
850 /// starting from zero at the start of the buffer. We also have to pass a bool (startOfLine)
851 /// that indicates whether the caret is being shown at the end of the previous line or at the start
852 /// of the next, since the caret can be shown at 2 visible positions for the same underlying
853 /// position.
854 virtual long GetVisibleLineNumber(long pos, bool caretPosition = false, bool startOfLine = false) const;
855
856 /// Given a line number, get the corresponding wxRichTextLine object.
857 virtual wxRichTextLine* GetLineForVisibleLineNumber(long lineNumber) const;
858
859 /// Get the leaf object in a paragraph at this position.
860 /// Given a line number, get the corresponding wxRichTextLine object.
861 virtual wxRichTextObject* GetLeafObjectAtPosition(long position) const;
862
863 /// Get the paragraph by number
864 virtual wxRichTextParagraph* GetParagraphAtLine(long paragraphNumber) const;
865
866 /// Get the paragraph for a given line
867 virtual wxRichTextParagraph* GetParagraphForLine(wxRichTextLine* line) const;
868
869 /// Get the length of the paragraph
870 virtual int GetParagraphLength(long paragraphNumber) const;
871
872 /// Get the number of paragraphs
873 virtual int GetParagraphCount() const { return GetChildCount(); }
874
875 /// Get the number of visible lines
876 virtual int GetLineCount() const;
877
878 /// Get the text of the paragraph
879 virtual wxString GetParagraphText(long paragraphNumber) const;
880
881 /// Convert zero-based line column and paragraph number to a position.
882 virtual long XYToPosition(long x, long y) const;
883
884 /// Convert zero-based position to line column and paragraph number
885 virtual bool PositionToXY(long pos, long* x, long* y) const;
886
887 /// Set text attributes: character and/or paragraph styles.
888 virtual bool SetStyle(const wxRichTextRange& range, const wxRichTextAttr& style, bool withUndo = true);
889 virtual bool SetStyle(const wxRichTextRange& range, const wxTextAttrEx& style, bool withUndo = true);
890
891 /// Get the text attributes for this position.
892 virtual bool GetStyle(long position, wxTextAttrEx& style) const;
893 virtual bool GetStyle(long position, wxRichTextAttr& style) const;
894
895 /// Test if this whole range has character attributes of the specified kind. If any
896 /// of the attributes are different within the range, the test fails. You
897 /// can use this to implement, for example, bold button updating. style must have
898 /// flags indicating which attributes are of interest.
899 virtual bool HasCharacterAttributes(const wxRichTextRange& range, const wxTextAttrEx& style) const;
900 virtual bool HasCharacterAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const;
901
902 /// Test if this whole range has paragraph attributes of the specified kind. If any
903 /// of the attributes are different within the range, the test fails. You
904 /// can use this to implement, for example, centering button updating. style must have
905 /// flags indicating which attributes are of interest.
906 virtual bool HasParagraphAttributes(const wxRichTextRange& range, const wxTextAttrEx& style) const;
907 virtual bool HasParagraphAttributes(const wxRichTextRange& range, const wxRichTextAttr& style) const;
908
909 /// Clone
910 virtual wxRichTextObject* Clone() const { return new wxRichTextParagraphLayoutBox(*this); }
911
912 /// Insert fragment into this box at the given position. If partialParagraph is true,
913 /// it is assumed that the last (or only) paragraph is just a piece of data with no paragraph
914 /// marker.
915 virtual bool InsertFragment(long position, wxRichTextFragment& fragment);
916
917 /// Make a copy of the fragment corresponding to the given range, putting it in 'fragment'.
918 virtual bool CopyFragment(const wxRichTextRange& range, wxRichTextFragment& fragment);
919
920 /// Copy
921 void Copy(const wxRichTextParagraphLayoutBox& obj);
922
923 /// Calculate ranges
924 virtual void UpdateRanges() { long end; CalculateRange(0, end); }
925
926 /// Get all the text
927 virtual wxString GetText() const;
928
929 /// Set default style for new content. Setting it to a default attribute
930 /// makes new content take on the 'basic' style.
931 virtual bool SetDefaultStyle(const wxTextAttrEx& style);
932
933 /// Get default style
934 virtual const wxTextAttrEx& GetDefaultStyle() const { return m_defaultAttributes; }
935
936 /// Set basic (overall) style
937 virtual void SetBasicStyle(const wxTextAttrEx& style) { m_attributes = style; }
938 virtual void SetBasicStyle(const wxRichTextAttr& style) { style.CopyTo(m_attributes); }
939
940 /// Get basic (overall) style
941 virtual const wxTextAttrEx& GetBasicStyle() const { return m_attributes; }
942
943 /// Invalidate the buffer. With no argument, invalidates whole buffer.
944 void Invalidate(const wxRichTextRange& invalidRange = wxRICHTEXT_ALL);
945
946 /// Get invalid range, rounding to entire paragraphs if argument is true.
947 wxRichTextRange GetInvalidRange(bool wholeParagraphs = false) const;
948
949 protected:
950 wxRichTextCtrl* m_ctrl;
951 wxTextAttrEx m_defaultAttributes;
952
953 /// The invalidated range that will need full layout
954 wxRichTextRange m_invalidRange;
955 };
956
957 /*!
958 * wxRichTextFragment class declaration
959 * This is a lind of paragraph layout box used for storing
960 * paragraphs for Undo/Redo, for example.
961 */
962
963 class WXDLLIMPEXP_ADV wxRichTextFragment: public wxRichTextParagraphLayoutBox
964 {
965 DECLARE_DYNAMIC_CLASS(wxRichTextFragment)
966 public:
967 // Constructors
968
969 wxRichTextFragment() { Init(); }
970 wxRichTextFragment(const wxRichTextFragment& obj):wxRichTextParagraphLayoutBox() { Init(); Copy(obj); }
971
972 // Accessors
973
974 /// Get/set whether the last paragraph is partial or complete
975 void SetPartialParagraph(bool partialPara) { m_partialParagraph = partialPara; }
976 bool GetPartialParagraph() const { return m_partialParagraph; }
977
978 // Overrideables
979
980 // Operations
981
982 /// Initialise
983 void Init();
984
985 /// Copy
986 void Copy(const wxRichTextFragment& obj);
987
988 /// Clone
989 virtual wxRichTextObject* Clone() const { return new wxRichTextFragment(*this); }
990
991 protected:
992
993 // Is the last paragraph partial or complete?
994 bool m_partialParagraph;
995 };
996
997 /*!
998 * wxRichTextLine class declaration
999 * This object represents a line in a paragraph, and stores
1000 * offsets from the start of the paragraph representing the
1001 * start and end positions of the line.
1002 */
1003
1004 class WXDLLIMPEXP_ADV wxRichTextLine
1005 {
1006 public:
1007 // Constructors
1008
1009 wxRichTextLine(wxRichTextParagraph* parent);
1010 wxRichTextLine(const wxRichTextLine& obj) { Init( NULL); Copy(obj); }
1011 virtual ~wxRichTextLine() {}
1012
1013 // Overrideables
1014
1015 // Accessors
1016
1017 /// Set the range
1018 void SetRange(const wxRichTextRange& range) { m_range = range; }
1019 void SetRange(long from, long to) { m_range = wxRichTextRange(from, to); }
1020
1021 /// Get the parent paragraph
1022 wxRichTextParagraph* GetParent() { return m_parent; }
1023
1024 /// Get the range
1025 const wxRichTextRange& GetRange() const { return m_range; }
1026 wxRichTextRange& GetRange() { return m_range; }
1027
1028 /// Get the absolute range
1029 wxRichTextRange GetAbsoluteRange() const;
1030
1031 /// Get/set the line size as calculated by Layout.
1032 virtual wxSize GetSize() const { return m_size; }
1033 virtual void SetSize(const wxSize& sz) { m_size = sz; }
1034
1035 /// Get/set the object position relative to the parent
1036 virtual wxPoint GetPosition() const { return m_pos; }
1037 virtual void SetPosition(const wxPoint& pos) { m_pos = pos; }
1038
1039 /// Get the absolute object position
1040 virtual wxPoint GetAbsolutePosition() const;
1041
1042 /// Get the rectangle enclosing the line
1043 virtual wxRect GetRect() const { return wxRect(GetAbsolutePosition(), GetSize()); }
1044
1045 /// Set/get stored descent
1046 void SetDescent(int descent) { m_descent = descent; }
1047 int GetDescent() const { return m_descent; }
1048
1049 // Operations
1050
1051 /// Initialisation
1052 void Init(wxRichTextParagraph* parent);
1053
1054 /// Copy
1055 void Copy(const wxRichTextLine& obj);
1056
1057 /// Clone
1058 virtual wxRichTextLine* Clone() const { return new wxRichTextLine(*this); }
1059
1060 protected:
1061
1062 /// The range of the line (start position to end position)
1063 /// This is relative to the parent paragraph.
1064 wxRichTextRange m_range;
1065
1066 /// Size and position measured relative to top of paragraph
1067 wxPoint m_pos;
1068 wxSize m_size;
1069
1070 /// Maximum descent for this line (location of text baseline)
1071 int m_descent;
1072
1073 // The parent object
1074 wxRichTextParagraph* m_parent;
1075 };
1076
1077 WX_DECLARE_LIST_WITH_DECL( wxRichTextLine, wxRichTextLineList , class WXDLLIMPEXP_ADV );
1078
1079 /*!
1080 * wxRichTextParagraph class declaration
1081 * This object represents a single paragraph (or in a straight text editor, a line).
1082 */
1083
1084 class WXDLLIMPEXP_ADV wxRichTextParagraph: public wxRichTextBox
1085 {
1086 DECLARE_DYNAMIC_CLASS(wxRichTextParagraph)
1087 public:
1088 // Constructors
1089
1090 wxRichTextParagraph(wxRichTextObject* parent = NULL, wxTextAttrEx* style = NULL);
1091 wxRichTextParagraph(const wxString& text, wxRichTextObject* parent = NULL, wxTextAttrEx* style = NULL);
1092 ~wxRichTextParagraph();
1093 wxRichTextParagraph(const wxRichTextParagraph& obj):wxRichTextBox() { Copy(obj); }
1094
1095 // Overrideables
1096
1097 /// Draw the item
1098 virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style);
1099
1100 /// Lay the item out
1101 virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
1102
1103 /// Get/set the object size for the given range. Returns false if the range
1104 /// is invalid for this object.
1105 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags) const;
1106
1107 /// Finds the absolute position and row height for the given character position
1108 virtual bool FindPosition(wxDC& dc, long index, wxPoint& pt, int* height, bool forceLineStart);
1109
1110 /// Hit-testing: returns a flag indicating hit test details, plus
1111 /// information about position
1112 virtual int HitTest(wxDC& dc, const wxPoint& pt, long& textPosition);
1113
1114 /// Calculate range
1115 virtual void CalculateRange(long start, long& end);
1116
1117 // Accessors
1118
1119 /// Get the cached lines
1120 wxRichTextLineList& GetLines() { return m_cachedLines; }
1121
1122 // Operations
1123
1124 /// Copy
1125 void Copy(const wxRichTextParagraph& obj);
1126
1127 /// Clone
1128 virtual wxRichTextObject* Clone() const { return new wxRichTextParagraph(*this); }
1129
1130 /// Clear the cached lines
1131 void ClearLines();
1132
1133 // Implementation
1134
1135 /// Apply paragraph styles such as centering to the wrapped lines
1136 virtual void ApplyParagraphStyle(const wxRect& rect);
1137
1138 /// Insert text at the given position
1139 virtual bool InsertText(long pos, const wxString& text);
1140
1141 /// Split an object at this position if necessary, and return
1142 /// the previous object, or NULL if inserting at beginning.
1143 virtual wxRichTextObject* SplitAt(long pos, wxRichTextObject** previousObject = NULL);
1144
1145 /// Move content to a list from this point
1146 virtual void MoveToList(wxRichTextObject* obj, wxList& list);
1147
1148 /// Add content back from list
1149 virtual void MoveFromList(wxList& list);
1150
1151 /// Get the plain text searching from the start or end of the range.
1152 /// The resulting string may be shorter than the range given.
1153 bool GetContiguousPlainText(wxString& text, const wxRichTextRange& range, bool fromStart = true);
1154
1155 /// Find a suitable wrap position. wrapPosition is the last position in the line to the left
1156 /// of the split.
1157 bool FindWrapPosition(const wxRichTextRange& range, wxDC& dc, int availableSpace, long& wrapPosition);
1158
1159 /// Find the object at the given position
1160 wxRichTextObject* FindObjectAtPosition(long position);
1161
1162 /// Get the bullet text for this paragraph.
1163 wxString GetBulletText();
1164
1165 /// Allocate or reuse a line object
1166 wxRichTextLine* AllocateLine(int pos);
1167
1168 /// Clear remaining unused line objects, if any
1169 bool ClearUnusedLines(int lineCount);
1170
1171 protected:
1172 /// The lines that make up the wrapped paragraph
1173 wxRichTextLineList m_cachedLines;
1174 };
1175
1176 /*!
1177 * wxRichTextPlainText class declaration
1178 * This object represents a single piece of text.
1179 */
1180
1181 class WXDLLIMPEXP_ADV wxRichTextPlainText: public wxRichTextObject
1182 {
1183 DECLARE_DYNAMIC_CLASS(wxRichTextPlainText)
1184 public:
1185 // Constructors
1186
1187 wxRichTextPlainText(const wxString& text = wxEmptyString, wxRichTextObject* parent = NULL, wxTextAttrEx* style = NULL);
1188 wxRichTextPlainText(const wxRichTextPlainText& obj):wxRichTextObject() { Copy(obj); }
1189
1190 // Overrideables
1191
1192 /// Draw the item
1193 virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style);
1194
1195 /// Lay the item out
1196 virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
1197
1198 /// Get/set the object size for the given range. Returns false if the range
1199 /// is invalid for this object.
1200 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags) const;
1201
1202 /// Get any text in this object for the given range
1203 virtual wxString GetTextForRange(const wxRichTextRange& range) const;
1204
1205 /// Do a split, returning an object containing the second part, and setting
1206 /// the first part in 'this'.
1207 virtual wxRichTextObject* DoSplit(long pos);
1208
1209 /// Calculate range
1210 virtual void CalculateRange(long start, long& end);
1211
1212 /// Delete range
1213 virtual bool DeleteRange(const wxRichTextRange& range);
1214
1215 /// Returns true if the object is empty
1216 virtual bool IsEmpty() const { return m_text.empty(); }
1217
1218 /// Returns true if this object can merge itself with the given one.
1219 virtual bool CanMerge(wxRichTextObject* object) const;
1220
1221 /// Returns true if this object merged itself with the given one.
1222 /// The calling code will then delete the given object.
1223 virtual bool Merge(wxRichTextObject* object);
1224
1225 /// Dump to output stream for debugging
1226 virtual void Dump(wxTextOutputStream& stream);
1227
1228 // Accessors
1229
1230 /// Get the text
1231 const wxString& GetText() const { return m_text; }
1232
1233 /// Set the text
1234 void SetText(const wxString& text) { m_text = text; }
1235
1236 // Operations
1237
1238 /// Copy
1239 void Copy(const wxRichTextPlainText& obj);
1240
1241 /// Clone
1242 virtual wxRichTextObject* Clone() const { return new wxRichTextPlainText(*this); }
1243
1244 protected:
1245 wxString m_text;
1246 };
1247
1248 /*!
1249 * wxRichTextImageBlock stores information about an image, in binary in-memory form
1250 */
1251
1252 class WXDLLIMPEXP_BASE wxDataInputStream;
1253 class WXDLLIMPEXP_BASE wxDataOutputStream;
1254
1255 class WXDLLIMPEXP_ADV wxRichTextImageBlock: public wxObject
1256 {
1257 public:
1258 wxRichTextImageBlock();
1259 wxRichTextImageBlock(const wxRichTextImageBlock& block);
1260 ~wxRichTextImageBlock();
1261
1262 void Init();
1263 void Clear();
1264
1265 // Load the original image into a memory block.
1266 // If the image is not a JPEG, we must convert it into a JPEG
1267 // to conserve space.
1268 // If it's not a JPEG we can make use of 'image', already scaled, so we don't have to
1269 // load the image a 2nd time.
1270 virtual bool MakeImageBlock(const wxString& filename, int imageType, wxImage& image, bool convertToJPEG = true);
1271
1272 // Make an image block from the wxImage in the given
1273 // format.
1274 virtual bool MakeImageBlock(wxImage& image, int imageType, int quality = 80);
1275
1276 // Write to a file
1277 bool Write(const wxString& filename);
1278
1279 // Write data in hex to a stream
1280 bool WriteHex(wxOutputStream& stream);
1281
1282 // Read data in hex from a stream
1283 bool ReadHex(wxInputStream& stream, int length, int imageType);
1284
1285 // Copy from 'block'
1286 void Copy(const wxRichTextImageBlock& block);
1287
1288 // Load a wxImage from the block
1289 bool Load(wxImage& image);
1290
1291 //// Operators
1292 void operator=(const wxRichTextImageBlock& block);
1293
1294 //// Accessors
1295
1296 unsigned char* GetData() const { return m_data; }
1297 size_t GetDataSize() const { return m_dataSize; }
1298 int GetImageType() const { return m_imageType; }
1299
1300 void SetData(unsigned char* image) { m_data = image; }
1301 void SetDataSize(size_t size) { m_dataSize = size; }
1302 void SetImageType(int imageType) { m_imageType = imageType; }
1303
1304 bool Ok() const { return GetData() != NULL; }
1305
1306 /// Implementation
1307
1308 /// Allocate and read from stream as a block of memory
1309 static unsigned char* ReadBlock(wxInputStream& stream, size_t size);
1310 static unsigned char* ReadBlock(const wxString& filename, size_t size);
1311
1312 // Write memory block to stream
1313 static bool WriteBlock(wxOutputStream& stream, unsigned char* block, size_t size);
1314
1315 // Write memory block to file
1316 static bool WriteBlock(const wxString& filename, unsigned char* block, size_t size);
1317
1318 protected:
1319 // Size in bytes of the image stored.
1320 // This is in the raw, original form such as a JPEG file.
1321 unsigned char* m_data;
1322 size_t m_dataSize;
1323 int m_imageType; // wxWin type id
1324 };
1325
1326
1327 /*!
1328 * wxRichTextImage class declaration
1329 * This object represents an image.
1330 */
1331
1332 class WXDLLIMPEXP_ADV wxRichTextImage: public wxRichTextObject
1333 {
1334 DECLARE_DYNAMIC_CLASS(wxRichTextImage)
1335 public:
1336 // Constructors
1337
1338 wxRichTextImage(wxRichTextObject* parent = NULL):wxRichTextObject(parent) { }
1339 wxRichTextImage(const wxImage& image, wxRichTextObject* parent = NULL);
1340 wxRichTextImage(const wxRichTextImageBlock& imageBlock, wxRichTextObject* parent = NULL);
1341 wxRichTextImage(const wxRichTextImage& obj):wxRichTextObject() { Copy(obj); }
1342
1343 // Overrideables
1344
1345 /// Draw the item
1346 virtual bool Draw(wxDC& dc, const wxRichTextRange& range, const wxRichTextRange& selectionRange, const wxRect& rect, int descent, int style);
1347
1348 /// Lay the item out
1349 virtual bool Layout(wxDC& dc, const wxRect& rect, int style);
1350
1351 /// Get the object size for the given range. Returns false if the range
1352 /// is invalid for this object.
1353 virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, int flags) const;
1354
1355 /// Returns true if the object is empty
1356 virtual bool IsEmpty() const { return !m_image.Ok(); }
1357
1358 // Accessors
1359
1360 /// Get the image
1361 const wxImage& GetImage() const { return m_image; }
1362
1363 /// Set the image
1364 void SetImage(const wxImage& image) { m_image = image; }
1365
1366 /// Get the image block containing the raw data
1367 wxRichTextImageBlock& GetImageBlock() { return m_imageBlock; }
1368
1369 // Operations
1370
1371 /// Copy
1372 void Copy(const wxRichTextImage& obj);
1373
1374 /// Clone
1375 virtual wxRichTextObject* Clone() const { return new wxRichTextImage(*this); }
1376
1377 /// Load wxImage from the block
1378 virtual bool LoadFromBlock();
1379
1380 /// Make block from the wxImage
1381 virtual bool MakeBlock();
1382
1383 protected:
1384 // TODO: reduce the multiple representations of data
1385 wxImage m_image;
1386 wxBitmap m_bitmap;
1387 wxRichTextImageBlock m_imageBlock;
1388 };
1389
1390
1391 /*!
1392 * wxRichTextBuffer class declaration
1393 * This is a kind of box, used to represent the whole buffer
1394 */
1395
1396 class WXDLLIMPEXP_ADV wxRichTextCommand;
1397 class WXDLLIMPEXP_ADV wxRichTextAction;
1398
1399 class WXDLLIMPEXP_ADV wxRichTextBuffer: public wxRichTextParagraphLayoutBox
1400 {
1401 DECLARE_DYNAMIC_CLASS(wxRichTextBuffer)
1402 public:
1403 // Constructors
1404
1405 wxRichTextBuffer() { Init(); }
1406 wxRichTextBuffer(const wxRichTextBuffer& obj):wxRichTextParagraphLayoutBox() { Init(); Copy(obj); }
1407 ~wxRichTextBuffer() ;
1408
1409 // Accessors
1410
1411 /// Gets the command processor
1412 wxCommandProcessor* GetCommandProcessor() const { return m_commandProcessor; }
1413
1414 /// Set style sheet, if any.
1415 void SetStyleSheet(wxRichTextStyleSheet* styleSheet) { m_styleSheet = styleSheet; }
1416 wxRichTextStyleSheet* GetStyleSheet() const { return m_styleSheet; }
1417
1418 // Operations
1419
1420 /// Initialisation
1421 void Init();
1422
1423 /// Clears the buffer and resets the command processor
1424 virtual void Clear();
1425
1426 /// The same as Clear, and adds an empty paragraph.
1427 virtual void Reset();
1428
1429 /// Load a file
1430 virtual bool LoadFile(const wxString& filename, int type = wxRICHTEXT_TYPE_ANY);
1431
1432 /// Save a file
1433 virtual bool SaveFile(const wxString& filename, int type = wxRICHTEXT_TYPE_ANY);
1434
1435 /// Load from a stream
1436 virtual bool LoadFile(wxInputStream& stream, int type = wxRICHTEXT_TYPE_ANY);
1437
1438 /// Save to a stream
1439 virtual bool SaveFile(wxOutputStream& stream, int type = wxRICHTEXT_TYPE_ANY);
1440
1441 /// Convenience function to add a paragraph of text
1442 virtual wxRichTextRange AddParagraph(const wxString& text) { Modify(); return wxRichTextParagraphLayoutBox::AddParagraph(text); }
1443
1444 /// Begin collapsing undo/redo commands. Note that this may not work properly
1445 /// if combining commands that delete or insert content, changing ranges for
1446 /// subsequent actions.
1447 virtual bool BeginBatchUndo(const wxString& cmdName);
1448
1449 /// End collapsing undo/redo commands
1450 virtual bool EndBatchUndo();
1451
1452 /// Collapsing commands?
1453 virtual bool BatchingUndo() const { return m_batchedCommandDepth > 0; }
1454
1455 /// Submit immediately, or delay according to whether collapsing is on
1456 virtual bool SubmitAction(wxRichTextAction* action);
1457
1458 /// Get collapsed command
1459 virtual wxRichTextCommand* GetBatchedCommand() const { return m_batchedCommand; }
1460
1461 /// Begin suppressing undo/redo commands. The way undo is suppressed may be implemented
1462 /// differently by each command. If not dealt with by a command implementation, then
1463 /// it will be implemented automatically by not storing the command in the undo history
1464 /// when the action is submitted to the command processor.
1465 virtual bool BeginSuppressUndo();
1466
1467 /// End suppressing undo/redo commands.
1468 virtual bool EndSuppressUndo();
1469
1470 /// Collapsing commands?
1471 virtual bool SuppressingUndo() const { return m_suppressUndo > 0; }
1472
1473 /// Copy the range to the clipboard
1474 virtual bool CopyToClipboard(const wxRichTextRange& range);
1475
1476 /// Paste the clipboard content to the buffer
1477 virtual bool PasteFromClipboard(long position);
1478
1479 /// Can we paste from the clipboard?
1480 virtual bool CanPasteFromClipboard() const;
1481
1482 /// Begin using a style
1483 virtual bool BeginStyle(const wxTextAttrEx& style);
1484
1485 /// End the style
1486 virtual bool EndStyle();
1487
1488 /// End all styles
1489 virtual bool EndAllStyles();
1490
1491 /// Clear the style stack
1492 virtual void ClearStyleStack();
1493
1494 /// Get the size of the style stack, for example to check correct nesting
1495 virtual int GetStyleStackSize() const { return m_attributeStack.GetCount(); }
1496
1497 /// Begin using bold
1498 bool BeginBold();
1499
1500 /// End using bold
1501 bool EndBold() { return EndStyle(); }
1502
1503 /// Begin using italic
1504 bool BeginItalic();
1505
1506 /// End using italic
1507 bool EndItalic() { return EndStyle(); }
1508
1509 /// Begin using underline
1510 bool BeginUnderline();
1511
1512 /// End using underline
1513 bool EndUnderline() { return EndStyle(); }
1514
1515 /// Begin using point size
1516 bool BeginFontSize(int pointSize);
1517
1518 /// End using point size
1519 bool EndFontSize() { return EndStyle(); }
1520
1521 /// Begin using this font
1522 bool BeginFont(const wxFont& font);
1523
1524 /// End using a font
1525 bool EndFont() { return EndStyle(); }
1526
1527 /// Begin using this colour
1528 bool BeginTextColour(const wxColour& colour);
1529
1530 /// End using a colour
1531 bool EndTextColour() { return EndStyle(); }
1532
1533 /// Begin using alignment
1534 bool BeginAlignment(wxTextAttrAlignment alignment);
1535
1536 /// End alignment
1537 bool EndAlignment() { return EndStyle(); }
1538
1539 /// Begin left indent
1540 bool BeginLeftIndent(int leftIndent, int leftSubIndent = 0);
1541
1542 /// End left indent
1543 bool EndLeftIndent() { return EndStyle(); }
1544
1545 /// Begin right indent
1546 bool BeginRightIndent(int rightIndent);
1547
1548 /// End right indent
1549 bool EndRightIndent() { return EndStyle(); }
1550
1551 /// Begin paragraph spacing
1552 bool BeginParagraphSpacing(int before, int after);
1553
1554 /// End paragraph spacing
1555 bool EndParagraphSpacing() { return EndStyle(); }
1556
1557 /// Begin line spacing
1558 bool BeginLineSpacing(int lineSpacing);
1559
1560 /// End line spacing
1561 bool EndLineSpacing() { return EndStyle(); }
1562
1563 /// Begin numbered bullet
1564 bool BeginNumberedBullet(int bulletNumber, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_ARABIC|wxTEXT_ATTR_BULLET_STYLE_PERIOD);
1565
1566 /// End numbered bullet
1567 bool EndNumberedBullet() { return EndStyle(); }
1568
1569 /// Begin symbol bullet
1570 bool BeginSymbolBullet(wxChar symbol, int leftIndent, int leftSubIndent, int bulletStyle = wxTEXT_ATTR_BULLET_STYLE_SYMBOL);
1571
1572 /// End symbol bullet
1573 bool EndSymbolBullet() { return EndStyle(); }
1574
1575 /// Begin named character style
1576 bool BeginCharacterStyle(const wxString& characterStyle);
1577
1578 /// End named character style
1579 bool EndCharacterStyle() { return EndStyle(); }
1580
1581 /// Begin named paragraph style
1582 bool BeginParagraphStyle(const wxString& paragraphStyle);
1583
1584 /// End named character style
1585 bool EndParagraphStyle() { return EndStyle(); }
1586
1587 // Implementation
1588
1589 /// Copy
1590 void Copy(const wxRichTextBuffer& obj) { wxRichTextBox::Copy(obj); }
1591
1592 /// Clone
1593 virtual wxRichTextObject* Clone() const { return new wxRichTextBuffer(*this); }
1594
1595 /// Submit command to insert the given text
1596 bool InsertTextWithUndo(long pos, const wxString& text, wxRichTextCtrl* ctrl);
1597
1598 /// Submit command to insert a newline
1599 bool InsertNewlineWithUndo(long pos, wxRichTextCtrl* ctrl);
1600
1601 /// Submit command to insert the given image
1602 bool InsertImageWithUndo(long pos, const wxRichTextImageBlock& imageBlock, wxRichTextCtrl* ctrl);
1603
1604 /// Submit command to delete this range
1605 bool DeleteRangeWithUndo(const wxRichTextRange& range, long initialCaretPosition, long newCaretPositon, wxRichTextCtrl* ctrl);
1606
1607 /// Mark modified
1608 void Modify(bool modify = true) { m_modified = modify; }
1609 bool IsModified() const { return m_modified; }
1610
1611 /// Dumps contents of buffer for debugging purposes
1612 virtual void Dump();
1613 virtual void Dump(wxTextOutputStream& stream) { wxRichTextParagraphLayoutBox::Dump(stream); }
1614
1615 /// Returns the file handlers
1616 static wxList& GetHandlers() { return sm_handlers; }
1617
1618 /// Adds a handler to the end
1619 static void AddHandler(wxRichTextFileHandler *handler);
1620
1621 /// Inserts a handler at the front
1622 static void InsertHandler(wxRichTextFileHandler *handler);
1623
1624 /// Removes a handler
1625 static bool RemoveHandler(const wxString& name);
1626
1627 /// Finds a handler by name
1628 static wxRichTextFileHandler *FindHandler(const wxString& name);
1629
1630 /// Finds a handler by extension and type
1631 static wxRichTextFileHandler *FindHandler(const wxString& extension, int imageType);
1632
1633 /// Finds a handler by filename or, if supplied, type
1634 static wxRichTextFileHandler *FindHandlerFilenameOrType(const wxString& filename, int imageType);
1635
1636 /// Finds a handler by type
1637 static wxRichTextFileHandler *FindHandler(int imageType);
1638
1639 /// Gets a wildcard incorporating all visible handlers. If 'types' is present,
1640 /// will be filled with the file type corresponding to each filter. This can be
1641 /// used to determine the type to pass to LoadFile given a selected filter.
1642 static wxString GetExtWildcard(bool combine = false, bool save = false, wxArrayInt* types = NULL);
1643
1644 /// Clean up handlers
1645 static void CleanUpHandlers();
1646
1647 /// Initialise the standard handlers
1648 static void InitStandardHandlers();
1649
1650 protected:
1651
1652 /// Command processor
1653 wxCommandProcessor* m_commandProcessor;
1654
1655 /// Has been modified?
1656 bool m_modified;
1657
1658 /// Collapsed command stack
1659 int m_batchedCommandDepth;
1660
1661 /// Name for collapsed command
1662 wxString m_batchedCommandsName;
1663
1664 /// Current collapsed command accumulating actions
1665 wxRichTextCommand* m_batchedCommand;
1666
1667 /// Whether to suppress undo
1668 int m_suppressUndo;
1669
1670 /// Style sheet, if any
1671 wxRichTextStyleSheet* m_styleSheet;
1672
1673 /// Stack of attributes for convenience functions
1674 wxList m_attributeStack;
1675
1676 /// File handlers
1677 static wxList sm_handlers;
1678 };
1679
1680 /*!
1681 * The command identifiers
1682 *
1683 */
1684
1685 enum wxRichTextCommandId
1686 {
1687 wxRICHTEXT_INSERT,
1688 wxRICHTEXT_DELETE,
1689 wxRICHTEXT_CHANGE_STYLE
1690 };
1691
1692 /*!
1693 * Command classes for undo/redo
1694 *
1695 */
1696
1697 class WXDLLIMPEXP_ADV wxRichTextAction;
1698 class WXDLLIMPEXP_ADV wxRichTextCommand: public wxCommand
1699 {
1700 public:
1701 // Ctor for one action
1702 wxRichTextCommand(const wxString& name, wxRichTextCommandId id, wxRichTextBuffer* buffer,
1703 wxRichTextCtrl* ctrl, bool ignoreFirstTime = false);
1704
1705 // Ctor for multiple actions
1706 wxRichTextCommand(const wxString& name);
1707
1708 ~wxRichTextCommand();
1709
1710 bool Do();
1711 bool Undo();
1712
1713 void AddAction(wxRichTextAction* action);
1714 void ClearActions();
1715
1716 wxList& GetActions() { return m_actions; }
1717
1718 protected:
1719
1720 wxList m_actions;
1721 };
1722
1723 /*!
1724 * wxRichTextAction class declaration
1725 * There can be more than one action in a command.
1726 */
1727
1728 class WXDLLIMPEXP_ADV wxRichTextAction: public wxObject
1729 {
1730 public:
1731 wxRichTextAction(wxRichTextCommand* cmd, const wxString& name, wxRichTextCommandId id, wxRichTextBuffer* buffer,
1732 wxRichTextCtrl* ctrl, bool ignoreFirstTime = false);
1733
1734 ~wxRichTextAction();
1735
1736 bool Do();
1737 bool Undo();
1738
1739 /// Update the control appearance
1740 void UpdateAppearance(long caretPosition, bool sendUpdateEvent = false);
1741
1742 /// Replace the buffer paragraphs with the given fragment.
1743 void ApplyParagraphs(const wxRichTextFragment& fragment);
1744
1745 /// Get the fragments
1746 wxRichTextFragment& GetNewParagraphs() { return m_newParagraphs; }
1747 wxRichTextFragment& GetOldParagraphs() { return m_oldParagraphs; }
1748
1749 /// Set/get the position used for e.g. insertion
1750 void SetPosition(long pos) { m_position = pos; }
1751 long GetPosition() const { return m_position; }
1752
1753 /// Set/get the range for e.g. deletion
1754 void SetRange(const wxRichTextRange& range) { m_range = range; }
1755 const wxRichTextRange& GetRange() const { return m_range; }
1756
1757 /// Get name
1758 const wxString& GetName() const { return m_name; }
1759
1760 protected:
1761 // Action name
1762 wxString m_name;
1763
1764 // Buffer
1765 wxRichTextBuffer* m_buffer;
1766
1767 // Control
1768 wxRichTextCtrl* m_ctrl;
1769
1770 // Stores the new paragraphs
1771 wxRichTextFragment m_newParagraphs;
1772
1773 // Stores the old paragraphs
1774 wxRichTextFragment m_oldParagraphs;
1775
1776 // The affected range
1777 wxRichTextRange m_range;
1778
1779 // The insertion point for this command
1780 long m_position;
1781
1782 // Ignore 1st 'Do' operation because we already did it
1783 bool m_ignoreThis;
1784
1785 // The command identifier
1786 wxRichTextCommandId m_cmdId;
1787 };
1788
1789 /*!
1790 * wxRichTextFileHandler
1791 * Base class for file handlers
1792 */
1793
1794 class WXDLLIMPEXP_ADV wxRichTextFileHandler: public wxObject
1795 {
1796 DECLARE_CLASS(wxRichTextFileHandler)
1797 public:
1798 wxRichTextFileHandler(const wxString& name = wxEmptyString, const wxString& ext = wxEmptyString, int type = 0)
1799 : m_name(name), m_extension(ext), m_type(type), m_visible(true)
1800 { }
1801
1802 #if wxUSE_STREAMS
1803 bool LoadFile(wxRichTextBuffer *buffer, wxInputStream& stream)
1804 { return DoLoadFile(buffer, stream); }
1805 bool SaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream)
1806 { return DoSaveFile(buffer, stream); }
1807 #endif
1808
1809 bool LoadFile(wxRichTextBuffer *buffer, const wxString& filename);
1810 bool SaveFile(wxRichTextBuffer *buffer, const wxString& filename);
1811
1812 /// Can we handle this filename (if using files)? By default, checks the extension.
1813 virtual bool CanHandle(const wxString& filename) const;
1814
1815 /// Can we save using this handler?
1816 virtual bool CanSave() const { return false; }
1817
1818 /// Can we load using this handler?
1819 virtual bool CanLoad() const { return false; }
1820
1821 /// Should this handler be visible to the user?
1822 virtual bool IsVisible() const { return m_visible; }
1823 virtual void SetVisible(bool visible) { m_visible = visible; }
1824
1825 void SetName(const wxString& name) { m_name = name; }
1826 wxString GetName() const { return m_name; }
1827
1828 void SetExtension(const wxString& ext) { m_extension = ext; }
1829 wxString GetExtension() const { return m_extension; }
1830
1831 void SetType(int type) { m_type = type; }
1832 int GetType() const { return m_type; }
1833
1834 protected:
1835
1836 #if wxUSE_STREAMS
1837 virtual bool DoLoadFile(wxRichTextBuffer *buffer, wxInputStream& stream) = 0;
1838 virtual bool DoSaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream) = 0;
1839 #endif
1840
1841 wxString m_name;
1842 wxString m_extension;
1843 int m_type;
1844 bool m_visible;
1845 };
1846
1847 /*!
1848 * wxRichTextPlainTextHandler
1849 * Plain text handler
1850 */
1851
1852 class WXDLLIMPEXP_ADV wxRichTextPlainTextHandler: public wxRichTextFileHandler
1853 {
1854 DECLARE_CLASS(wxRichTextPlainTextHandler)
1855 public:
1856 wxRichTextPlainTextHandler(const wxString& name = wxT("Text"), const wxString& ext = wxT("txt"), int type = wxRICHTEXT_TYPE_TEXT)
1857 : wxRichTextFileHandler(name, ext, type)
1858 { }
1859
1860 /// Can we save using this handler?
1861 virtual bool CanSave() const { return true; }
1862
1863 /// Can we load using this handler?
1864 virtual bool CanLoad() const { return true; }
1865
1866 protected:
1867
1868 #if wxUSE_STREAMS
1869 virtual bool DoLoadFile(wxRichTextBuffer *buffer, wxInputStream& stream);
1870 virtual bool DoSaveFile(wxRichTextBuffer *buffer, wxOutputStream& stream);
1871 #endif
1872
1873 };
1874
1875 /*!
1876 * Utilities
1877 *
1878 */
1879
1880 inline bool wxRichTextHasStyle(int flags, int style)
1881 {
1882 return ((flags & style) == style);
1883 }
1884
1885 /// Compare two attribute objects
1886 bool wxTextAttrEq(const wxTextAttrEx& attr1, const wxTextAttrEx& attr2);
1887 bool wxTextAttrEq(const wxTextAttr& attr1, const wxRichTextAttr& attr2);
1888
1889 /// Compare two attribute objects, but take into account the flags
1890 /// specifying attributes of interest.
1891 bool wxTextAttrEqPartial(const wxTextAttrEx& attr1, const wxTextAttrEx& attr2, int flags);
1892 bool wxTextAttrEqPartial(const wxTextAttrEx& attr1, const wxRichTextAttr& attr2, int flags);
1893
1894 /// Apply one style to another
1895 bool wxRichTextApplyStyle(wxTextAttrEx& destStyle, const wxTextAttrEx& style);
1896 bool wxRichTextApplyStyle(wxRichTextAttr& destStyle, const wxTextAttrEx& style);
1897 bool wxRichTextApplyStyle(wxTextAttrEx& destStyle, const wxRichTextAttr& style);
1898
1899 #endif
1900 // wxUSE_RICHTEXT
1901
1902 #endif
1903 // _WX_RICHTEXTBUFFER_H_