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