]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: wx/propgrid/property.h | |
3 | // Purpose: wxPGProperty and related support classes | |
4 | // Author: Jaakko Salli | |
5 | // Modified by: | |
6 | // Created: 2008-08-23 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) Jaakko Salli | |
9 | // Licence: wxWindows license | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | #ifndef _WX_PROPGRID_PROPERTY_H_ | |
13 | #define _WX_PROPGRID_PROPERTY_H_ | |
14 | ||
15 | #if wxUSE_PROPGRID | |
16 | ||
17 | #include "wx/propgrid/propgriddefs.h" | |
18 | ||
19 | // ----------------------------------------------------------------------- | |
20 | ||
21 | #define wxNullProperty ((wxPGProperty*)NULL) | |
22 | ||
23 | ||
24 | /** @class wxPGPaintData | |
25 | ||
26 | Contains information relayed to property's OnCustomPaint. | |
27 | */ | |
28 | struct wxPGPaintData | |
29 | { | |
30 | /** wxPropertyGrid. */ | |
31 | const wxPropertyGrid* m_parent; | |
32 | ||
33 | /** | |
34 | Normally -1, otherwise index to drop-down list item that has to be | |
35 | drawn. | |
36 | */ | |
37 | int m_choiceItem; | |
38 | ||
39 | /** Set to drawn width in OnCustomPaint (optional). */ | |
40 | int m_drawnWidth; | |
41 | ||
42 | /** | |
43 | In a measure item call, set this to the height of item at m_choiceItem | |
44 | index. | |
45 | */ | |
46 | int m_drawnHeight; | |
47 | }; | |
48 | ||
49 | ||
50 | #ifndef SWIG | |
51 | ||
52 | ||
53 | // space between vertical sides of a custom image | |
54 | #define wxPG_CUSTOM_IMAGE_SPACINGY 1 | |
55 | ||
56 | // space between caption and selection rectangle, | |
57 | #define wxPG_CAPRECTXMARGIN 2 | |
58 | ||
59 | // horizontally and vertically | |
60 | #define wxPG_CAPRECTYMARGIN 1 | |
61 | ||
62 | ||
63 | /** @class wxPGCellRenderer | |
64 | ||
65 | Base class for wxPropertyGrid cell renderers. | |
66 | */ | |
67 | class WXDLLIMPEXP_PROPGRID wxPGCellRenderer | |
68 | { | |
69 | public: | |
70 | ||
71 | wxPGCellRenderer( unsigned int refCount = 1 ) | |
72 | : m_refCount(refCount) { } | |
73 | virtual ~wxPGCellRenderer() { } | |
74 | ||
75 | // Render flags | |
76 | enum | |
77 | { | |
78 | // We are painting selected item | |
79 | Selected = 0x00010000, | |
80 | ||
81 | // We are painting item in choice popup | |
82 | ChoicePopup = 0x00020000, | |
83 | ||
84 | // We are rendering wxOwnerDrawnComboBox control | |
85 | // (or other owner drawn control, but that is only | |
86 | // officially supported one ATM). | |
87 | Control = 0x00040000, | |
88 | ||
89 | // We are painting a disable property | |
90 | Disabled = 0x00080000, | |
91 | ||
92 | // We are painting selected, disabled, or similar | |
93 | // item that dictates fore- and background colours, | |
94 | // overriding any cell values. | |
95 | DontUseCellFgCol = 0x00100000, | |
96 | DontUseCellBgCol = 0x00200000, | |
97 | DontUseCellColours = DontUseCellFgCol | | |
98 | DontUseCellBgCol | |
99 | }; | |
100 | ||
101 | virtual void Render( wxDC& dc, | |
102 | const wxRect& rect, | |
103 | const wxPropertyGrid* propertyGrid, | |
104 | wxPGProperty* property, | |
105 | int column, | |
106 | int item, | |
107 | int flags ) const = 0; | |
108 | ||
109 | /** Returns size of the image in front of the editable area. | |
110 | @remarks | |
111 | If property is NULL, then this call is for a custom value. In that case | |
112 | the item is index to wxPropertyGrid's custom values. | |
113 | */ | |
114 | virtual wxSize GetImageSize( const wxPGProperty* property, | |
115 | int column, | |
116 | int item ) const; | |
117 | ||
118 | /** Paints property category selection rectangle. | |
119 | */ | |
120 | virtual void DrawCaptionSelectionRect( wxDC& dc, | |
121 | int x, int y, | |
122 | int w, int h ) const; | |
123 | ||
124 | /** Utility to draw vertically centered text. | |
125 | */ | |
126 | void DrawText( wxDC& dc, | |
127 | const wxRect& rect, | |
128 | int imageWidth, | |
129 | const wxString& text ) const; | |
130 | ||
131 | /** | |
132 | Utility to draw editor's value, or vertically aligned text if editor is | |
133 | NULL. | |
134 | */ | |
135 | void DrawEditorValue( wxDC& dc, const wxRect& rect, | |
136 | int xOffset, const wxString& text, | |
137 | wxPGProperty* property, | |
138 | const wxPGEditor* editor ) const; | |
139 | ||
140 | /** Utility to render cell bitmap and set text colour plus bg brush colour. | |
141 | ||
142 | Returns image width that, for instance, can be passed to DrawText. | |
143 | */ | |
144 | int PreDrawCell( wxDC& dc, | |
145 | const wxRect& rect, | |
146 | const wxPGCell& cell, | |
147 | int flags ) const; | |
148 | ||
149 | void IncRef() | |
150 | { | |
151 | m_refCount++; | |
152 | } | |
153 | ||
154 | void DecRef() | |
155 | { | |
156 | m_refCount--; | |
157 | if ( !m_refCount ) | |
158 | delete this; | |
159 | } | |
160 | protected: | |
161 | ||
162 | private: | |
163 | unsigned int m_refCount; | |
164 | }; | |
165 | ||
166 | ||
167 | class WXDLLIMPEXP_PROPGRID wxPGCellData : public wxObjectRefData | |
168 | { | |
169 | friend class wxPGCell; | |
170 | public: | |
171 | wxPGCellData(); | |
172 | ||
173 | void SetText( const wxString& text ) | |
174 | { | |
175 | m_text = text; | |
176 | m_hasValidText = true; | |
177 | } | |
178 | void SetBitmap( const wxBitmap& bitmap ) { m_bitmap = bitmap; } | |
179 | void SetFgCol( const wxColour& col ) { m_fgCol = col; } | |
180 | void SetBgCol( const wxColour& col ) { m_bgCol = col; } | |
181 | ||
182 | protected: | |
183 | virtual ~wxPGCellData() { } | |
184 | ||
185 | wxString m_text; | |
186 | wxBitmap m_bitmap; | |
187 | wxColour m_fgCol; | |
188 | wxColour m_bgCol; | |
189 | ||
190 | // True if m_text is valid and specified | |
191 | bool m_hasValidText; | |
192 | }; | |
193 | ||
194 | /** @class wxPGCell | |
195 | ||
196 | Base class for simple wxPropertyGrid cell information. | |
197 | */ | |
198 | class WXDLLIMPEXP_PROPGRID wxPGCell : public wxObject | |
199 | { | |
200 | public: | |
201 | wxPGCell(); | |
202 | wxPGCell(const wxPGCell& other) | |
203 | : wxObject(other) | |
204 | { | |
205 | } | |
206 | ||
207 | wxPGCell( const wxString& text, | |
208 | const wxBitmap& bitmap = wxNullBitmap, | |
209 | const wxColour& fgCol = wxNullColour, | |
210 | const wxColour& bgCol = wxNullColour ); | |
211 | ||
212 | virtual ~wxPGCell() { } | |
213 | ||
214 | wxPGCellData* GetData() | |
215 | { | |
216 | return (wxPGCellData*) m_refData; | |
217 | } | |
218 | ||
219 | const wxPGCellData* GetData() const | |
220 | { | |
221 | return (const wxPGCellData*) m_refData; | |
222 | } | |
223 | ||
224 | bool HasText() const | |
225 | { | |
226 | return (m_refData && GetData()->m_hasValidText); | |
227 | } | |
228 | ||
229 | /** | |
230 | Merges valid data from srcCell into this. | |
231 | */ | |
232 | void MergeFrom( const wxPGCell& srcCell ); | |
233 | ||
234 | void SetText( const wxString& text ); | |
235 | void SetBitmap( const wxBitmap& bitmap ); | |
236 | void SetFgCol( const wxColour& col ); | |
237 | void SetBgCol( const wxColour& col ); | |
238 | ||
239 | const wxString& GetText() const { return GetData()->m_text; } | |
240 | const wxBitmap& GetBitmap() const { return GetData()->m_bitmap; } | |
241 | const wxColour& GetFgCol() const { return GetData()->m_fgCol; } | |
242 | const wxColour& GetBgCol() const { return GetData()->m_bgCol; } | |
243 | ||
244 | wxPGCell& operator=( const wxPGCell& other ) | |
245 | { | |
246 | if ( this != &other ) | |
247 | { | |
248 | Ref(other); | |
249 | } | |
250 | return *this; | |
251 | } | |
252 | ||
253 | protected: | |
254 | virtual wxObjectRefData *CreateRefData() const | |
255 | { return new wxPGCellData(); } | |
256 | ||
257 | virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const; | |
258 | }; | |
259 | ||
260 | ||
261 | /** @class wxPGDefaultRenderer | |
262 | ||
263 | Default cell renderer, that can handles the common | |
264 | scenarios. | |
265 | */ | |
266 | class WXDLLIMPEXP_PROPGRID wxPGDefaultRenderer : public wxPGCellRenderer | |
267 | { | |
268 | public: | |
269 | virtual void Render( wxDC& dc, | |
270 | const wxRect& rect, | |
271 | const wxPropertyGrid* propertyGrid, | |
272 | wxPGProperty* property, | |
273 | int column, | |
274 | int item, | |
275 | int flags ) const; | |
276 | ||
277 | virtual wxSize GetImageSize( const wxPGProperty* property, | |
278 | int column, | |
279 | int item ) const; | |
280 | ||
281 | protected: | |
282 | }; | |
283 | ||
284 | // ----------------------------------------------------------------------- | |
285 | ||
286 | /** @class wxPGAttributeStorage | |
287 | ||
288 | wxPGAttributeStorage is somewhat optimized storage for | |
289 | key=variant pairs (ie. a map). | |
290 | */ | |
291 | class WXDLLIMPEXP_PROPGRID wxPGAttributeStorage | |
292 | { | |
293 | public: | |
294 | wxPGAttributeStorage(); | |
295 | ~wxPGAttributeStorage(); | |
296 | ||
297 | void Set( const wxString& name, const wxVariant& value ); | |
298 | unsigned int GetCount() const { return (unsigned int) m_map.size(); } | |
299 | wxVariant FindValue( const wxString& name ) const | |
300 | { | |
301 | wxPGHashMapS2P::const_iterator it = m_map.find(name); | |
302 | if ( it != m_map.end() ) | |
303 | { | |
304 | wxVariantData* data = (wxVariantData*) it->second; | |
305 | data->IncRef(); | |
306 | return wxVariant(data, it->first); | |
307 | } | |
308 | return wxVariant(); | |
309 | } | |
310 | ||
311 | typedef wxPGHashMapS2P::const_iterator const_iterator; | |
312 | const_iterator StartIteration() const | |
313 | { | |
314 | return m_map.begin(); | |
315 | } | |
316 | bool GetNext( const_iterator& it, wxVariant& variant ) const | |
317 | { | |
318 | if ( it == m_map.end() ) | |
319 | return false; | |
320 | ||
321 | wxVariantData* data = (wxVariantData*) it->second; | |
322 | data->IncRef(); | |
323 | variant.SetData(data); | |
324 | variant.SetName(it->first); | |
325 | ++it; | |
326 | return true; | |
327 | } | |
328 | ||
329 | protected: | |
330 | wxPGHashMapS2P m_map; | |
331 | }; | |
332 | ||
333 | #endif // !SWIG | |
334 | ||
335 | // ----------------------------------------------------------------------- | |
336 | ||
337 | /** @section propgrid_propflags wxPGProperty Flags | |
338 | @{ | |
339 | */ | |
340 | ||
341 | enum wxPG_PROPERTY_FLAGS | |
342 | { | |
343 | ||
344 | /** Indicates bold font. | |
345 | */ | |
346 | wxPG_PROP_MODIFIED = 0x0001, | |
347 | ||
348 | /** Disables ('greyed' text and editor does not activate) property. | |
349 | */ | |
350 | wxPG_PROP_DISABLED = 0x0002, | |
351 | ||
352 | /** Hider button will hide this property. | |
353 | */ | |
354 | wxPG_PROP_HIDDEN = 0x0004, | |
355 | ||
356 | /** This property has custom paint image just in front of its value. | |
357 | If property only draws custom images into a popup list, then this | |
358 | flag should not be set. | |
359 | */ | |
360 | wxPG_PROP_CUSTOMIMAGE = 0x0008, | |
361 | ||
362 | /** Do not create text based editor for this property (but button-triggered | |
363 | dialog and choice are ok). | |
364 | */ | |
365 | wxPG_PROP_NOEDITOR = 0x0010, | |
366 | ||
367 | /** Property is collapsed, ie. it's children are hidden. | |
368 | */ | |
369 | wxPG_PROP_COLLAPSED = 0x0020, | |
370 | ||
371 | /** | |
372 | If property is selected, then indicates that validation failed for pending | |
373 | value. | |
374 | ||
375 | If property is not selected, then indicates that the the actual property | |
376 | value has failed validation (NB: this behavior is not currently supported, | |
377 | but may be used in future). | |
378 | */ | |
379 | wxPG_PROP_INVALID_VALUE = 0x0040, | |
380 | ||
381 | // 0x0080, | |
382 | ||
383 | /** Switched via SetWasModified(). Temporary flag - only used when | |
384 | setting/changing property value. | |
385 | */ | |
386 | wxPG_PROP_WAS_MODIFIED = 0x0200, | |
387 | ||
388 | /** | |
389 | If set, then child properties (if any) are private, and should be | |
390 | "invisible" to the application. | |
391 | */ | |
392 | wxPG_PROP_AGGREGATE = 0x0400, | |
393 | ||
394 | /** If set, then child properties (if any) are copies and should not | |
395 | be deleted in dtor. | |
396 | */ | |
397 | wxPG_PROP_CHILDREN_ARE_COPIES = 0x0800, | |
398 | ||
399 | /** | |
400 | Classifies this item as a non-category. | |
401 | ||
402 | Used for faster item type identification. | |
403 | */ | |
404 | wxPG_PROP_PROPERTY = 0x1000, | |
405 | ||
406 | /** | |
407 | Classifies this item as a category. | |
408 | ||
409 | Used for faster item type identification. | |
410 | */ | |
411 | wxPG_PROP_CATEGORY = 0x2000, | |
412 | ||
413 | /** Classifies this item as a property that has children, but is not aggregate | |
414 | (ie children are not private). | |
415 | */ | |
416 | wxPG_PROP_MISC_PARENT = 0x4000, | |
417 | ||
418 | /** Property is read-only. Editor is still created. | |
419 | */ | |
420 | wxPG_PROP_READONLY = 0x8000, | |
421 | ||
422 | // | |
423 | // NB: FLAGS ABOVE 0x8000 CANNOT BE USED WITH PROPERTY ITERATORS | |
424 | // | |
425 | ||
426 | /** Property's value is composed from values of child properties. | |
427 | @remarks | |
428 | This flag cannot be used with property iterators. | |
429 | */ | |
430 | wxPG_PROP_COMPOSED_VALUE = 0x00010000, | |
431 | ||
432 | /** Common value of property is selectable in editor. | |
433 | @remarks | |
434 | This flag cannot be used with property iterators. | |
435 | */ | |
436 | wxPG_PROP_USES_COMMON_VALUE = 0x00020000, | |
437 | ||
438 | /** Property can be set to unspecified value via editor. | |
439 | Currently, this applies to following properties: | |
440 | - wxIntProperty, wxUIntProperty, wxFloatProperty, wxEditEnumProperty: | |
441 | Clear the text field | |
442 | ||
443 | @remarks | |
444 | This flag cannot be used with property iterators. | |
445 | */ | |
446 | wxPG_PROP_AUTO_UNSPECIFIED = 0x00040000, | |
447 | ||
448 | /** Indicates the bit useable by derived properties. | |
449 | */ | |
450 | wxPG_PROP_CLASS_SPECIFIC_1 = 0x00080000, | |
451 | ||
452 | /** Indicates the bit useable by derived properties. | |
453 | */ | |
454 | wxPG_PROP_CLASS_SPECIFIC_2 = 0x00100000 | |
455 | ||
456 | }; | |
457 | ||
458 | /** Topmost flag. | |
459 | */ | |
460 | #define wxPG_PROP_MAX wxPG_PROP_AUTO_UNSPECIFIED | |
461 | ||
462 | /** Property with children must have one of these set, otherwise iterators | |
463 | will not work correctly. | |
464 | Code should automatically take care of this, however. | |
465 | */ | |
466 | #define wxPG_PROP_PARENTAL_FLAGS \ | |
467 | (wxPG_PROP_AGGREGATE|wxPG_PROP_CATEGORY|wxPG_PROP_MISC_PARENT) | |
468 | ||
469 | /** @} | |
470 | */ | |
471 | ||
472 | // Combination of flags that can be stored by GetFlagsAsString | |
473 | #define wxPG_STRING_STORED_FLAGS \ | |
474 | (wxPG_PROP_DISABLED|wxPG_PROP_HIDDEN|wxPG_PROP_NOEDITOR|wxPG_PROP_COLLAPSED) | |
475 | ||
476 | // ----------------------------------------------------------------------- | |
477 | ||
478 | #ifndef SWIG | |
479 | ||
480 | /** | |
481 | @section propgrid_property_attributes wxPropertyGrid Property Attribute | |
482 | Identifiers. | |
483 | ||
484 | wxPGProperty::SetAttribute() and | |
485 | wxPropertyGridInterface::SetPropertyAttribute() accept one of these as | |
486 | attribute name argument. | |
487 | ||
488 | You can use strings instead of constants. However, some of these | |
489 | constants are redefined to use cached strings which may reduce | |
490 | your binary size by some amount. | |
491 | ||
492 | @{ | |
493 | */ | |
494 | ||
495 | /** Set default value for property. | |
496 | */ | |
497 | #define wxPG_ATTR_DEFAULT_VALUE wxS("DefaultValue") | |
498 | ||
499 | /** Universal, int or double. Minimum value for numeric properties. | |
500 | */ | |
501 | #define wxPG_ATTR_MIN wxS("Min") | |
502 | ||
503 | /** Universal, int or double. Maximum value for numeric properties. | |
504 | */ | |
505 | #define wxPG_ATTR_MAX wxS("Max") | |
506 | ||
507 | /** Universal, string. When set, will be shown as text after the displayed | |
508 | text value. Alternatively, if third column is enabled, text will be shown | |
509 | there (for any type of property). | |
510 | */ | |
511 | #define wxPG_ATTR_UNITS wxS("Units") | |
512 | ||
513 | /** Universal, string. When set, will be shown in property's value cell | |
514 | when displayed value string is empty, or value is unspecified. | |
515 | */ | |
516 | #define wxPG_ATTR_INLINE_HELP wxS("InlineHelp") | |
517 | ||
518 | /** wxBoolProperty specific, int, default 0. When 1 sets bool property to | |
519 | use checkbox instead of choice. | |
520 | */ | |
521 | #define wxPG_BOOL_USE_CHECKBOX wxS("UseCheckbox") | |
522 | ||
523 | /** wxBoolProperty specific, int, default 0. When 1 sets bool property value | |
524 | to cycle on double click (instead of showing the popup listbox). | |
525 | */ | |
526 | #define wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING wxS("UseDClickCycling") | |
527 | ||
528 | /** | |
529 | wxFloatProperty (and similar) specific, int, default -1. | |
530 | ||
531 | Sets the (max) precision used when floating point value is rendered as | |
532 | text. The default -1 means infinite precision. | |
533 | */ | |
534 | #define wxPG_FLOAT_PRECISION wxS("Precision") | |
535 | ||
536 | /** | |
537 | The text will be echoed as asterisks (wxTE_PASSWORD will be passed to | |
538 | textctrl etc). | |
539 | */ | |
540 | #define wxPG_STRING_PASSWORD wxS("Password") | |
541 | ||
542 | /** Define base used by a wxUIntProperty. Valid constants are | |
543 | wxPG_BASE_OCT, wxPG_BASE_DEC, wxPG_BASE_HEX and wxPG_BASE_HEXL | |
544 | (lowercase characters). | |
545 | */ | |
546 | #define wxPG_UINT_BASE wxS("Base") | |
547 | ||
548 | /** Define prefix rendered to wxUIntProperty. Accepted constants | |
549 | wxPG_PREFIX_NONE, wxPG_PREFIX_0x, and wxPG_PREFIX_DOLLAR_SIGN. | |
550 | <b>Note:</b> Only wxPG_PREFIX_NONE works with Decimal and Octal | |
551 | numbers. | |
552 | */ | |
553 | #define wxPG_UINT_PREFIX wxS("Prefix") | |
554 | ||
555 | /** | |
556 | wxFileProperty/wxImageFileProperty specific, wxChar*, default is | |
557 | detected/varies. | |
558 | Sets the wildcard used in the triggered wxFileDialog. Format is the same. | |
559 | */ | |
560 | #define wxPG_FILE_WILDCARD wxS("Wildcard") | |
561 | ||
562 | /** wxFileProperty/wxImageFileProperty specific, int, default 1. | |
563 | When 0, only the file name is shown (i.e. drive and directory are hidden). | |
564 | */ | |
565 | #define wxPG_FILE_SHOW_FULL_PATH wxS("ShowFullPath") | |
566 | ||
567 | /** Specific to wxFileProperty and derived properties, wxString, default empty. | |
568 | If set, then the filename is shown relative to the given path string. | |
569 | */ | |
570 | #define wxPG_FILE_SHOW_RELATIVE_PATH wxS("ShowRelativePath") | |
571 | ||
572 | /** | |
573 | Specific to wxFileProperty and derived properties, wxString, default is | |
574 | empty. | |
575 | ||
576 | Sets the initial path of where to look for files. | |
577 | */ | |
578 | #define wxPG_FILE_INITIAL_PATH wxS("InitialPath") | |
579 | ||
580 | /** Specific to wxFileProperty and derivatives, wxString, default is empty. | |
581 | Sets a specific title for the dir dialog. | |
582 | */ | |
583 | #define wxPG_FILE_DIALOG_TITLE wxS("DialogTitle") | |
584 | ||
585 | /** Specific to wxDirProperty, wxString, default is empty. | |
586 | Sets a specific message for the dir dialog. | |
587 | */ | |
588 | #define wxPG_DIR_DIALOG_MESSAGE wxS("DialogMessage") | |
589 | ||
590 | /** Sets displayed date format for wxDateProperty. | |
591 | */ | |
592 | #define wxPG_DATE_FORMAT wxS("DateFormat") | |
593 | ||
594 | /** Sets wxDatePickerCtrl window style used with wxDateProperty. Default | |
595 | is wxDP_DEFAULT | wxDP_SHOWCENTURY. | |
596 | */ | |
597 | #define wxPG_DATE_PICKER_STYLE wxS("PickerStyle") | |
598 | ||
599 | /** SpinCtrl editor, int or double. How much number changes when button is | |
600 | pressed (or up/down on keybard). | |
601 | */ | |
602 | #define wxPG_ATTR_SPINCTRL_STEP wxS("Step") | |
603 | ||
604 | /** SpinCtrl editor, bool. If true, value wraps at Min/Max. | |
605 | */ | |
606 | #define wxPG_ATTR_SPINCTRL_WRAP wxS("Wrap") | |
607 | ||
608 | /** | |
609 | wxMultiChoiceProperty, int. | |
610 | If 0, no user strings allowed. If 1, user strings appear before list | |
611 | strings. If 2, user strings appear after list string. | |
612 | */ | |
613 | #define wxPG_ATTR_MULTICHOICE_USERSTRINGMODE wxS("UserStringMode") | |
614 | ||
615 | /** | |
616 | wxColourProperty and its kind, int, default 1. | |
617 | ||
618 | Setting this attribute to 0 hides custom colour from property's list of | |
619 | choices. | |
620 | */ | |
621 | #define wxPG_COLOUR_ALLOW_CUSTOM wxS("AllowCustom") | |
622 | ||
623 | /** @} | |
624 | */ | |
625 | ||
626 | // Redefine attribute macros to use cached strings | |
627 | #undef wxPG_ATTR_MIN | |
628 | #define wxPG_ATTR_MIN wxPGGlobalVars->m_strMin | |
629 | #undef wxPG_ATTR_MAX | |
630 | #define wxPG_ATTR_MAX wxPGGlobalVars->m_strMax | |
631 | #undef wxPG_ATTR_UNITS | |
632 | #define wxPG_ATTR_UNITS wxPGGlobalVars->m_strUnits | |
633 | #undef wxPG_ATTR_INLINE_HELP | |
634 | #define wxPG_ATTR_INLINE_HELP wxPGGlobalVars->m_strInlineHelp | |
635 | ||
636 | #endif // !SWIG | |
637 | ||
638 | // ----------------------------------------------------------------------- | |
639 | ||
640 | #ifndef SWIG | |
641 | ||
642 | /** @class wxPGChoiceEntry | |
643 | Data of a single wxPGChoices choice. | |
644 | */ | |
645 | class WXDLLIMPEXP_PROPGRID wxPGChoiceEntry : public wxPGCell | |
646 | { | |
647 | public: | |
648 | wxPGChoiceEntry(); | |
649 | wxPGChoiceEntry(const wxPGChoiceEntry& other) | |
650 | : wxPGCell(other) | |
651 | { | |
652 | m_value = other.m_value; | |
653 | } | |
654 | wxPGChoiceEntry( const wxString& label, | |
655 | int value = wxPG_INVALID_VALUE ) | |
656 | : wxPGCell(), m_value(value) | |
657 | { | |
658 | SetText(label); | |
659 | } | |
660 | ||
661 | virtual ~wxPGChoiceEntry() { } | |
662 | ||
663 | void SetValue( int value ) { m_value = value; } | |
664 | int GetValue() const { return m_value; } | |
665 | ||
666 | wxPGChoiceEntry& operator=( const wxPGChoiceEntry& other ) | |
667 | { | |
668 | if ( this != &other ) | |
669 | { | |
670 | Ref(other); | |
671 | } | |
672 | m_value = other.m_value; | |
673 | return *this; | |
674 | } | |
675 | ||
676 | protected: | |
677 | int m_value; | |
678 | }; | |
679 | ||
680 | ||
681 | typedef void* wxPGChoicesId; | |
682 | ||
683 | class WXDLLIMPEXP_PROPGRID wxPGChoicesData | |
684 | { | |
685 | friend class wxPGChoices; | |
686 | public: | |
687 | // Constructor sets m_refCount to 1. | |
688 | wxPGChoicesData(); | |
689 | ||
690 | void CopyDataFrom( wxPGChoicesData* data ); | |
691 | ||
692 | wxPGChoiceEntry& Insert( int index, const wxPGChoiceEntry& item ); | |
693 | ||
694 | // Delete all entries | |
695 | void Clear(); | |
696 | ||
697 | unsigned int GetCount() const | |
698 | { | |
699 | return (unsigned int) m_items.size(); | |
700 | } | |
701 | ||
702 | const wxPGChoiceEntry& Item( unsigned int i ) const | |
703 | { | |
704 | wxASSERT_MSG( i < GetCount(), "invalid index" ); | |
705 | return m_items[i]; | |
706 | } | |
707 | ||
708 | wxPGChoiceEntry& Item( unsigned int i ) | |
709 | { | |
710 | wxASSERT_MSG( i < GetCount(), "invalid index" ); | |
711 | return m_items[i]; | |
712 | } | |
713 | ||
714 | void DecRef() | |
715 | { | |
716 | m_refCount--; | |
717 | wxASSERT( m_refCount >= 0 ); | |
718 | if ( m_refCount == 0 ) | |
719 | delete this; | |
720 | } | |
721 | ||
722 | private: | |
723 | wxVector<wxPGChoiceEntry> m_items; | |
724 | ||
725 | // So that multiple properties can use the same set | |
726 | int m_refCount; | |
727 | ||
728 | virtual ~wxPGChoicesData(); | |
729 | }; | |
730 | ||
731 | #define wxPGChoicesEmptyData ((wxPGChoicesData*)NULL) | |
732 | ||
733 | #endif // SWIG | |
734 | ||
735 | /** @class wxPGChoices | |
736 | ||
737 | Helper class for managing choices of wxPropertyGrid properties. | |
738 | Each entry can have label, value, bitmap, text colour, and background | |
739 | colour. | |
740 | ||
741 | wxPGChoices uses reference counting, similar to other wxWidgets classes. | |
742 | This means that assignment operator and copy constructor only copy the | |
743 | reference and not the actual data. Use Copy() member function to create a | |
744 | real copy. | |
745 | ||
746 | @remarks If you do not specify value for entry, index is used. | |
747 | ||
748 | @library{wxpropgrid} | |
749 | @category{propgrid} | |
750 | */ | |
751 | class WXDLLIMPEXP_PROPGRID wxPGChoices | |
752 | { | |
753 | public: | |
754 | typedef long ValArrItem; | |
755 | ||
756 | /** Default constructor. */ | |
757 | wxPGChoices() | |
758 | { | |
759 | Init(); | |
760 | } | |
761 | ||
762 | /** | |
763 | Copy constructor, uses reference counting. To create a real copy, | |
764 | use Copy() member function instead. | |
765 | */ | |
766 | wxPGChoices( const wxPGChoices& a ) | |
767 | { | |
768 | if ( a.m_data != wxPGChoicesEmptyData ) | |
769 | { | |
770 | m_data = a.m_data; | |
771 | m_data->m_refCount++; | |
772 | } | |
773 | } | |
774 | ||
775 | /** | |
776 | Constructor. | |
777 | ||
778 | @param labels | |
779 | Labels for choices | |
780 | ||
781 | @param values | |
782 | Values for choices. If NULL, indexes are used. | |
783 | */ | |
784 | wxPGChoices( const wxChar** labels, const long* values = NULL ) | |
785 | { | |
786 | Init(); | |
787 | Set(labels,values); | |
788 | } | |
789 | ||
790 | /** | |
791 | Constructor. | |
792 | ||
793 | @param labels | |
794 | Labels for choices | |
795 | ||
796 | @param values | |
797 | Values for choices. If empty, indexes are used. | |
798 | */ | |
799 | wxPGChoices( const wxArrayString& labels, | |
800 | const wxArrayInt& values = wxArrayInt() ) | |
801 | { | |
802 | Init(); | |
803 | Set(labels,values); | |
804 | } | |
805 | ||
806 | /** Simple interface constructor. */ | |
807 | wxPGChoices( wxPGChoicesData* data ) | |
808 | { | |
809 | wxASSERT(data); | |
810 | m_data = data; | |
811 | data->m_refCount++; | |
812 | } | |
813 | ||
814 | /** Destructor. */ | |
815 | ~wxPGChoices() | |
816 | { | |
817 | Free(); | |
818 | } | |
819 | ||
820 | /** | |
821 | Adds to current. | |
822 | ||
823 | If did not have own copies, creates them now. If was empty, identical | |
824 | to set except that creates copies. | |
825 | ||
826 | @param labels | |
827 | Labels for added choices. | |
828 | ||
829 | @param values | |
830 | Values for added choices. If empty, relevant entry indexes are used. | |
831 | */ | |
832 | void Add( const wxChar** labels, const ValArrItem* values = NULL ); | |
833 | ||
834 | /** Version that works with wxArrayString and wxArrayInt. */ | |
835 | void Add( const wxArrayString& arr, const wxArrayInt& arrint = wxArrayInt() ); | |
836 | ||
837 | /** | |
838 | Adds a single choice. | |
839 | ||
840 | @param label | |
841 | Label for added choice. | |
842 | ||
843 | @param value | |
844 | Value for added choice. If unspecified, index is used. | |
845 | */ | |
846 | wxPGChoiceEntry& Add( const wxString& label, | |
847 | int value = wxPG_INVALID_VALUE ); | |
848 | ||
849 | /** Adds a single item, with bitmap. */ | |
850 | wxPGChoiceEntry& Add( const wxString& label, | |
851 | const wxBitmap& bitmap, | |
852 | int value = wxPG_INVALID_VALUE ); | |
853 | ||
854 | /** Adds a single item with full entry information. */ | |
855 | wxPGChoiceEntry& Add( const wxPGChoiceEntry& entry ) | |
856 | { | |
857 | return Insert(entry, -1); | |
858 | } | |
859 | ||
860 | /** Adds single item. */ | |
861 | wxPGChoiceEntry& AddAsSorted( const wxString& label, | |
862 | int value = wxPG_INVALID_VALUE ); | |
863 | ||
864 | /** | |
865 | Assigns choices data, using reference counting. To create a real copy, | |
866 | use Copy() member function instead. | |
867 | */ | |
868 | void Assign( const wxPGChoices& a ) | |
869 | { | |
870 | AssignData(a.m_data); | |
871 | } | |
872 | ||
873 | void AssignData( wxPGChoicesData* data ); | |
874 | ||
875 | /** Delete all choices. */ | |
876 | void Clear() | |
877 | { | |
878 | if ( m_data != wxPGChoicesEmptyData ) | |
879 | m_data->Clear(); | |
880 | } | |
881 | ||
882 | /** | |
883 | Returns a real copy of the choices. | |
884 | */ | |
885 | wxPGChoices Copy() const | |
886 | { | |
887 | wxPGChoices dst; | |
888 | dst.EnsureData(); | |
889 | dst.m_data->CopyDataFrom(m_data); | |
890 | return dst; | |
891 | } | |
892 | ||
893 | void EnsureData() | |
894 | { | |
895 | if ( m_data == wxPGChoicesEmptyData ) | |
896 | m_data = new wxPGChoicesData(); | |
897 | } | |
898 | ||
899 | /** Gets a unsigned number identifying this list. */ | |
900 | wxPGChoicesId GetId() const { return (wxPGChoicesId) m_data; }; | |
901 | ||
902 | const wxString& GetLabel( unsigned int ind ) const | |
903 | { | |
904 | return Item(ind).GetText(); | |
905 | } | |
906 | ||
907 | unsigned int GetCount () const | |
908 | { | |
909 | if ( !m_data ) | |
910 | return 0; | |
911 | ||
912 | return m_data->GetCount(); | |
913 | } | |
914 | ||
915 | int GetValue( unsigned int ind ) const { return Item(ind).GetValue(); } | |
916 | ||
917 | /** Returns array of values matching the given strings. Unmatching strings | |
918 | result in wxPG_INVALID_VALUE entry in array. | |
919 | */ | |
920 | wxArrayInt GetValuesForStrings( const wxArrayString& strings ) const; | |
921 | ||
922 | /** Returns array of indices matching given strings. Unmatching strings | |
923 | are added to 'unmatched', if not NULL. | |
924 | */ | |
925 | wxArrayInt GetIndicesForStrings( const wxArrayString& strings, | |
926 | wxArrayString* unmatched = NULL ) const; | |
927 | ||
928 | int Index( const wxString& str ) const; | |
929 | int Index( int val ) const; | |
930 | ||
931 | /** Inserts single item. */ | |
932 | wxPGChoiceEntry& Insert( const wxString& label, | |
933 | int index, | |
934 | int value = wxPG_INVALID_VALUE ); | |
935 | ||
936 | /** Inserts a single item with full entry information. */ | |
937 | wxPGChoiceEntry& Insert( const wxPGChoiceEntry& entry, int index ); | |
938 | ||
939 | /** Returns false if this is a constant empty set of choices, | |
940 | which should not be modified. | |
941 | */ | |
942 | bool IsOk() const | |
943 | { | |
944 | return ( m_data != wxPGChoicesEmptyData ); | |
945 | } | |
946 | ||
947 | const wxPGChoiceEntry& Item( unsigned int i ) const | |
948 | { | |
949 | wxASSERT( IsOk() ); | |
950 | return m_data->Item(i); | |
951 | } | |
952 | ||
953 | wxPGChoiceEntry& Item( unsigned int i ) | |
954 | { | |
955 | wxASSERT( IsOk() ); | |
956 | return m_data->Item(i); | |
957 | } | |
958 | ||
959 | /** Removes count items starting at position nIndex. */ | |
960 | void RemoveAt(size_t nIndex, size_t count = 1); | |
961 | ||
962 | #ifndef SWIG | |
963 | /** Does not create copies for itself. */ | |
964 | void Set( const wxChar** labels, const long* values = NULL ) | |
965 | { | |
966 | Free(); | |
967 | Add(labels,values); | |
968 | } | |
969 | #endif // SWIG | |
970 | ||
971 | /** Version that works with wxArrayString and wxArrayInt. */ | |
972 | void Set( const wxArrayString& labels, | |
973 | const wxArrayInt& values = wxArrayInt() ) | |
974 | { | |
975 | Free(); | |
976 | if ( &values ) | |
977 | Add(labels,values); | |
978 | else | |
979 | Add(labels); | |
980 | } | |
981 | ||
982 | // Creates exclusive copy of current choices | |
983 | void SetExclusive() | |
984 | { | |
985 | if ( m_data->m_refCount != 1 ) | |
986 | { | |
987 | wxPGChoicesData* data = new wxPGChoicesData(); | |
988 | data->CopyDataFrom(m_data); | |
989 | Free(); | |
990 | m_data = data; | |
991 | } | |
992 | } | |
993 | ||
994 | // Returns data, increases refcount. | |
995 | wxPGChoicesData* GetData() | |
996 | { | |
997 | wxASSERT( m_data->m_refCount != 0xFFFFFFF ); | |
998 | m_data->m_refCount++; | |
999 | return m_data; | |
1000 | } | |
1001 | ||
1002 | // Returns plain data ptr - no refcounting stuff is done. | |
1003 | wxPGChoicesData* GetDataPtr() const { return m_data; } | |
1004 | ||
1005 | // Changes ownership of data to you. | |
1006 | wxPGChoicesData* ExtractData() | |
1007 | { | |
1008 | wxPGChoicesData* data = m_data; | |
1009 | m_data = wxPGChoicesEmptyData; | |
1010 | return data; | |
1011 | } | |
1012 | ||
1013 | wxArrayString GetLabels() const; | |
1014 | ||
1015 | #ifndef SWIG | |
1016 | void operator= (const wxPGChoices& a) | |
1017 | { | |
1018 | if (this != &a) | |
1019 | AssignData(a.m_data); | |
1020 | } | |
1021 | ||
1022 | wxPGChoiceEntry& operator[](unsigned int i) | |
1023 | { | |
1024 | return Item(i); | |
1025 | } | |
1026 | ||
1027 | const wxPGChoiceEntry& operator[](unsigned int i) const | |
1028 | { | |
1029 | return Item(i); | |
1030 | } | |
1031 | ||
1032 | protected: | |
1033 | wxPGChoicesData* m_data; | |
1034 | ||
1035 | void Init(); | |
1036 | void Free(); | |
1037 | #endif // !SWIG | |
1038 | }; | |
1039 | ||
1040 | // ----------------------------------------------------------------------- | |
1041 | ||
1042 | /** @class wxPGProperty | |
1043 | ||
1044 | wxPGProperty is base class for all wxPropertyGrid properties. | |
1045 | ||
1046 | NB: Full class overview is now only present in | |
1047 | interface/wx/propgrid/property.h. | |
1048 | ||
1049 | @library{wxpropgrid} | |
1050 | @category{propgrid} | |
1051 | */ | |
1052 | class WXDLLIMPEXP_PROPGRID wxPGProperty : public wxObject | |
1053 | { | |
1054 | friend class wxPropertyGrid; | |
1055 | friend class wxPropertyGridInterface; | |
1056 | friend class wxPropertyGridPageState; | |
1057 | friend class wxPropertyGridPopulator; | |
1058 | friend class wxStringProperty; // Proper "<composed>" support requires this | |
1059 | #ifndef SWIG | |
1060 | DECLARE_ABSTRACT_CLASS(wxPGProperty) | |
1061 | #endif | |
1062 | public: | |
1063 | typedef wxUint32 FlagType; | |
1064 | ||
1065 | /** Basic constructor. | |
1066 | */ | |
1067 | wxPGProperty(); | |
1068 | ||
1069 | /** Constructor. | |
1070 | Non-abstract property classes should have constructor of this style: | |
1071 | ||
1072 | @code | |
1073 | ||
1074 | // If T is a class, then it should be a constant reference | |
1075 | // (e.g. const T& ) instead. | |
1076 | MyProperty( const wxString& label, const wxString& name, T value ) | |
1077 | : wxPGProperty() | |
1078 | { | |
1079 | // Generally recommended way to set the initial value | |
1080 | // (as it should work in pretty much 100% of cases). | |
1081 | wxVariant variant; | |
1082 | variant << value; | |
1083 | SetValue(variant); | |
1084 | ||
1085 | // If has private child properties then create them here. Also | |
1086 | // set flag that indicates presence of private children. E.g.: | |
1087 | // | |
1088 | // SetParentalType(wxPG_PROP_AGGREGATE); | |
1089 | // | |
1090 | // AddChild( new wxStringProperty( "Subprop 1", | |
1091 | // wxPG_LABEL, | |
1092 | // value.GetSubProp1() ) ); | |
1093 | } | |
1094 | ||
1095 | @endcode | |
1096 | */ | |
1097 | wxPGProperty( const wxString& label, const wxString& name ); | |
1098 | ||
1099 | /** | |
1100 | Virtual destructor. | |
1101 | It is customary for derived properties to implement this. | |
1102 | */ | |
1103 | virtual ~wxPGProperty(); | |
1104 | ||
1105 | /** This virtual function is called after m_value has been set. | |
1106 | ||
1107 | @remarks | |
1108 | - If m_value was set to Null variant (ie. unspecified value), | |
1109 | OnSetValue() will not be called. | |
1110 | - m_value may be of any variant type. Typically properties internally | |
1111 | support only one variant type, and as such OnSetValue() provides a | |
1112 | good opportunity to convert | |
1113 | supported values into internal type. | |
1114 | - Default implementation does nothing. | |
1115 | */ | |
1116 | virtual void OnSetValue(); | |
1117 | ||
1118 | /** Override this to return something else than m_value as the value. | |
1119 | */ | |
1120 | virtual wxVariant DoGetValue() const { return m_value; } | |
1121 | ||
1122 | #if !defined(SWIG) || defined(CREATE_VCW) | |
1123 | /** Implement this function in derived class to check the value. | |
1124 | Return true if it is ok. Returning false prevents property change events | |
1125 | from occurring. | |
1126 | ||
1127 | @remarks | |
1128 | - Default implementation always returns true. | |
1129 | */ | |
1130 | virtual bool ValidateValue( wxVariant& value, | |
1131 | wxPGValidationInfo& validationInfo ) const; | |
1132 | ||
1133 | /** | |
1134 | Converts text into wxVariant value appropriate for this property. | |
1135 | ||
1136 | @param variant | |
1137 | On function entry this is the old value (should not be wxNullVariant | |
1138 | in normal cases). Translated value must be assigned back to it. | |
1139 | ||
1140 | @param text | |
1141 | Text to be translated into variant. | |
1142 | ||
1143 | @param argFlags | |
1144 | If wxPG_FULL_VALUE is set, returns complete, storable value instead | |
1145 | of displayable one (they may be different). | |
1146 | If wxPG_COMPOSITE_FRAGMENT is set, text is interpreted as a part of | |
1147 | composite property string value (as generated by ValueToString() | |
1148 | called with this same flag). | |
1149 | ||
1150 | @return Returns @true if resulting wxVariant value was different. | |
1151 | ||
1152 | @remarks Default implementation converts semicolon delimited tokens into | |
1153 | child values. Only works for properties with children. | |
1154 | ||
1155 | You might want to take into account that m_value is Null variant | |
1156 | if property value is unspecified (which is usually only case if | |
1157 | you explicitly enabled that sort behavior). | |
1158 | */ | |
1159 | virtual bool StringToValue( wxVariant& variant, | |
1160 | const wxString& text, | |
1161 | int argFlags = 0 ) const; | |
1162 | ||
1163 | /** | |
1164 | Converts integer (possibly a choice selection) into wxVariant value | |
1165 | appropriate for this property. | |
1166 | ||
1167 | @param variant | |
1168 | On function entry this is the old value (should not be wxNullVariant | |
1169 | in normal cases). Translated value must be assigned back to it. | |
1170 | ||
1171 | @param number | |
1172 | Integer to be translated into variant. | |
1173 | ||
1174 | @param argFlags | |
1175 | If wxPG_FULL_VALUE is set, returns complete, storable value instead | |
1176 | of displayable one. | |
1177 | ||
1178 | @return Returns @true if resulting wxVariant value was different. | |
1179 | ||
1180 | @remarks | |
1181 | - If property is not supposed to use choice or spinctrl or other editor | |
1182 | with int-based value, it is not necessary to implement this method. | |
1183 | - Default implementation simply assign given int to m_value. | |
1184 | - If property uses choice control, and displays a dialog on some choice | |
1185 | items, then it is preferred to display that dialog in IntToValue | |
1186 | instead of OnEvent. | |
1187 | - You might want to take into account that m_value is Null variant if | |
1188 | property value is unspecified (which is usually only case if you | |
1189 | explicitly enabled that sort behavior). | |
1190 | */ | |
1191 | virtual bool IntToValue( wxVariant& value, | |
1192 | int number, | |
1193 | int argFlags = 0 ) const; | |
1194 | #endif // !defined(SWIG) || defined(CREATE_VCW) | |
1195 | /** | |
1196 | Converts property value into a text representation. | |
1197 | ||
1198 | @param value | |
1199 | Value to be converted. | |
1200 | ||
1201 | @param argFlags | |
1202 | If 0 (default value), then displayed string is returned. | |
1203 | If wxPG_FULL_VALUE is set, returns complete, storable string value | |
1204 | instead of displayable. If wxPG_EDITABLE_VALUE is set, returns | |
1205 | string value that must be editable in textctrl. If | |
1206 | wxPG_COMPOSITE_FRAGMENT is set, returns text that is appropriate to | |
1207 | display as a part of string property's composite text | |
1208 | representation. | |
1209 | ||
1210 | @remarks Default implementation calls GenerateComposedValue(). | |
1211 | */ | |
1212 | virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const; | |
1213 | ||
1214 | /** Converts string to a value, and if successful, calls SetValue() on it. | |
1215 | Default behavior is to do nothing. | |
1216 | @param text | |
1217 | String to get the value from. | |
1218 | @return | |
1219 | true if value was changed. | |
1220 | */ | |
1221 | bool SetValueFromString( const wxString& text, int flags = wxPG_PROGRAMMATIC_VALUE ); | |
1222 | ||
1223 | /** Converts integer to a value, and if succesful, calls SetValue() on it. | |
1224 | Default behavior is to do nothing. | |
1225 | @param value | |
1226 | Int to get the value from. | |
1227 | @param flags | |
1228 | If has wxPG_FULL_VALUE, then the value given is a actual value and | |
1229 | not an index. | |
1230 | @return | |
1231 | True if value was changed. | |
1232 | */ | |
1233 | bool SetValueFromInt( long value, int flags = 0 ); | |
1234 | ||
1235 | /** | |
1236 | Returns size of the custom painted image in front of property. | |
1237 | ||
1238 | This method must be overridden to return non-default value if | |
1239 | OnCustomPaint is to be called. | |
1240 | @param item | |
1241 | Normally -1, but can be an index to the property's list of items. | |
1242 | @remarks | |
1243 | - Default behavior is to return wxSize(0,0), which means no image. | |
1244 | - Default image width or height is indicated with dimension -1. | |
1245 | - You can also return wxPG_DEFAULT_IMAGE_SIZE, i.e. wxSize(-1, -1). | |
1246 | */ | |
1247 | virtual wxSize OnMeasureImage( int item = -1 ) const; | |
1248 | ||
1249 | /** | |
1250 | Events received by editor widgets are processed here. | |
1251 | ||
1252 | Note that editor class usually processes most events. Some, such as | |
1253 | button press events of TextCtrlAndButton class, can be handled here. | |
1254 | Also, if custom handling for regular events is desired, then that can | |
1255 | also be done (for example, wxSystemColourProperty custom handles | |
1256 | wxEVT_COMMAND_CHOICE_SELECTED to display colour picker dialog when | |
1257 | 'custom' selection is made). | |
1258 | ||
1259 | If the event causes value to be changed, SetValueInEvent() | |
1260 | should be called to set the new value. | |
1261 | ||
1262 | @param event | |
1263 | Associated wxEvent. | |
1264 | @return | |
1265 | Should return true if any changes in value should be reported. | |
1266 | @remarks | |
1267 | If property uses choice control, and displays a dialog on some choice | |
1268 | items, then it is preferred to display that dialog in IntToValue | |
1269 | instead of OnEvent. | |
1270 | */ | |
1271 | virtual bool OnEvent( wxPropertyGrid* propgrid, | |
1272 | wxWindow* wnd_primary, | |
1273 | wxEvent& event ); | |
1274 | ||
1275 | /** | |
1276 | Called after value of a child property has been altered. | |
1277 | ||
1278 | Note that this function is usually called at the time that value of | |
1279 | this property, or given child property, is still pending for change. | |
1280 | ||
1281 | Sample pseudo-code implementation: | |
1282 | ||
1283 | @code | |
1284 | void MyProperty::ChildChanged( wxVariant& thisValue, | |
1285 | int childIndex, | |
1286 | wxVariant& childValue ) const | |
1287 | { | |
1288 | // Acquire reference to actual type of data stored in variant | |
1289 | // (TFromVariant only exists if wxPropertyGrid's wxVariant-macros | |
1290 | // were used to create the variant class). | |
1291 | T& data = TFromVariant(thisValue); | |
1292 | ||
1293 | // Copy childValue into data. | |
1294 | switch ( childIndex ) | |
1295 | { | |
1296 | case 0: | |
1297 | data.SetSubProp1( childvalue.GetLong() ); | |
1298 | break; | |
1299 | case 1: | |
1300 | data.SetSubProp2( childvalue.GetString() ); | |
1301 | break; | |
1302 | ... | |
1303 | } | |
1304 | } | |
1305 | @endcode | |
1306 | ||
1307 | @param thisValue | |
1308 | Value of this property, that should be altered. | |
1309 | @param childIndex | |
1310 | Index of child changed (you can use Item(childIndex) to get). | |
1311 | @param childValue | |
1312 | Value of the child property. | |
1313 | */ | |
1314 | virtual void ChildChanged( wxVariant& thisValue, | |
1315 | int childIndex, | |
1316 | wxVariant& childValue ) const; | |
1317 | ||
1318 | /** Returns pointer to an instance of used editor. | |
1319 | */ | |
1320 | virtual const wxPGEditor* DoGetEditorClass() const; | |
1321 | ||
1322 | /** Returns pointer to the wxValidator that should be used | |
1323 | with the editor of this property (NULL for no validator). | |
1324 | Setting validator explicitly via SetPropertyValidator | |
1325 | will override this. | |
1326 | ||
1327 | In most situations, code like this should work well | |
1328 | (macros are used to maintain one actual validator instance, | |
1329 | so on the second call the function exits within the first | |
1330 | macro): | |
1331 | ||
1332 | @code | |
1333 | ||
1334 | wxValidator* wxMyPropertyClass::DoGetValidator () const | |
1335 | { | |
1336 | WX_PG_DOGETVALIDATOR_ENTRY() | |
1337 | ||
1338 | wxMyValidator* validator = new wxMyValidator(...); | |
1339 | ||
1340 | ... prepare validator... | |
1341 | ||
1342 | WX_PG_DOGETVALIDATOR_EXIT(validator) | |
1343 | } | |
1344 | ||
1345 | @endcode | |
1346 | ||
1347 | @remarks | |
1348 | You can get common filename validator by returning | |
1349 | wxFileProperty::GetClassValidator(). wxDirProperty, | |
1350 | for example, uses it. | |
1351 | */ | |
1352 | virtual wxValidator* DoGetValidator () const; | |
1353 | ||
1354 | /** | |
1355 | Override to paint an image in front of the property value text or | |
1356 | drop-down list item (but only if wxPGProperty::OnMeasureImage is | |
1357 | overridden as well). | |
1358 | ||
1359 | If property's OnMeasureImage() returns size that has height != 0 but | |
1360 | less than row height ( < 0 has special meanings), wxPropertyGrid calls | |
1361 | this method to draw a custom image in a limited area in front of the | |
1362 | editor control or value text/graphics, and if control has drop-down | |
1363 | list, then the image is drawn there as well (even in the case | |
1364 | OnMeasureImage() returned higher height than row height). | |
1365 | ||
1366 | NOTE: Following applies when OnMeasureImage() returns a "flexible" | |
1367 | height ( using wxPG_FLEXIBLE_SIZE(W,H) macro), which implies variable | |
1368 | height items: If rect.x is < 0, then this is a measure item call, which | |
1369 | means that dc is invalid and only thing that should be done is to set | |
1370 | paintdata.m_drawnHeight to the height of the image of item at index | |
1371 | paintdata.m_choiceItem. This call may be done even as often as once | |
1372 | every drop-down popup show. | |
1373 | ||
1374 | @param dc | |
1375 | wxDC to paint on. | |
1376 | @param rect | |
1377 | Box reserved for custom graphics. Includes surrounding rectangle, | |
1378 | if any. If x is < 0, then this is a measure item call (see above). | |
1379 | @param paintdata | |
1380 | wxPGPaintData structure with much useful data. | |
1381 | ||
1382 | @remarks | |
1383 | - You can actually exceed rect width, but if you do so then | |
1384 | paintdata.m_drawnWidth must be set to the full width drawn in | |
1385 | pixels. | |
1386 | - Due to technical reasons, rect's height will be default even if | |
1387 | custom height was reported during measure call. | |
1388 | - Brush is guaranteed to be default background colour. It has been | |
1389 | already used to clear the background of area being painted. It | |
1390 | can be modified. | |
1391 | - Pen is guaranteed to be 1-wide 'black' (or whatever is the proper | |
1392 | colour) pen for drawing framing rectangle. It can be changed as | |
1393 | well. | |
1394 | ||
1395 | @see ValueToString() | |
1396 | */ | |
1397 | virtual void OnCustomPaint( wxDC& dc, | |
1398 | const wxRect& rect, | |
1399 | wxPGPaintData& paintdata ); | |
1400 | ||
1401 | /** | |
1402 | Returns used wxPGCellRenderer instance for given property column | |
1403 | (label=0, value=1). | |
1404 | ||
1405 | Default implementation returns editor's renderer for all columns. | |
1406 | */ | |
1407 | virtual wxPGCellRenderer* GetCellRenderer( int column ) const; | |
1408 | ||
1409 | /** Returns which choice is currently selected. Only applies to properties | |
1410 | which have choices. | |
1411 | ||
1412 | Needs to reimplemented in derived class if property value does not | |
1413 | map directly to a choice. Integer as index, bool, and string usually do. | |
1414 | */ | |
1415 | virtual int GetChoiceSelection() const; | |
1416 | ||
1417 | /** | |
1418 | Refresh values of child properties. | |
1419 | ||
1420 | Automatically called after value is set. | |
1421 | */ | |
1422 | virtual void RefreshChildren(); | |
1423 | ||
1424 | /** Special handling for attributes of this property. | |
1425 | ||
1426 | If returns false, then the attribute will be automatically stored in | |
1427 | m_attributes. | |
1428 | ||
1429 | Default implementation simply returns false. | |
1430 | */ | |
1431 | virtual bool DoSetAttribute( const wxString& name, wxVariant& value ); | |
1432 | ||
1433 | /** Returns value of an attribute. | |
1434 | ||
1435 | Override if custom handling of attributes is needed. | |
1436 | ||
1437 | Default implementation simply return NULL variant. | |
1438 | */ | |
1439 | virtual wxVariant DoGetAttribute( const wxString& name ) const; | |
1440 | ||
1441 | /** Returns instance of a new wxPGEditorDialogAdapter instance, which is | |
1442 | used when user presses the (optional) button next to the editor control; | |
1443 | ||
1444 | Default implementation returns NULL (ie. no action is generated when | |
1445 | button is pressed). | |
1446 | */ | |
1447 | virtual wxPGEditorDialogAdapter* GetEditorDialog() const; | |
1448 | ||
1449 | /** | |
1450 | Called whenever validation has failed with given pending value. | |
1451 | ||
1452 | @remarks If you implement this in your custom property class, please | |
1453 | remember to call the baser implementation as well, since they | |
1454 | may use it to revert property into pre-change state. | |
1455 | */ | |
1456 | virtual void OnValidationFailure( wxVariant& pendingValue ); | |
1457 | ||
1458 | /** Append a new choice to property's list of choices. | |
1459 | */ | |
1460 | int AddChoice( const wxString& label, int value = wxPG_INVALID_VALUE ) | |
1461 | { | |
1462 | return InsertChoice(label, wxNOT_FOUND, value); | |
1463 | } | |
1464 | ||
1465 | /** | |
1466 | Returns true if children of this property are component values (for | |
1467 | instance, points size, face name, and is_underlined are component | |
1468 | values of a font). | |
1469 | */ | |
1470 | bool AreChildrenComponents() const | |
1471 | { | |
1472 | if ( m_flags & (wxPG_PROP_COMPOSED_VALUE|wxPG_PROP_AGGREGATE) ) | |
1473 | return true; | |
1474 | ||
1475 | return false; | |
1476 | } | |
1477 | ||
1478 | /** | |
1479 | Deletes children of the property. | |
1480 | */ | |
1481 | void DeleteChildren(); | |
1482 | ||
1483 | /** | |
1484 | Removes entry from property's wxPGChoices and editor control (if it is | |
1485 | active). | |
1486 | ||
1487 | If selected item is deleted, then the value is set to unspecified. | |
1488 | */ | |
1489 | void DeleteChoice( int index ); | |
1490 | ||
1491 | /** | |
1492 | Call to enable or disable usage of common value (integer value that can | |
1493 | be selected for properties instead of their normal values) for this | |
1494 | property. | |
1495 | ||
1496 | Common values are disabled by the default for all properties. | |
1497 | */ | |
1498 | void EnableCommonValue( bool enable = true ) | |
1499 | { | |
1500 | if ( enable ) SetFlag( wxPG_PROP_USES_COMMON_VALUE ); | |
1501 | else ClearFlag( wxPG_PROP_USES_COMMON_VALUE ); | |
1502 | } | |
1503 | ||
1504 | /** | |
1505 | Composes text from values of child properties. | |
1506 | */ | |
1507 | wxString GenerateComposedValue() const | |
1508 | { | |
1509 | wxString s; | |
1510 | DoGenerateComposedValue(s); | |
1511 | return s; | |
1512 | } | |
1513 | ||
1514 | /** Returns property's label. */ | |
1515 | const wxString& GetLabel() const { return m_label; } | |
1516 | ||
1517 | /** Returns property's name with all (non-category, non-root) parents. */ | |
1518 | wxString GetName() const; | |
1519 | ||
1520 | /** | |
1521 | Returns property's base name (ie parent's name is not added in any | |
1522 | case) | |
1523 | */ | |
1524 | const wxString& GetBaseName() const { return m_name; } | |
1525 | ||
1526 | /** Returns read-only reference to property's list of choices. | |
1527 | */ | |
1528 | const wxPGChoices& GetChoices() const | |
1529 | { | |
1530 | return m_choices; | |
1531 | } | |
1532 | ||
1533 | /** Returns coordinate to the top y of the property. Note that the | |
1534 | position of scrollbars is not taken into account. | |
1535 | */ | |
1536 | int GetY() const; | |
1537 | ||
1538 | wxVariant GetValue() const | |
1539 | { | |
1540 | return DoGetValue(); | |
1541 | } | |
1542 | ||
1543 | #ifndef SWIG | |
1544 | /** Returns reference to the internal stored value. GetValue is preferred | |
1545 | way to get the actual value, since GetValueRef ignores DoGetValue, | |
1546 | which may override stored value. | |
1547 | */ | |
1548 | wxVariant& GetValueRef() | |
1549 | { | |
1550 | return m_value; | |
1551 | } | |
1552 | ||
1553 | const wxVariant& GetValueRef() const | |
1554 | { | |
1555 | return m_value; | |
1556 | } | |
1557 | #endif | |
1558 | ||
1559 | /** Returns text representation of property's value. | |
1560 | ||
1561 | @param argFlags | |
1562 | If 0 (default value), then displayed string is returned. | |
1563 | If wxPG_FULL_VALUE is set, returns complete, storable string value | |
1564 | instead of displayable. If wxPG_EDITABLE_VALUE is set, returns | |
1565 | string value that must be editable in textctrl. If | |
1566 | wxPG_COMPOSITE_FRAGMENT is set, returns text that is appropriate to | |
1567 | display as a part of string property's composite text | |
1568 | representation. | |
1569 | ||
1570 | @remarks In older versions, this function used to be overridden to convert | |
1571 | property's value into a string representation. This function is | |
1572 | now handled by ValueToString(), and overriding this function now | |
1573 | will result in run-time assertion failure. | |
1574 | */ | |
1575 | virtual wxString GetValueAsString( int argFlags = 0 ) const; | |
1576 | ||
1577 | /** Synonymous to GetValueAsString(). | |
1578 | ||
1579 | @deprecated Use GetValueAsString() instead. | |
1580 | ||
1581 | @see GetValueAsString() | |
1582 | */ | |
1583 | wxDEPRECATED( wxString GetValueString( int argFlags = 0 ) const ); | |
1584 | ||
1585 | /** | |
1586 | Returns wxPGCell of given column. | |
1587 | */ | |
1588 | const wxPGCell& GetCell( unsigned int column ) const; | |
1589 | ||
1590 | wxPGCell& GetCell( unsigned int column ); | |
1591 | ||
1592 | /** Return number of displayed common values for this property. | |
1593 | */ | |
1594 | int GetDisplayedCommonValueCount() const; | |
1595 | ||
1596 | wxString GetDisplayedString() const | |
1597 | { | |
1598 | return GetValueAsString(0); | |
1599 | } | |
1600 | ||
1601 | /** Returns property grid where property lies. */ | |
1602 | wxPropertyGrid* GetGrid() const; | |
1603 | ||
1604 | /** Returns owner wxPropertyGrid, but only if one is currently on a page | |
1605 | displaying this property. */ | |
1606 | wxPropertyGrid* GetGridIfDisplayed() const; | |
1607 | ||
1608 | /** Returns highest level non-category, non-root parent. Useful when you | |
1609 | have nested wxCustomProperties/wxParentProperties. | |
1610 | @remarks | |
1611 | Thus, if immediate parent is root or category, this will return the | |
1612 | property itself. | |
1613 | */ | |
1614 | wxPGProperty* GetMainParent() const; | |
1615 | ||
1616 | /** Return parent of property */ | |
1617 | wxPGProperty* GetParent() const { return m_parent; } | |
1618 | ||
1619 | /** Returns true if property has editable wxTextCtrl when selected. | |
1620 | ||
1621 | @remarks | |
1622 | Altough disabled properties do not displayed editor, they still | |
1623 | return True here as being disabled is considered a temporary | |
1624 | condition (unlike being read-only or having limited editing enabled). | |
1625 | */ | |
1626 | bool IsTextEditable() const; | |
1627 | ||
1628 | bool IsValueUnspecified() const | |
1629 | { | |
1630 | return m_value.IsNull(); | |
1631 | } | |
1632 | ||
1633 | FlagType HasFlag( FlagType flag ) const | |
1634 | { | |
1635 | return ( m_flags & flag ); | |
1636 | } | |
1637 | ||
1638 | /** Returns comma-delimited string of property attributes. | |
1639 | */ | |
1640 | const wxPGAttributeStorage& GetAttributes() const | |
1641 | { | |
1642 | return m_attributes; | |
1643 | } | |
1644 | ||
1645 | /** Returns m_attributes as list wxVariant. | |
1646 | */ | |
1647 | wxVariant GetAttributesAsList() const; | |
1648 | ||
1649 | FlagType GetFlags() const | |
1650 | { | |
1651 | return m_flags; | |
1652 | } | |
1653 | ||
1654 | const wxPGEditor* GetEditorClass() const; | |
1655 | ||
1656 | wxString GetValueType() const | |
1657 | { | |
1658 | return m_value.GetType(); | |
1659 | } | |
1660 | ||
1661 | /** Returns editor used for given column. NULL for no editor. | |
1662 | */ | |
1663 | const wxPGEditor* GetColumnEditor( int column ) const | |
1664 | { | |
1665 | if ( column == 1 ) | |
1666 | return GetEditorClass(); | |
1667 | ||
1668 | return NULL; | |
1669 | } | |
1670 | ||
1671 | /** Returns common value selected for this property. -1 for none. | |
1672 | */ | |
1673 | int GetCommonValue() const | |
1674 | { | |
1675 | return m_commonValue; | |
1676 | } | |
1677 | ||
1678 | /** Returns true if property has even one visible child. | |
1679 | */ | |
1680 | bool HasVisibleChildren() const; | |
1681 | ||
1682 | /** Inserts a new choice to property's list of choices. | |
1683 | */ | |
1684 | int InsertChoice( const wxString& label, int index, int value = wxPG_INVALID_VALUE ); | |
1685 | ||
1686 | /** | |
1687 | Returns true if this property is actually a wxPropertyCategory. | |
1688 | */ | |
1689 | bool IsCategory() const { return HasFlag(wxPG_PROP_CATEGORY)?true:false; } | |
1690 | ||
1691 | /** Returns true if this property is actually a wxRootProperty. | |
1692 | */ | |
1693 | bool IsRoot() const { return (m_parent == NULL); } | |
1694 | ||
1695 | /** Returns true if this is a sub-property. */ | |
1696 | bool IsSubProperty() const | |
1697 | { | |
1698 | wxPGProperty* parent = (wxPGProperty*)m_parent; | |
1699 | if ( parent && !parent->IsCategory() ) | |
1700 | return true; | |
1701 | return false; | |
1702 | } | |
1703 | ||
1704 | /** Returns last visible sub-property, recursively. | |
1705 | */ | |
1706 | const wxPGProperty* GetLastVisibleSubItem() const; | |
1707 | ||
1708 | wxVariant GetDefaultValue() const; | |
1709 | ||
1710 | int GetMaxLength() const | |
1711 | { | |
1712 | return (int) m_maxLen; | |
1713 | } | |
1714 | ||
1715 | /** | |
1716 | Determines, recursively, if all children are not unspecified. | |
1717 | ||
1718 | @param pendingList | |
1719 | Assumes members in this wxVariant list as pending | |
1720 | replacement values. | |
1721 | */ | |
1722 | bool AreAllChildrenSpecified( wxVariant* pendingList = NULL ) const; | |
1723 | ||
1724 | /** Updates composed values of parent non-category properties, recursively. | |
1725 | Returns topmost property updated. | |
1726 | ||
1727 | @remarks | |
1728 | - Must not call SetValue() (as can be called in it). | |
1729 | */ | |
1730 | wxPGProperty* UpdateParentValues(); | |
1731 | ||
1732 | /** Returns true if containing grid uses wxPG_EX_AUTO_UNSPECIFIED_VALUES. | |
1733 | */ | |
1734 | bool UsesAutoUnspecified() const | |
1735 | { | |
1736 | return HasFlag(wxPG_PROP_AUTO_UNSPECIFIED)?true:false; | |
1737 | } | |
1738 | ||
1739 | wxBitmap* GetValueImage() const | |
1740 | { | |
1741 | return m_valueBitmap; | |
1742 | } | |
1743 | ||
1744 | wxVariant GetAttribute( const wxString& name ) const; | |
1745 | ||
1746 | /** | |
1747 | Returns named attribute, as string, if found. | |
1748 | ||
1749 | Otherwise defVal is returned. | |
1750 | */ | |
1751 | wxString GetAttribute( const wxString& name, const wxString& defVal ) const; | |
1752 | ||
1753 | /** | |
1754 | Returns named attribute, as long, if found. | |
1755 | ||
1756 | Otherwise defVal is returned. | |
1757 | */ | |
1758 | long GetAttributeAsLong( const wxString& name, long defVal ) const; | |
1759 | ||
1760 | /** | |
1761 | Returns named attribute, as double, if found. | |
1762 | ||
1763 | Otherwise defVal is returned. | |
1764 | */ | |
1765 | double GetAttributeAsDouble( const wxString& name, double defVal ) const; | |
1766 | ||
1767 | unsigned int GetDepth() const { return (unsigned int)m_depth; } | |
1768 | ||
1769 | /** Gets flags as a'|' delimited string. Note that flag names are not | |
1770 | prepended with 'wxPG_PROP_'. | |
1771 | @param flagsMask | |
1772 | String will only be made to include flags combined by this parameter. | |
1773 | */ | |
1774 | wxString GetFlagsAsString( FlagType flagsMask ) const; | |
1775 | ||
1776 | /** Returns position in parent's array. */ | |
1777 | unsigned int GetIndexInParent() const | |
1778 | { | |
1779 | return (unsigned int)m_arrIndex; | |
1780 | } | |
1781 | ||
1782 | /** Hides or reveals the property. | |
1783 | @param hide | |
1784 | true for hide, false for reveal. | |
1785 | @param flags | |
1786 | By default changes are applied recursively. Set this paramter | |
1787 | wxPG_DONT_RECURSE to prevent this. | |
1788 | */ | |
1789 | inline bool Hide( bool hide, int flags = wxPG_RECURSE ); | |
1790 | ||
1791 | bool IsExpanded() const | |
1792 | { return (!(m_flags & wxPG_PROP_COLLAPSED) && GetChildCount()); } | |
1793 | ||
1794 | /** Returns true if all parents expanded. | |
1795 | */ | |
1796 | bool IsVisible() const; | |
1797 | ||
1798 | bool IsEnabled() const { return !(m_flags & wxPG_PROP_DISABLED); } | |
1799 | ||
1800 | /** If property's editor is created this forces its recreation. | |
1801 | Useful in SetAttribute etc. Returns true if actually did anything. | |
1802 | */ | |
1803 | bool RecreateEditor(); | |
1804 | ||
1805 | /** If property's editor is active, then update it's value. | |
1806 | */ | |
1807 | void RefreshEditor(); | |
1808 | ||
1809 | /** Sets an attribute for this property. | |
1810 | @param name | |
1811 | Text identifier of attribute. See @ref propgrid_property_attributes. | |
1812 | @param value | |
1813 | Value of attribute. | |
1814 | */ | |
1815 | void SetAttribute( const wxString& name, wxVariant value ); | |
1816 | ||
1817 | void SetAttributes( const wxPGAttributeStorage& attributes ); | |
1818 | ||
1819 | /** | |
1820 | Sets property's background colour. | |
1821 | ||
1822 | @param colour | |
1823 | Background colour to use. | |
1824 | ||
1825 | @param recursively | |
1826 | If @true, children are affected recursively, and any categories | |
1827 | are not. | |
1828 | */ | |
1829 | void SetBackgroundColour( const wxColour& colour, | |
1830 | bool recursively = false ); | |
1831 | ||
1832 | /** | |
1833 | Sets property's text colour. | |
1834 | ||
1835 | @param colour | |
1836 | Text colour to use. | |
1837 | ||
1838 | @param recursively | |
1839 | If @true, children are affected recursively, and any categories | |
1840 | are not. | |
1841 | */ | |
1842 | void SetTextColour( const wxColour& colour, | |
1843 | bool recursively = false ); | |
1844 | ||
1845 | #ifndef SWIG | |
1846 | /** Sets editor for a property. | |
1847 | ||
1848 | @param editor | |
1849 | For builtin editors, use wxPGEditor_X, where X is builtin editor's | |
1850 | name (TextCtrl, Choice, etc. see wxPGEditor documentation for full | |
1851 | list). | |
1852 | ||
1853 | For custom editors, use pointer you received from | |
1854 | wxPropertyGrid::RegisterEditorClass(). | |
1855 | */ | |
1856 | void SetEditor( const wxPGEditor* editor ) | |
1857 | { | |
1858 | m_customEditor = editor; | |
1859 | } | |
1860 | #endif | |
1861 | ||
1862 | /** Sets editor for a property. | |
1863 | */ | |
1864 | inline void SetEditor( const wxString& editorName ); | |
1865 | ||
1866 | /** | |
1867 | Sets cell information for given column. | |
1868 | */ | |
1869 | void SetCell( int column, const wxPGCell& cell ); | |
1870 | ||
1871 | /** Sets common value selected for this property. -1 for none. | |
1872 | */ | |
1873 | void SetCommonValue( int commonValue ) | |
1874 | { | |
1875 | m_commonValue = commonValue; | |
1876 | } | |
1877 | ||
1878 | /** Sets flags from a '|' delimited string. Note that flag names are not | |
1879 | prepended with 'wxPG_PROP_'. | |
1880 | */ | |
1881 | void SetFlagsFromString( const wxString& str ); | |
1882 | ||
1883 | /** Sets property's "is it modified?" flag. Affects children recursively. | |
1884 | */ | |
1885 | void SetModifiedStatus( bool modified ) | |
1886 | { | |
1887 | SetFlagRecursively(wxPG_PROP_MODIFIED, modified); | |
1888 | } | |
1889 | ||
1890 | /** Call in OnEvent(), OnButtonClick() etc. to change the property value | |
1891 | based on user input. | |
1892 | ||
1893 | @remarks | |
1894 | This method is const since it doesn't actually modify value, but posts | |
1895 | given variant as pending value, stored in wxPropertyGrid. | |
1896 | */ | |
1897 | void SetValueInEvent( wxVariant value ) const; | |
1898 | ||
1899 | /** | |
1900 | Call this to set value of the property. | |
1901 | ||
1902 | Unlike methods in wxPropertyGrid, this does not automatically update | |
1903 | the display. | |
1904 | ||
1905 | @remarks | |
1906 | Use wxPropertyGrid::ChangePropertyValue() instead if you need to run | |
1907 | through validation process and send property change event. | |
1908 | ||
1909 | If you need to change property value in event, based on user input, use | |
1910 | SetValueInEvent() instead. | |
1911 | ||
1912 | @param pList | |
1913 | Pointer to list variant that contains child values. Used to indicate | |
1914 | which children should be marked as modified. | |
1915 | @param flags | |
1916 | Various flags (for instance, wxPG_SETVAL_REFRESH_EDITOR). | |
1917 | */ | |
1918 | void SetValue( wxVariant value, wxVariant* pList = NULL, int flags = 0 ); | |
1919 | ||
1920 | /** Set wxBitmap in front of the value. This bitmap may be ignored | |
1921 | by custom cell renderers. | |
1922 | */ | |
1923 | void SetValueImage( wxBitmap& bmp ); | |
1924 | ||
1925 | /** If property has choices and they are not yet exclusive, new such copy | |
1926 | of them will be created. | |
1927 | */ | |
1928 | void SetChoicesExclusive() | |
1929 | { | |
1930 | m_choices.SetExclusive(); | |
1931 | } | |
1932 | ||
1933 | /** Sets selected choice and changes property value. | |
1934 | ||
1935 | Tries to retain value type, although currently if it is not string, | |
1936 | then it is forced to integer. | |
1937 | */ | |
1938 | void SetChoiceSelection( int newValue ); | |
1939 | ||
1940 | void SetExpanded( bool expanded ) | |
1941 | { | |
1942 | if ( !expanded ) m_flags |= wxPG_PROP_COLLAPSED; | |
1943 | else m_flags &= ~wxPG_PROP_COLLAPSED; | |
1944 | } | |
1945 | ||
1946 | void SetFlag( FlagType flag ) { m_flags |= flag; } | |
1947 | ||
1948 | void SetFlagRecursively( FlagType flag, bool set ); | |
1949 | ||
1950 | void SetHelpString( const wxString& helpString ) | |
1951 | { | |
1952 | m_helpString = helpString; | |
1953 | } | |
1954 | ||
1955 | void SetLabel( const wxString& label ) { m_label = label; } | |
1956 | ||
1957 | inline void SetName( const wxString& newName ); | |
1958 | ||
1959 | /** | |
1960 | Changes what sort of parent this property is for its children. | |
1961 | ||
1962 | @param flag | |
1963 | Use one of the following values: wxPG_PROP_MISC_PARENT (for generic | |
1964 | parents), wxPG_PROP_CATEGORY (for categories), or | |
1965 | wxPG_PROP_AGGREGATE (for derived property classes with private | |
1966 | children). | |
1967 | ||
1968 | @remarks You only need to call this if you use AddChild() to add | |
1969 | child properties. Adding properties with | |
1970 | wxPropertyGridInterface::Insert() or | |
1971 | wxPropertyGridInterface::AppendIn() will automatically set | |
1972 | property to use wxPG_PROP_MISC_PARENT style. | |
1973 | */ | |
1974 | void SetParentalType( int flag ) | |
1975 | { | |
1976 | m_flags &= ~(wxPG_PROP_PROPERTY|wxPG_PROP_PARENTAL_FLAGS); | |
1977 | m_flags |= flag; | |
1978 | } | |
1979 | ||
1980 | void SetValueToUnspecified() | |
1981 | { | |
1982 | wxVariant val; // Create NULL variant | |
1983 | SetValue(val); | |
1984 | } | |
1985 | ||
1986 | #if wxUSE_VALIDATORS | |
1987 | /** Sets wxValidator for a property*/ | |
1988 | void SetValidator( const wxValidator& validator ) | |
1989 | { | |
1990 | m_validator = wxDynamicCast(validator.Clone(),wxValidator); | |
1991 | } | |
1992 | ||
1993 | /** Gets assignable version of property's validator. */ | |
1994 | wxValidator* GetValidator() const | |
1995 | { | |
1996 | if ( m_validator ) | |
1997 | return m_validator; | |
1998 | return DoGetValidator(); | |
1999 | } | |
2000 | #endif // #if wxUSE_VALIDATORS | |
2001 | ||
2002 | #ifndef SWIG | |
2003 | /** Returns client data (void*) of a property. | |
2004 | */ | |
2005 | void* GetClientData() const | |
2006 | { | |
2007 | return m_clientData; | |
2008 | } | |
2009 | ||
2010 | /** Sets client data (void*) of a property. | |
2011 | @remarks | |
2012 | This untyped client data has to be deleted manually. | |
2013 | */ | |
2014 | void SetClientData( void* clientData ) | |
2015 | { | |
2016 | m_clientData = clientData; | |
2017 | } | |
2018 | ||
2019 | /** Returns client object of a property. | |
2020 | */ | |
2021 | void SetClientObject(wxClientData* clientObject) | |
2022 | { | |
2023 | delete m_clientObject; | |
2024 | m_clientObject = clientObject; | |
2025 | } | |
2026 | ||
2027 | /** Sets managed client object of a property. | |
2028 | */ | |
2029 | wxClientData *GetClientObject() const { return m_clientObject; } | |
2030 | #endif | |
2031 | ||
2032 | /** Sets new set of choices for property. | |
2033 | ||
2034 | @remarks | |
2035 | This operation clears the property value. | |
2036 | */ | |
2037 | bool SetChoices( wxPGChoices& choices ); | |
2038 | ||
2039 | /** Set max length of text in text editor. | |
2040 | */ | |
2041 | inline bool SetMaxLength( int maxLen ); | |
2042 | ||
2043 | /** Call with 'false' in OnSetValue to cancel value changes after all | |
2044 | (ie. cancel 'true' returned by StringToValue() or IntToValue()). | |
2045 | */ | |
2046 | void SetWasModified( bool set = true ) | |
2047 | { | |
2048 | if ( set ) m_flags |= wxPG_PROP_WAS_MODIFIED; | |
2049 | else m_flags &= ~wxPG_PROP_WAS_MODIFIED; | |
2050 | } | |
2051 | ||
2052 | const wxString& GetHelpString() const | |
2053 | { | |
2054 | return m_helpString; | |
2055 | } | |
2056 | ||
2057 | void ClearFlag( FlagType flag ) { m_flags &= ~(flag); } | |
2058 | ||
2059 | // Use, for example, to detect if item is inside collapsed section. | |
2060 | bool IsSomeParent( wxPGProperty* candidate_parent ) const; | |
2061 | ||
2062 | /** | |
2063 | Adapts list variant into proper value using consecutive | |
2064 | ChildChanged-calls. | |
2065 | */ | |
2066 | void AdaptListToValue( wxVariant& list, wxVariant* value ) const; | |
2067 | ||
2068 | /** | |
2069 | Adds a child property. If you use this instead of | |
2070 | wxPropertyGridInterface::Insert() or | |
2071 | wxPropertyGridInterface::AppendIn(), then you must set up | |
2072 | property's parental type before making the call. To do this, | |
2073 | call property's SetParentalType() function with either | |
2074 | wxPG_PROP_MISC_PARENT (normal, public children) or with | |
2075 | wxPG_PROP_AGGREGATE (private children for subclassed property). | |
2076 | For instance: | |
2077 | ||
2078 | @code | |
2079 | wxPGProperty* prop = new wxStringProperty(wxS("Property")); | |
2080 | prop->SetParentalType(wxPG_PROP_MISC_PARENT); | |
2081 | wxPGProperty* prop2 = new wxStringProperty(wxS("Property2")); | |
2082 | prop->AddChild(prop2); | |
2083 | @endcode | |
2084 | */ | |
2085 | void AddChild( wxPGProperty* prop ); | |
2086 | ||
2087 | /** Returns height of children, recursively, and | |
2088 | by taking expanded/collapsed status into account. | |
2089 | ||
2090 | iMax is used when finding property y-positions. | |
2091 | */ | |
2092 | int GetChildrenHeight( int lh, int iMax = -1 ) const; | |
2093 | ||
2094 | /** Returns number of child properties */ | |
2095 | unsigned int GetChildCount() const | |
2096 | { | |
2097 | return (unsigned int) m_children.size(); | |
2098 | } | |
2099 | ||
2100 | /** Returns sub-property at index i. */ | |
2101 | wxPGProperty* Item( unsigned int i ) const | |
2102 | { return m_children[i]; } | |
2103 | ||
2104 | /** Returns last sub-property. | |
2105 | */ | |
2106 | wxPGProperty* Last() const { return m_children.back(); } | |
2107 | ||
2108 | /** Returns index of given child property. */ | |
2109 | int Index( const wxPGProperty* p ) const; | |
2110 | ||
2111 | // Puts correct indexes to children | |
2112 | void FixIndicesOfChildren( unsigned int starthere = 0 ); | |
2113 | ||
2114 | #ifndef SWIG | |
2115 | // Returns wxPropertyGridPageState in which this property resides. | |
2116 | wxPropertyGridPageState* GetParentState() const { return m_parentState; } | |
2117 | #endif | |
2118 | ||
2119 | wxPGProperty* GetItemAtY( unsigned int y, | |
2120 | unsigned int lh, | |
2121 | unsigned int* nextItemY ) const; | |
2122 | ||
2123 | /** Returns (direct) child property with given name (or NULL if not found). | |
2124 | */ | |
2125 | wxPGProperty* GetPropertyByName( const wxString& name ) const; | |
2126 | ||
2127 | #ifdef SWIG | |
2128 | %extend { | |
2129 | DocStr(GetClientData, | |
2130 | "Returns the client data object for a property", ""); | |
2131 | PyObject* GetClientData() { | |
2132 | wxPyClientData* data = (wxPyClientData*)self->GetClientObject(); | |
2133 | if (data) { | |
2134 | Py_INCREF(data->m_obj); | |
2135 | return data->m_obj; | |
2136 | } else { | |
2137 | Py_INCREF(Py_None); | |
2138 | return Py_None; | |
2139 | } | |
2140 | } | |
2141 | ||
2142 | DocStr(SetClientData, | |
2143 | "Associate the given client data.", ""); | |
2144 | void SetClientData(PyObject* clientData) { | |
2145 | wxPyClientData* data = new wxPyClientData(clientData); | |
2146 | self->SetClientObject(data); | |
2147 | } | |
2148 | } | |
2149 | %pythoncode { | |
2150 | GetClientObject = GetClientData | |
2151 | SetClientObject = SetClientData | |
2152 | } | |
2153 | #endif | |
2154 | ||
2155 | #ifndef SWIG | |
2156 | ||
2157 | // Returns various display-related information for given column | |
2158 | void GetDisplayInfo( unsigned int column, | |
2159 | int choiceIndex, | |
2160 | int flags, | |
2161 | wxString* pString, | |
2162 | const wxPGCell** pCell ); | |
2163 | ||
2164 | static wxString* sm_wxPG_LABEL; | |
2165 | ||
2166 | /** This member is public so scripting language bindings | |
2167 | wrapper code can access it freely. | |
2168 | */ | |
2169 | void* m_clientData; | |
2170 | ||
2171 | protected: | |
2172 | ||
2173 | /** | |
2174 | Sets property cell in fashion that reduces number of exclusive | |
2175 | copies of cell data. Used when setting, for instance, same | |
2176 | background colour for a number of properties. | |
2177 | ||
2178 | @param firstCol | |
2179 | First column to affect. | |
2180 | ||
2181 | @param lastCol | |
2182 | Last column to affect. | |
2183 | ||
2184 | @param preparedCell | |
2185 | Pre-prepared cell that is used for those which cell data | |
2186 | before this matched unmodCellData. | |
2187 | ||
2188 | @param srcData | |
2189 | If unmodCellData did not match, valid cell data from this | |
2190 | is merged into cell (usually generating new exclusive copy | |
2191 | of cell's data). | |
2192 | ||
2193 | @param unmodCellData | |
2194 | If cell's cell data matches this, its cell is now set to | |
2195 | preparedCell. | |
2196 | ||
2197 | @param ignoreWithFlags | |
2198 | Properties with any one of these flags are skipped. | |
2199 | ||
2200 | @param recursively | |
2201 | If @true, apply this operation recursively in child properties. | |
2202 | */ | |
2203 | void AdaptiveSetCell( unsigned int firstCol, | |
2204 | unsigned int lastCol, | |
2205 | const wxPGCell& preparedCell, | |
2206 | const wxPGCell& srcData, | |
2207 | wxPGCellData* unmodCellData, | |
2208 | FlagType ignoreWithFlags, | |
2209 | bool recursively ); | |
2210 | ||
2211 | /** | |
2212 | Makes sure m_cells has size of column+1 (or more). | |
2213 | */ | |
2214 | void EnsureCells( unsigned int column ); | |
2215 | ||
2216 | /** Returns (direct) child property with given name (or NULL if not found), | |
2217 | with hint index. | |
2218 | ||
2219 | @param hintIndex | |
2220 | Start looking for the child at this index. | |
2221 | ||
2222 | @remarks | |
2223 | Does not support scope (ie. Parent.Child notation). | |
2224 | */ | |
2225 | wxPGProperty* GetPropertyByNameWH( const wxString& name, | |
2226 | unsigned int hintIndex ) const; | |
2227 | ||
2228 | /** This is used by Insert etc. */ | |
2229 | void AddChild2( wxPGProperty* prop, | |
2230 | int index = -1, | |
2231 | bool correct_mode = true ); | |
2232 | ||
2233 | void DoGenerateComposedValue( wxString& text, | |
2234 | int argFlags = wxPG_VALUE_IS_CURRENT, | |
2235 | const wxVariantList* valueOverrides = NULL, | |
2236 | wxPGHashMapS2S* childResults = NULL ) const; | |
2237 | ||
2238 | void DoSetName(const wxString& str) { m_name = str; } | |
2239 | ||
2240 | /** Deletes all sub-properties. */ | |
2241 | void Empty(); | |
2242 | ||
2243 | void InitAfterAdded( wxPropertyGridPageState* pageState, | |
2244 | wxPropertyGrid* propgrid ); | |
2245 | ||
2246 | // Removes child property with given pointer. Does not delete it. | |
2247 | void RemoveChild( wxPGProperty* p ); | |
2248 | ||
2249 | void SetParentState( wxPropertyGridPageState* pstate ) | |
2250 | { m_parentState = pstate; } | |
2251 | ||
2252 | // Call after fixed sub-properties added/removed after creation. | |
2253 | // if oldSelInd >= 0 and < new max items, then selection is | |
2254 | // moved to it. | |
2255 | void SubPropsChanged( int oldSelInd = -1 ); | |
2256 | ||
2257 | int GetY2( int lh ) const; | |
2258 | ||
2259 | wxString m_label; | |
2260 | wxString m_name; | |
2261 | wxPGProperty* m_parent; | |
2262 | wxPropertyGridPageState* m_parentState; | |
2263 | ||
2264 | wxClientData* m_clientObject; | |
2265 | ||
2266 | // Overrides editor returned by property class | |
2267 | const wxPGEditor* m_customEditor; | |
2268 | #if wxUSE_VALIDATORS | |
2269 | // Editor is going to get this validator | |
2270 | wxValidator* m_validator; | |
2271 | #endif | |
2272 | // Show this in front of the value | |
2273 | // | |
2274 | // TODO: Can bitmap be implemented with wxPGCell? | |
2275 | wxBitmap* m_valueBitmap; | |
2276 | ||
2277 | wxVariant m_value; | |
2278 | wxPGAttributeStorage m_attributes; | |
2279 | wxArrayPGProperty m_children; | |
2280 | ||
2281 | // Extended cell information | |
2282 | wxVector<wxPGCell> m_cells; | |
2283 | ||
2284 | // Choices shown in drop-down list of editor control. | |
2285 | wxPGChoices m_choices; | |
2286 | ||
2287 | // Help shown in statusbar or help box. | |
2288 | wxString m_helpString; | |
2289 | ||
2290 | // Index in parent's property array. | |
2291 | unsigned int m_arrIndex; | |
2292 | ||
2293 | // If not -1, then overrides m_value | |
2294 | int m_commonValue; | |
2295 | ||
2296 | FlagType m_flags; | |
2297 | ||
2298 | // Maximum length (mainly for string properties). Could be in some sort of | |
2299 | // wxBaseStringProperty, but currently, for maximum flexibility and | |
2300 | // compatibility, we'll stick it here. Anyway, we had 3 excess bytes to use | |
2301 | // so short int will fit in just fine. | |
2302 | short m_maxLen; | |
2303 | ||
2304 | // Root has 0, categories etc. at that level 1, etc. | |
2305 | unsigned char m_depth; | |
2306 | ||
2307 | // m_depthBgCol indicates width of background colour between margin and item | |
2308 | // (essentially this is category's depth, if none then equals m_depth). | |
2309 | unsigned char m_depthBgCol; | |
2310 | ||
2311 | private: | |
2312 | // Called in constructors. | |
2313 | void Init(); | |
2314 | void Init( const wxString& label, const wxString& name ); | |
2315 | #endif // #ifndef SWIG | |
2316 | }; | |
2317 | ||
2318 | // ----------------------------------------------------------------------- | |
2319 | ||
2320 | // | |
2321 | // Property class declaration helper macros | |
2322 | // (wxPGRootPropertyClass and wxPropertyCategory require this). | |
2323 | // | |
2324 | ||
2325 | #define WX_PG_DECLARE_DOGETEDITORCLASS \ | |
2326 | virtual const wxPGEditor* DoGetEditorClass() const; | |
2327 | ||
2328 | #ifndef SWIG | |
2329 | #define WX_PG_DECLARE_PROPERTY_CLASS(CLASSNAME) \ | |
2330 | public: \ | |
2331 | DECLARE_DYNAMIC_CLASS(CLASSNAME) \ | |
2332 | WX_PG_DECLARE_DOGETEDITORCLASS \ | |
2333 | private: | |
2334 | #else | |
2335 | #define WX_PG_DECLARE_PROPERTY_CLASS(CLASSNAME) | |
2336 | #endif | |
2337 | ||
2338 | // Implements sans constructor function. Also, first arg is class name, not | |
2339 | // property name. | |
2340 | #define WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(PROPNAME,T,EDITOR) \ | |
2341 | const wxPGEditor* PROPNAME::DoGetEditorClass() const \ | |
2342 | { \ | |
2343 | return wxPGEditor_##EDITOR; \ | |
2344 | } | |
2345 | ||
2346 | // ----------------------------------------------------------------------- | |
2347 | ||
2348 | #ifndef SWIG | |
2349 | ||
2350 | /** @class wxPGRootProperty | |
2351 | @ingroup classes | |
2352 | Root parent property. | |
2353 | */ | |
2354 | class WXDLLIMPEXP_PROPGRID wxPGRootProperty : public wxPGProperty | |
2355 | { | |
2356 | public: | |
2357 | WX_PG_DECLARE_PROPERTY_CLASS(wxPGRootProperty) | |
2358 | public: | |
2359 | ||
2360 | /** Constructor. */ | |
2361 | wxPGRootProperty(); | |
2362 | virtual ~wxPGRootProperty(); | |
2363 | ||
2364 | virtual bool StringToValue( wxVariant&, const wxString&, int ) const | |
2365 | { | |
2366 | return false; | |
2367 | } | |
2368 | ||
2369 | protected: | |
2370 | }; | |
2371 | ||
2372 | // ----------------------------------------------------------------------- | |
2373 | ||
2374 | /** @class wxPropertyCategory | |
2375 | @ingroup classes | |
2376 | Category (caption) property. | |
2377 | */ | |
2378 | class WXDLLIMPEXP_PROPGRID wxPropertyCategory : public wxPGProperty | |
2379 | { | |
2380 | friend class wxPropertyGrid; | |
2381 | friend class wxPropertyGridPageState; | |
2382 | WX_PG_DECLARE_PROPERTY_CLASS(wxPropertyCategory) | |
2383 | public: | |
2384 | ||
2385 | /** Default constructor is only used in special cases. */ | |
2386 | wxPropertyCategory(); | |
2387 | ||
2388 | wxPropertyCategory( const wxString& label, | |
2389 | const wxString& name = wxPG_LABEL ); | |
2390 | ~wxPropertyCategory(); | |
2391 | ||
2392 | int GetTextExtent( const wxWindow* wnd, const wxFont& font ) const; | |
2393 | ||
2394 | virtual wxString ValueToString( wxVariant& value, int argFlags ) const; | |
2395 | ||
2396 | protected: | |
2397 | void SetTextColIndex( unsigned int colInd ) | |
2398 | { m_capFgColIndex = (wxByte) colInd; } | |
2399 | unsigned int GetTextColIndex() const | |
2400 | { return (unsigned int) m_capFgColIndex; } | |
2401 | ||
2402 | void CalculateTextExtent( wxWindow* wnd, const wxFont& font ); | |
2403 | ||
2404 | int m_textExtent; // pre-calculated length of text | |
2405 | wxByte m_capFgColIndex; // caption text colour index | |
2406 | ||
2407 | private: | |
2408 | void Init(); | |
2409 | }; | |
2410 | ||
2411 | #endif // !SWIG | |
2412 | ||
2413 | // ----------------------------------------------------------------------- | |
2414 | ||
2415 | #endif // wxUSE_PROPGRID | |
2416 | ||
2417 | #endif // _WX_PROPGRID_PROPERTY_H_ |