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