]> git.saurik.com Git - wxWidgets.git/blame_incremental - include/wx/propgrid/propgrid.h
no changes, just remove #if'd out code
[wxWidgets.git] / include / wx / propgrid / propgrid.h
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: wx/propgrid/propgrid.h
3// Purpose: wxPropertyGrid
4// Author: Jaakko Salli
5// Modified by:
6// Created: 2004-09-25
7// RCS-ID: $Id$
8// Copyright: (c) Jaakko Salli
9// Licence: wxWindows license
10/////////////////////////////////////////////////////////////////////////////
11
12#ifndef _WX_PROPGRID_PROPGRID_H_
13#define _WX_PROPGRID_PROPGRID_H_
14
15#if wxUSE_PROPGRID
16
17#include "wx/dcclient.h"
18#include "wx/scrolwin.h"
19#include "wx/tooltip.h"
20#include "wx/datetime.h"
21
22#include "wx/propgrid/property.h"
23#include "wx/propgrid/propgridiface.h"
24
25
26#ifndef SWIG
27extern WXDLLIMPEXP_DATA_PROPGRID(const char) wxPropertyGridNameStr[];
28#endif
29
30class wxPGComboBox;
31
32// -----------------------------------------------------------------------
33// Global variables
34// -----------------------------------------------------------------------
35
36#ifndef SWIG
37
38// This is required for sharing common global variables.
39class WXDLLIMPEXP_PROPGRID wxPGGlobalVarsClass
40{
41public:
42
43 wxPGGlobalVarsClass();
44 ~wxPGGlobalVarsClass();
45
46 // Used by advprops, but here to make things easier.
47 wxString m_pDefaultImageWildcard;
48
49 // Map of editor class instances (keys are name string).
50 wxPGHashMapS2P m_mapEditorClasses;
51
52#if wxUSE_VALIDATORS
53 wxVector<wxValidator*> m_arrValidators; // These wxValidators need to be freed
54#endif
55
56 wxPGHashMapS2P m_dictPropertyClassInfo; // PropertyName -> ClassInfo
57
58 wxPGChoices* m_fontFamilyChoices;
59
60 // Replace with your own to affect all properties using default renderer.
61 wxPGCellRenderer* m_defaultRenderer;
62
63 wxPGChoices m_boolChoices;
64
65 wxVariant m_vEmptyString;
66 wxVariant m_vZero;
67 wxVariant m_vMinusOne;
68 wxVariant m_vTrue;
69 wxVariant m_vFalse;
70
71 // Cached constant strings
72 wxPGCachedString m_strstring;
73 wxPGCachedString m_strlong;
74 wxPGCachedString m_strbool;
75 wxPGCachedString m_strlist;
76
77 wxPGCachedString m_strMin;
78 wxPGCachedString m_strMax;
79 wxPGCachedString m_strUnits;
80 wxPGCachedString m_strInlineHelp;
81
82 // If true then some things are automatically translated
83 bool m_autoGetTranslation;
84
85 // > 0 if errors cannot or should not be shown in statusbar etc.
86 int m_offline;
87
88 int m_extraStyle; // global extra style
89
90 int m_warnings;
91
92 int HasExtraStyle( int style ) const { return (m_extraStyle & style); }
93};
94
95extern WXDLLIMPEXP_PROPGRID wxPGGlobalVarsClass* wxPGGlobalVars;
96
97#define wxPGVariant_EmptyString (wxPGGlobalVars->m_vEmptyString)
98#define wxPGVariant_Zero (wxPGGlobalVars->m_vZero)
99#define wxPGVariant_MinusOne (wxPGGlobalVars->m_vMinusOne)
100#define wxPGVariant_True (wxPGGlobalVars->m_vTrue)
101#define wxPGVariant_False (wxPGGlobalVars->m_vFalse)
102
103#define wxPGVariant_Bool(A) (A?wxPGVariant_True:wxPGVariant_False)
104
105#endif // !SWIG
106
107// -----------------------------------------------------------------------
108
109/** @section propgrid_window_styles wxPropertyGrid Window Styles
110
111 SetWindowStyleFlag method can be used to modify some of these at run-time.
112 @{
113*/
114enum wxPG_WINDOW_STYLES
115{
116
117/** This will cause Sort() automatically after an item is added.
118 When inserting a lot of items in this mode, it may make sense to
119 use Freeze() before operations and Thaw() afterwards to increase
120 performance.
121*/
122wxPG_AUTO_SORT = 0x00000010,
123
124/** Categories are not initially shown (even if added).
125 IMPORTANT NOTE: If you do not plan to use categories, then this
126 style will waste resources.
127 This flag can also be changed using wxPropertyGrid::EnableCategories method.
128*/
129wxPG_HIDE_CATEGORIES = 0x00000020,
130
131/* This style combines non-categoric mode and automatic sorting.
132*/
133wxPG_ALPHABETIC_MODE = (wxPG_HIDE_CATEGORIES|wxPG_AUTO_SORT),
134
135/** Modified values are shown in bold font. Changing this requires Refresh()
136 to show changes.
137*/
138wxPG_BOLD_MODIFIED = 0x00000040,
139
140/** When wxPropertyGrid is resized, splitter moves to the center. This
141 behavior stops once the user manually moves the splitter.
142*/
143wxPG_SPLITTER_AUTO_CENTER = 0x00000080,
144
145/** Display tooltips for cell text that cannot be shown completely. If
146 wxUSE_TOOLTIPS is 0, then this doesn't have any effect.
147*/
148wxPG_TOOLTIPS = 0x00000100,
149
150/** Disables margin and hides all expand/collapse buttons that would appear
151 outside the margin (for sub-properties). Toggling this style automatically
152 expands all collapsed items.
153*/
154wxPG_HIDE_MARGIN = 0x00000200,
155
156/** This style prevents user from moving the splitter.
157*/
158wxPG_STATIC_SPLITTER = 0x00000400,
159
160/** Combination of other styles that make it impossible for user to modify
161 the layout.
162*/
163wxPG_STATIC_LAYOUT = (wxPG_HIDE_MARGIN|wxPG_STATIC_SPLITTER),
164
165/** Disables wxTextCtrl based editors for properties which
166 can be edited in another way.
167
168 Equals calling wxPropertyGrid::LimitPropertyEditing for all added
169 properties.
170*/
171wxPG_LIMITED_EDITING = 0x00000800,
172
173/** wxPropertyGridManager only: Show toolbar for mode and page selection. */
174wxPG_TOOLBAR = 0x00001000,
175
176/** wxPropertyGridManager only: Show adjustable text box showing description
177 or help text, if available, for currently selected property.
178*/
179wxPG_DESCRIPTION = 0x00002000
180
181};
182
183enum wxPG_EX_WINDOW_STYLES
184{
185
186/**
187 NOTE: wxPG_EX_xxx are extra window styles and must be set using
188 SetExtraStyle() member function.
189
190 Speeds up switching to wxPG_HIDE_CATEGORIES mode. Initially, if
191 wxPG_HIDE_CATEGORIES is not defined, the non-categorized data storage is
192 not activated, and switching the mode first time becomes somewhat slower.
193 wxPG_EX_INIT_NOCAT activates the non-categorized data storage right away.
194 IMPORTANT NOTE: If you do plan not switching to non-categoric mode, or if
195 you don't plan to use categories at all, then using this style will result
196 in waste of resources.
197
198*/
199wxPG_EX_INIT_NOCAT = 0x00001000,
200
201/** Extended window style that sets wxPropertyGridManager toolbar to not
202 use flat style.
203*/
204wxPG_EX_NO_FLAT_TOOLBAR = 0x00002000,
205
206/** Shows alphabetic/categoric mode buttons from toolbar.
207*/
208wxPG_EX_MODE_BUTTONS = 0x00008000,
209
210/** Show property help strings as tool tips instead as text on the status bar.
211 You can set the help strings using SetPropertyHelpString member function.
212*/
213wxPG_EX_HELP_AS_TOOLTIPS = 0x00010000,
214
215/** Prevent TAB from focusing to wxButtons. This behavior was default
216 in version 1.2.0 and earlier.
217 NOTE! Tabbing to button doesn't work yet. Problem seems to be that on wxMSW
218 atleast the button doesn't properly propagate key events (yes, I'm using
219 wxWANTS_CHARS).
220*/
221//wxPG_EX_NO_TAB_TO_BUTTON = 0x00020000,
222
223/** Allows relying on native double-buffering.
224*/
225wxPG_EX_NATIVE_DOUBLE_BUFFERING = 0x00080000,
226
227/** Set this style to let user have ability to set values of properties to
228 unspecified state. Same as setting wxPG_PROP_AUTO_UNSPECIFIED for
229 all properties.
230*/
231wxPG_EX_AUTO_UNSPECIFIED_VALUES = 0x00200000,
232
233/**
234 If this style is used, built-in attributes (such as wxPG_FLOAT_PRECISION
235 and wxPG_STRING_PASSWORD) are not stored into property's attribute storage
236 (thus they are not readable).
237
238 Note that this option is global, and applies to all wxPG property
239 containers.
240*/
241wxPG_EX_WRITEONLY_BUILTIN_ATTRIBUTES = 0x00400000,
242
243/** Hides page selection buttons from toolbar.
244*/
245wxPG_EX_HIDE_PAGE_BUTTONS = 0x01000000
246
247};
248
249/** Combines various styles.
250*/
251#define wxPG_DEFAULT_STYLE (0)
252
253/** Combines various styles.
254*/
255#define wxPGMAN_DEFAULT_STYLE (0)
256
257/** @}
258*/
259
260// -----------------------------------------------------------------------
261
262//
263// Ids for sub-controls
264// NB: It should not matter what these are.
265#define wxPG_SUBID1 2
266#define wxPG_SUBID2 3
267#define wxPG_SUBID_TEMP1 4
268
269// -----------------------------------------------------------------------
270
271/** @class wxPGCommonValue
272
273 wxPropertyGrid stores information about common values in these
274 records.
275
276 NB: Common value feature is not complete, and thus not mentioned in
277 documentation.
278*/
279class WXDLLIMPEXP_PROPGRID wxPGCommonValue
280{
281public:
282
283 wxPGCommonValue( const wxString& label, wxPGCellRenderer* renderer )
284 {
285 m_label = label;
286 m_renderer = renderer;
287 renderer->IncRef();
288 }
289 virtual ~wxPGCommonValue()
290 {
291 m_renderer->DecRef();
292 }
293
294 virtual wxString GetEditableText() const { return m_label; }
295 const wxString& GetLabel() const { return m_label; }
296 wxPGCellRenderer* GetRenderer() const { return m_renderer; }
297
298protected:
299 wxString m_label;
300 wxPGCellRenderer* m_renderer;
301};
302
303// -----------------------------------------------------------------------
304
305/** @section propgrid_vfbflags wxPropertyGrid Validation Failure Behavior Flags
306 @{
307*/
308
309enum wxPG_VALIDATION_FAILURE_BEHAVIOR_FLAGS
310{
311
312/** Prevents user from leaving property unless value is valid. If this
313 behavior flag is not used, then value change is instead cancelled.
314*/
315wxPG_VFB_STAY_IN_PROPERTY = 0x01,
316
317/** Calls wxBell() on validation failure.
318*/
319wxPG_VFB_BEEP = 0x02,
320
321/** Cell with invalid value will be marked (with red colour).
322*/
323wxPG_VFB_MARK_CELL = 0x04,
324
325/** Display customizable text message explaining the situation.
326*/
327wxPG_VFB_SHOW_MESSAGE = 0x08,
328
329/** Defaults. */
330wxPG_VFB_DEFAULT = wxPG_VFB_STAY_IN_PROPERTY|wxPG_VFB_BEEP,
331
332/** Only used internally. */
333wxPG_VFB_UNDEFINED = 0x80
334
335};
336
337/** @}
338*/
339
340typedef wxByte wxPGVFBFlags;
341
342/**
343 wxPGValidationInfo
344
345 Used to convey validation information to and from functions that
346 actually perform validation. Mostly used in custom property
347 classes.
348*/
349class WXDLLIMPEXP_PROPGRID wxPGValidationInfo
350{
351 friend class wxPropertyGrid;
352public:
353 /**
354 @return Returns failure behavior which is a combination of
355 @ref propgrid_vfbflags.
356 */
357 wxPGVFBFlags GetFailureBehavior() const
358 { return m_failureBehavior; }
359
360 /**
361 Returns current failure message.
362 */
363 const wxString& GetFailureMessage() const
364 { return m_failureMessage; }
365
366 /**
367 Returns reference to pending value.
368 */
369 const wxVariant& GetValue() const
370 {
371 wxASSERT(m_pValue);
372 return *m_pValue;
373 }
374
375 /** Set validation failure behavior
376
377 @param failureBehavior
378 Mixture of @ref propgrid_vfbflags.
379 */
380 void SetFailureBehavior(wxPGVFBFlags failureBehavior)
381 { m_failureBehavior = failureBehavior; }
382
383 /**
384 Set current failure message.
385 */
386 void SetFailureMessage(const wxString& message)
387 { m_failureMessage = message; }
388
389private:
390 /** Value to be validated.
391 */
392 wxVariant* m_pValue;
393
394 /** Message displayed on validation failure.
395 */
396 wxString m_failureMessage;
397
398 /** Validation failure behavior. Use wxPG_VFB_XXX flags.
399 */
400 wxPGVFBFlags m_failureBehavior;
401};
402
403// -----------------------------------------------------------------------
404
405/** @section propgrid_pgactions wxPropertyGrid Action Identifiers
406
407 These are used with wxPropertyGrid::AddActionTrigger() and
408 wxPropertyGrid::ClearActionTriggers().
409 @{
410*/
411
412enum wxPG_KEYBOARD_ACTIONS
413{
414 wxPG_ACTION_INVALID = 0,
415 wxPG_ACTION_NEXT_PROPERTY,
416 wxPG_ACTION_PREV_PROPERTY,
417 wxPG_ACTION_EXPAND_PROPERTY,
418 wxPG_ACTION_COLLAPSE_PROPERTY,
419 wxPG_ACTION_CANCEL_EDIT,
420 wxPG_ACTION_PRESS_BUTTON, // Causes editor button (if any) to be pressed
421 wxPG_ACTION_MAX
422};
423
424/** @}
425*/
426
427// -----------------------------------------------------------------------
428
429
430// wxPropertyGrid::DoSelectProperty flags (selFlags)
431
432// Focuses to created editor
433#define wxPG_SEL_FOCUS 0x01
434// Forces deletion and recreation of editor
435#define wxPG_SEL_FORCE 0x02
436// For example, doesn't cause EnsureVisible
437#define wxPG_SEL_NONVISIBLE 0x04
438// Do not validate editor's value before selecting
439#define wxPG_SEL_NOVALIDATE 0x08
440// Property being deselected is about to be deleted
441#define wxPG_SEL_DELETING 0x10
442// Property's values was set to unspecified by the user
443#define wxPG_SEL_SETUNSPEC 0x20
444// Property's event handler changed the value
445#define wxPG_SEL_DIALOGVAL 0x40
446
447
448// -----------------------------------------------------------------------
449
450#ifndef SWIG
451
452// Internal flags
453#define wxPG_FL_INITIALIZED 0x0001
454// Set when creating editor controls if it was clicked on.
455#define wxPG_FL_ACTIVATION_BY_CLICK 0x0002
456#define wxPG_FL_DONT_CENTER_SPLITTER 0x0004
457#define wxPG_FL_FOCUSED 0x0008
458#define wxPG_FL_MOUSE_CAPTURED 0x0010
459#define wxPG_FL_MOUSE_INSIDE 0x0020
460#define wxPG_FL_VALUE_MODIFIED 0x0040
461// don't clear background of m_wndEditor
462#define wxPG_FL_PRIMARY_FILLS_ENTIRE 0x0080
463// currently active editor uses custom image
464#define wxPG_FL_CUR_USES_CUSTOM_IMAGE 0x0100
465// cell colours override selection colours for selected cell
466#define wxPG_FL_CELL_OVERRIDES_SEL 0x0200
467#define wxPG_FL_SCROLLED 0x0400
468// set when all added/inserted properties get hideable flag
469#define wxPG_FL_ADDING_HIDEABLES 0x0800
470// Disables showing help strings on statusbar.
471#define wxPG_FL_NOSTATUSBARHELP 0x1000
472// Marks that we created the state, so we have to destroy it too.
473#define wxPG_FL_CREATEDSTATE 0x2000
474// Set if scrollbar's existence was detected in last onresize.
475#define wxPG_FL_SCROLLBAR_DETECTED 0x4000
476// Set if wxPGMan requires redrawing of description text box.
477#define wxPG_FL_DESC_REFRESH_REQUIRED 0x8000
478// Set if contained in wxPropertyGridManager
479#define wxPG_FL_IN_MANAGER 0x00020000
480// Set after wxPropertyGrid is shown in its initial good size
481#define wxPG_FL_GOOD_SIZE_SET 0x00040000
482// Set when in SelectProperty.
483#define wxPG_FL_IN_SELECT_PROPERTY 0x00100000
484// Set when help string is shown in status bar
485#define wxPG_FL_STRING_IN_STATUSBAR 0x00200000
486// Splitter position has been custom-set by the user
487#define wxPG_FL_SPLITTER_PRE_SET 0x00400000
488// Validation failed. Clear on modify event.
489#define wxPG_FL_VALIDATION_FAILED 0x00800000
490// Auto sort is enabled (for categorized mode)
491#define wxPG_FL_CATMODE_AUTO_SORT 0x01000000
492// Set after page has been inserted to manager
493#define wxPG_MAN_FL_PAGE_INSERTED 0x02000000
494// Active editor control is abnormally large
495#define wxPG_FL_ABNORMAL_EDITOR 0x04000000
496// Recursion guard for HandleCustomEditorEvent
497#define wxPG_FL_IN_HANDLECUSTOMEDITOREVENT 0x08000000
498#define wxPG_FL_VALUE_CHANGE_IN_EVENT 0x10000000
499// Editor control width should not change on resize
500#define wxPG_FL_FIXED_WIDTH_EDITOR 0x20000000
501// Width of panel can be different than width of grid
502#define wxPG_FL_HAS_VIRTUAL_WIDTH 0x40000000
503// Prevents RecalculateVirtualSize re-entrancy
504#define wxPG_FL_RECALCULATING_VIRTUAL_SIZE 0x80000000
505
506#endif // #ifndef SWIG
507
508#if !defined(__wxPG_SOURCE_FILE__) && !defined(SWIG)
509 // Reduce compile time, but still include in user app
510 #include "wx/propgrid/props.h"
511#endif
512
513// -----------------------------------------------------------------------
514
515/** @class wxPropertyGrid
516
517 wxPropertyGrid is a specialized grid for editing properties
518 such as strings, numbers, flagsets, fonts, and colours. wxPropertySheet
519 used to do the very same thing, but it hasn't been updated for a while
520 and it is currently deprecated.
521
522 Please note that most member functions are inherited and as such not
523 documented on this page. This means you will probably also want to read
524 wxPropertyGridInterface class reference.
525
526 See also @ref overview_propgrid.
527
528 @section propgrid_window_styles_ Window Styles
529
530 See @ref propgrid_window_styles.
531
532 @section propgrid_event_handling Event Handling
533
534 To process input from a propertygrid control, use these event handler
535 macros to direct input to member functions that take a wxPropertyGridEvent
536 argument.
537
538 @beginEventTable{wxPropertyGridEvent}
539 @event{EVT_PG_SELECTED (id, func)}
540 Respond to wxEVT_PG_SELECTED event, generated when property value
541 has been changed by user.
542 @event{EVT_PG_CHANGING(id, func)}
543 Respond to wxEVT_PG_CHANGING event, generated when property value
544 is about to be changed by user. Use wxPropertyGridEvent::GetValue()
545 to take a peek at the pending value, and wxPropertyGridEvent::Veto()
546 to prevent change from taking place, if necessary.
547 @event{EVT_PG_HIGHLIGHTED(id, func)}
548 Respond to wxEVT_PG_HIGHLIGHTED event, which occurs when mouse
549 moves over a property. Event's property is NULL if hovered area does
550 not belong to any property.
551 @event{EVT_PG_RIGHT_CLICK(id, func)}
552 Respond to wxEVT_PG_RIGHT_CLICK event, which occurs when property is
553 clicked on with right mouse button.
554 @event{EVT_PG_DOUBLE_CLICK(id, func)}
555 Respond to wxEVT_PG_DOUBLE_CLICK event, which occurs when property is
556 double-clicked onwith left mouse button.
557 @event{EVT_PG_ITEM_COLLAPSED(id, func)}
558 Respond to wxEVT_PG_ITEM_COLLAPSED event, generated when user collapses
559 a property or category..
560 @event{EVT_PG_ITEM_EXPANDED(id, func)}
561 Respond to wxEVT_PG_ITEM_EXPANDED event, generated when user expands
562 a property or category..
563 @endEventTable
564
565 @remarks
566
567 - Use Freeze() and Thaw() respectively to disable and enable drawing. This
568 will also delay sorting etc. miscellaneous calculations to the last
569 possible moment.
570
571 @library{wxpropgrid}
572 @category{propgrid}
573*/
574class WXDLLIMPEXP_PROPGRID
575 wxPropertyGrid : public wxScrolledWindow, public wxPropertyGridInterface
576{
577 friend class wxPropertyGridPageState;
578 friend class wxPropertyGridInterface;
579 friend class wxPropertyGridManager;
580 friend class wxPGCanvas;
581
582#ifndef SWIG
583 DECLARE_DYNAMIC_CLASS(wxPropertyGrid)
584#endif
585public:
586
587#ifdef SWIG
588 %pythonAppend wxPropertyGrid {
589 self._setOORInfo(self)
590 self.DoDefaultTypeMappings()
591 self.edited_objects = {}
592 self.DoDefaultValueTypeMappings()
593 if not hasattr(self.__class__,'_vt2setter'):
594 self.__class__._vt2setter = {}
595 }
596 %pythonAppend wxPropertyGrid() ""
597
598 wxPropertyGrid( wxWindow *parent, wxWindowID id = wxID_ANY,
599 const wxPoint& pos = wxDefaultPosition,
600 const wxSize& size = wxDefaultSize,
601 long style = wxPG_DEFAULT_STYLE,
602 const wxChar* name = wxPyPropertyGridNameStr );
603 %RenameCtor(PrePropertyGrid, wxPropertyGrid());
604#else
605
606 /**
607 Two step constructor.
608
609 Call Create when this constructor is called to build up the
610 wxPropertyGrid
611 */
612 wxPropertyGrid();
613
614 /** The default constructor. The styles to be used are styles valid for
615 the wxWindow and wxScrolledWindow.
616
617 @see @link wndflags Additional Window Styles @endlink
618 */
619 wxPropertyGrid( wxWindow *parent, wxWindowID id = wxID_ANY,
620 const wxPoint& pos = wxDefaultPosition,
621 const wxSize& size = wxDefaultSize,
622 long style = wxPG_DEFAULT_STYLE,
623 const wxString& name = wxPropertyGridNameStr );
624
625 /** Destructor */
626 virtual ~wxPropertyGrid();
627#endif
628
629 /** Adds given key combination to trigger given action.
630
631 @param action
632 Which action to trigger. See @link pgactions List of list of
633 wxPropertyGrid actions@endlink.
634 */
635 void AddActionTrigger( int action, int keycode, int modifiers = 0 );
636
637 /**
638 This static function enables or disables automatic use of
639 wxGetTranslation for following strings: wxEnumProperty list labels,
640 wxFlagsProperty sub-property labels.
641
642 Default is false.
643 */
644 static void AutoGetTranslation( bool enable );
645
646 /**
647 Changes value of a property, as if from an editor.
648
649 Use this instead of SetPropertyValue() if you need the value to run
650 through validation process, and also send the property change event.
651
652 @return
653 Returns true if value was successfully changed.
654 */
655 bool ChangePropertyValue( wxPGPropArg id, wxVariant newValue );
656
657 /**
658 Centers the splitter.
659
660 If argument is true, automatic splitter centering is enabled (only
661 applicapple if style wxPG_SPLITTER_AUTO_CENTER was defined).
662 */
663 void CenterSplitter( bool enable_auto_centering = false );
664
665 /** Deletes all properties.
666 */
667 virtual void Clear();
668
669 /** Clears action triggers for given action.
670 @param action
671 Which action to trigger. See @link pgactions List of list of
672 wxPropertyGrid actions@endlink.
673 */
674 void ClearActionTriggers( int action );
675
676 /** Forces updating the value of property from the editor control.
677
678 Note that wxEVT_PG_CHANGING and wxEVT_PG_CHANGED are dispatched using
679 ProcessEvent, meaning your event handlers will be called immediately.
680
681 @return
682 Returns true if anything was changed.
683 */
684 virtual bool CommitChangesFromEditor( wxUint32 flags = 0 );
685
686 /**
687 Two step creation.
688
689 Whenever the control is created without any parameters, use Create to
690 actually create it. Don't access the control's public methods before
691 this is called @see @link wndflags Additional Window Styles@endlink
692 */
693 bool Create( wxWindow *parent, wxWindowID id = wxID_ANY,
694 const wxPoint& pos = wxDefaultPosition,
695 const wxSize& size = wxDefaultSize,
696 long style = wxPG_DEFAULT_STYLE,
697 const wxString& name = wxPropertyGridNameStr );
698
699 /**
700 Call when editor widget's contents is modified.
701
702 For example, this is called when changes text in wxTextCtrl (used in
703 wxStringProperty and wxIntProperty).
704
705 @remarks
706 This function should only be called by custom properties.
707
708 @see wxPGProperty::OnEvent()
709 */
710 void EditorsValueWasModified() { m_iFlags |= wxPG_FL_VALUE_MODIFIED; }
711
712 /** Reverse of EditorsValueWasModified().
713
714 @remarks
715 This function should only be called by custom properties.
716 */
717 void EditorsValueWasNotModified()
718 {
719 m_iFlags &= ~(wxPG_FL_VALUE_MODIFIED);
720 }
721
722 /**
723 Enables or disables (shows/hides) categories according to parameter
724 enable.
725 */
726 bool EnableCategories( bool enable );
727
728 /** Scrolls and/or expands items to ensure that the given item is visible.
729 Returns true if something was actually done.
730 */
731 bool EnsureVisible( wxPGPropArg id );
732
733 /**
734 Reduces column sizes to minimum possible that contents are still
735 visibly (naturally some margin space will be applied as well).
736
737 @return
738 Minimum size for the grid to still display everything.
739
740 @remarks
741 Does not work well with wxPG_SPLITTER_AUTO_CENTER window style.
742
743 This function only works properly if grid size prior to call was already
744 fairly large.
745
746 Note that you can also get calculated column widths by calling
747 GetState->GetColumnWidth() immediately after this function returns.
748 */
749 wxSize FitColumns()
750 {
751 wxSize sz = m_pState->DoFitColumns();
752 return sz;
753 }
754
755 /**
756 Returns wxWindow that the properties are painted on, and which should
757 be used as the parent for editor controls.
758 */
759 wxPanel* GetPanel() const
760 {
761 return m_canvas;
762 }
763
764 /** Returns current category caption background colour. */
765 wxColour GetCaptionBackgroundColour() const { return m_colCapBack; }
766
767 wxFont& GetCaptionFont() { return m_captionFont; }
768
769 const wxFont& GetCaptionFont() const { return m_captionFont; }
770
771 /** Returns current category caption text colour. */
772 wxColour GetCaptionForegroundColour() const { return m_colCapFore; }
773
774 /** Returns current cell background colour. */
775 wxColour GetCellBackgroundColour() const { return m_colPropBack; }
776
777 /** Returns current cell text colour when disabled. */
778 wxColour GetCellDisabledTextColour() const { return m_colDisPropFore; }
779
780 /** Returns current cell text colour. */
781 wxColour GetCellTextColour() const { return m_colPropFore; }
782
783 /**
784 Returns number of columns currently on grid.
785 */
786 unsigned int GetColumnCount() const
787 {
788 return (unsigned int) m_pState->m_colWidths.size();
789 }
790
791 /** Returns colour of empty space below properties. */
792 wxColour GetEmptySpaceColour() const { return m_colEmptySpace; }
793
794 /** Returns height of highest characters of used font. */
795 int GetFontHeight() const { return m_fontHeight; }
796
797 /** Returns pointer to itself. Dummy function that enables same kind
798 of code to use wxPropertyGrid and wxPropertyGridManager.
799 */
800 wxPropertyGrid* GetGrid() { return this; }
801
802 /** Returns rectangle of custom paint image.
803 */
804 wxRect GetImageRect( wxPGProperty* p, int item ) const;
805
806 /** Returns size of the custom paint image in front of property.
807 If no argument is given, returns preferred size.
808 */
809 wxSize GetImageSize( wxPGProperty* p = NULL, int item = -1 ) const;
810
811 //@{
812 /** Returns last item which could be iterated using given flags.
813 @param flags
814 See @ref propgrid_iterator_flags.
815 */
816 wxPGProperty* GetLastItem( int flags = wxPG_ITERATE_DEFAULT )
817 {
818 return m_pState->GetLastItem(flags);
819 }
820
821 const wxPGProperty* GetLastItem( int flags = wxPG_ITERATE_DEFAULT ) const
822 {
823 return m_pState->GetLastItem(flags);
824 }
825 //@}
826
827 /** Returns colour of lines between cells. */
828 wxColour GetLineColour() const { return m_colLine; }
829
830 /** Returns background colour of margin. */
831 wxColour GetMarginColour() const { return m_colMargin; }
832
833 /**
834 Returns most up-to-date value of selected property. This will return
835 value different from GetSelectedProperty()->GetValue() only when text
836 editor is activate and string edited by user represents valid,
837 uncommitted property value.
838 */
839 wxVariant GetUncommittedPropertyValue();
840
841 /** Returns "root property". It does not have name, etc. and it is not
842 visible. It is only useful for accessing its children.
843 */
844 wxPGProperty* GetRoot() const { return m_pState->m_properties; }
845
846 /** Returns height of a single grid row (in pixels). */
847 int GetRowHeight() const { return m_lineHeight; }
848
849 /** Returns currently selected property. */
850 wxPGProperty* GetSelectedProperty() const { return GetSelection(); }
851
852 /** Returns currently selected property. */
853 wxPGProperty* GetSelection() const
854 {
855 return m_selected;
856 }
857
858 /** Returns current selection background colour. */
859 wxColour GetSelectionBackgroundColour() const { return m_colSelBack; }
860
861 /** Returns current selection text colour. */
862 wxColour GetSelectionForegroundColour() const { return m_colSelFore; }
863
864 /** Returns current splitter x position. */
865 int GetSplitterPosition() const
866 { return m_pState->DoGetSplitterPosition(0); }
867
868 /** Returns wxTextCtrl active in currently selected property, if any. Takes
869 into account wxOwnerDrawnComboBox.
870 */
871 wxTextCtrl* GetEditorTextCtrl() const;
872
873 wxPGValidationInfo& GetValidationInfo()
874 {
875 return m_validationInfo;
876 }
877
878 /** Returns current vertical spacing. */
879 int GetVerticalSpacing() const { return (int)m_vspacing; }
880
881 /**
882 Returns @true if a property editor control has focus.
883 */
884 bool IsEditorFocused() const;
885
886 /** Returns true if editor's value was marked modified.
887 */
888 bool IsEditorsValueModified() const
889 { return ( m_iFlags & wxPG_FL_VALUE_MODIFIED ) ? true : false; }
890
891 /**
892 Returns information about arbitrary position in the grid.
893
894 @param pt
895 Coordinates in the virtual grid space. You may need to use
896 wxScrolledWindow::CalcScrolledPosition() for translating
897 wxPropertyGrid client coordinates into something this member
898 function can use.
899 */
900 wxPropertyGridHitTestResult HitTest( const wxPoint& pt ) const;
901
902 /** Returns true if any property has been modified by the user. */
903 bool IsAnyModified() const { return (m_pState->m_anyModified>0); }
904
905 /**
906 Returns true if updating is frozen (ie Freeze() called but not yet
907 Thaw() ).
908 */
909 bool IsFrozen() const { return (m_frozen>0)?true:false; }
910
911 /** Redraws given property.
912 */
913 virtual void RefreshProperty( wxPGProperty* p );
914
915#ifndef SWIG
916 /** Registers a new editor class.
917 @return
918 Pointer to the editor class instance that should be used.
919 */
920 static wxPGEditor* RegisterEditorClass( wxPGEditor* editor,
921 bool noDefCheck = false );
922#endif
923
924 /** Resets all colours to the original system values.
925 */
926 void ResetColours();
927
928 /**
929 Selects a property.
930 Editor widget is automatically created, but not focused unless focus is
931 true. This will generate wxEVT_PG_SELECT event.
932 @param id
933 Property to select.
934 @return
935 True if selection finished successfully. Usually only fails if
936 current value in editor is not valid.
937 @see wxPropertyGrid::Unselect
938 */
939 bool SelectProperty( wxPGPropArg id, bool focus = false )
940 {
941 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
942 return DoSelectProperty(p,focus?wxPG_SEL_FOCUS:0);
943 }
944
945 /** Sets category caption background colour. */
946 void SetCaptionBackgroundColour(const wxColour& col);
947
948 /** Sets category caption text colour. */
949 void SetCaptionTextColour(const wxColour& col);
950
951 /** Sets default cell background colour - applies to property cells.
952 Note that appearance of editor widgets may not be affected.
953 */
954 void SetCellBackgroundColour(const wxColour& col);
955
956 /** Sets cell text colour for disabled properties.
957 */
958 void SetCellDisabledTextColour(const wxColour& col);
959
960 /** Sets default cell text colour - applies to property name and value text.
961 Note that appearance of editor widgets may not be affected.
962 */
963 void SetCellTextColour(const wxColour& col);
964
965 /** Set number of columns (2 or more).
966 */
967 void SetColumnCount( int colCount )
968 {
969 m_pState->SetColumnCount(colCount);
970 Refresh();
971 }
972
973 /**
974 Sets the 'current' category - Append will add non-category properties
975 under it.
976 */
977 void SetCurrentCategory( wxPGPropArg id )
978 {
979 wxPG_PROP_ARG_CALL_PROLOG()
980 wxPropertyCategory* pc = wxDynamicCast(p, wxPropertyCategory);
981 wxASSERT(pc);
982 m_pState->m_currentCategory = pc;
983 }
984
985 /** Sets colour of empty space below properties. */
986 void SetEmptySpaceColour(const wxColour& col);
987
988 /** Sets colour of lines between cells. */
989 void SetLineColour(const wxColour& col);
990
991 /** Sets background colour of margin. */
992 void SetMarginColour(const wxColour& col);
993
994 /**
995 Sets selection background colour - applies to selected property name
996 background.
997 */
998 void SetSelectionBackgroundColour(const wxColour& col);
999
1000 /**
1001 Sets selection foreground colour - applies to selected property name
1002 text.
1003 */
1004 void SetSelectionTextColour(const wxColour& col);
1005
1006 /** Sets x coordinate of the splitter.
1007 @remarks
1008 Splitter position cannot exceed grid size, and therefore setting it
1009 during form creation may fail as initial grid size is often smaller
1010 than desired splitter position, especially when sizers are being used.
1011 */
1012 void SetSplitterPosition( int newxpos, int col = 0 )
1013 {
1014 DoSetSplitterPosition_(newxpos, true, col);
1015 m_iFlags |= wxPG_FL_SPLITTER_PRE_SET;
1016 }
1017
1018 /**
1019 Sets the property sorting function.
1020
1021 @param sortFunction
1022 The sorting function to be used. It should return a value greater
1023 than 0 if position of p1 is after p2. So, for instance, when
1024 comparing property names, you can use following implementation:
1025
1026 @code
1027 int MyPropertySortFunction(wxPropertyGrid* propGrid,
1028 wxPGProperty* p1,
1029 wxPGProperty* p2)
1030 {
1031 return p1->GetBaseName().compare( p2->GetBaseName() );
1032 }
1033 @endcode
1034
1035 @remarks
1036 Default property sort function sorts properties by their labels
1037 (case-insensitively).
1038
1039 @see GetSortFunction, wxPropertyGridInterface::Sort,
1040 wxPropertyGridInterface::SortChildren
1041 */
1042 void SetSortFunction( wxPGSortCallback sortFunction )
1043 {
1044 m_sortFunction = sortFunction;
1045 }
1046
1047 /**
1048 Returns the property sort function (default is @NULL).
1049
1050 @see SetSortFunction
1051 */
1052 wxPGSortCallback GetSortFunction() const
1053 {
1054 return m_sortFunction;
1055 }
1056
1057 /** Set virtual width for this particular page. Width -1 indicates that the
1058 virtual width should be disabled. */
1059 void SetVirtualWidth( int width );
1060
1061 /**
1062 Moves splitter as left as possible, while still allowing all
1063 labels to be shown in full.
1064
1065 @param privateChildrenToo
1066 If @false, will still allow private children to be cropped.
1067 */
1068 void SetSplitterLeft( bool privateChildrenToo = false )
1069 {
1070 m_pState->SetSplitterLeft(privateChildrenToo);
1071 }
1072
1073 /** Sets vertical spacing. Can be 1, 2, or 3 - a value relative to font
1074 height. Value of 2 should be default on most platforms.
1075 */
1076 void SetVerticalSpacing( int vspacing )
1077 {
1078 m_vspacing = (unsigned char)vspacing;
1079 CalculateFontAndBitmapStuff( vspacing );
1080 if ( !m_pState->m_itemsAdded ) Refresh();
1081 }
1082
1083 /** Shows an brief error message that is related to a property. */
1084 void ShowPropertyError( wxPGPropArg id, const wxString& msg )
1085 {
1086 wxPG_PROP_ARG_CALL_PROLOG()
1087 DoShowPropertyError(p, msg);
1088 }
1089
1090 /////////////////////////////////////////////////////////////////
1091 //
1092 // Following methods do not need to be (currently) documented
1093 //
1094 /////////////////////////////////////////////////////////////////
1095
1096 bool HasVirtualWidth() const
1097 { return (m_iFlags & wxPG_FL_HAS_VIRTUAL_WIDTH) ? true : false; }
1098
1099 const wxPGCommonValue* GetCommonValue( unsigned int i ) const
1100 {
1101 return (wxPGCommonValue*) m_commonValues[i];
1102 }
1103
1104 /** Returns number of common values.
1105 */
1106 unsigned int GetCommonValueCount() const
1107 {
1108 return (unsigned int) m_commonValues.size();
1109 }
1110
1111 /** Returns label of given common value.
1112 */
1113 wxString GetCommonValueLabel( unsigned int i ) const
1114 {
1115 wxASSERT( GetCommonValue(i) );
1116 return GetCommonValue(i)->GetLabel();
1117 }
1118
1119 /**
1120 Returns index of common value that will truly change value to
1121 unspecified.
1122 */
1123 int GetUnspecifiedCommonValue() const { return m_cvUnspecified; }
1124
1125 /** Set index of common value that will truly change value to unspecified.
1126 Using -1 will set none to have such effect.
1127 Default is 0.
1128 */
1129 void SetUnspecifiedCommonValue( int index ) { m_cvUnspecified = index; }
1130
1131 /**
1132 Shortcut for creating dialog-caller button. Used, for example, by
1133 wxFontProperty.
1134 @remarks
1135 This should only be called by properties.
1136 */
1137 wxWindow* GenerateEditorButton( const wxPoint& pos, const wxSize& sz );
1138
1139 /** Fixes position of wxTextCtrl-like control (wxSpinCtrl usually
1140 fits as one). Call after control has been created (but before
1141 shown).
1142 */
1143 void FixPosForTextCtrl( wxWindow* ctrl,
1144 const wxPoint& offset = wxPoint(0, 0) );
1145
1146 /** Shortcut for creating text editor widget.
1147 @param pos
1148 Same as pos given for CreateEditor.
1149 @param sz
1150 Same as sz given for CreateEditor.
1151 @param value
1152 Initial text for wxTextCtrl.
1153 @param secondary
1154 If right-side control, such as button, also created, then create it
1155 first and pass it as this parameter.
1156 @param extraStyle
1157 Extra style flags to pass for wxTextCtrl.
1158 @remarks
1159 Note that this should generally be called only by new classes derived
1160 from wxPGProperty.
1161 */
1162 wxWindow* GenerateEditorTextCtrl( const wxPoint& pos,
1163 const wxSize& sz,
1164 const wxString& value,
1165 wxWindow* secondary,
1166 int extraStyle = 0,
1167 int maxLen = 0 );
1168
1169 /* Generates both textctrl and button.
1170 */
1171 wxWindow* GenerateEditorTextCtrlAndButton( const wxPoint& pos,
1172 const wxSize& sz, wxWindow** psecondary, int limited_editing,
1173 wxPGProperty* property );
1174
1175 /** Generates position for a widget editor dialog box.
1176 @param p
1177 Property for which dialog is positioned.
1178 @param sz
1179 Known or over-approximated size of the dialog.
1180 @return
1181 Position for dialog.
1182 */
1183 wxPoint GetGoodEditorDialogPosition( wxPGProperty* p,
1184 const wxSize& sz );
1185
1186 // Converts escape sequences in src_str to newlines,
1187 // tabs, etc. and copies result to dst_str.
1188 static wxString& ExpandEscapeSequences( wxString& dst_str,
1189 wxString& src_str );
1190
1191 // Converts newlines, tabs, etc. in src_str to escape
1192 // sequences, and copies result to dst_str.
1193 static wxString& CreateEscapeSequences( wxString& dst_str,
1194 wxString& src_str );
1195
1196 /**
1197 Returns rectangle that fully contains properties between and including
1198 p1 and p2.
1199 */
1200 wxRect GetPropertyRect( const wxPGProperty* p1,
1201 const wxPGProperty* p2 ) const;
1202
1203 /** Returns pointer to current active primary editor control (NULL if none).
1204 */
1205 wxWindow* GetEditorControl() const;
1206
1207 wxWindow* GetPrimaryEditor() const
1208 {
1209 return GetEditorControl();
1210 }
1211
1212 /**
1213 Returns pointer to current active secondary editor control (NULL if
1214 none).
1215 */
1216 wxWindow* GetEditorControlSecondary() const
1217 {
1218 return m_wndEditor2;
1219 }
1220
1221 /**
1222 Refreshes any active editor control.
1223 */
1224 void RefreshEditor();
1225
1226 // Events from editor controls are forward to this function
1227 void HandleCustomEditorEvent( wxEvent &event );
1228
1229#ifndef SWIG
1230
1231 /**
1232 Generates contents for string dst based on the contents of
1233 wxArrayString src.
1234
1235 Format will be "(preDelim)str1(postDelim) (preDelim)str2(postDelim) and
1236 so on. Set flags to 1 inorder to convert backslashes to double-back-
1237 slashes and "(preDelims)"'s to "(preDelims)".
1238 */
1239 static void ArrayStringToString( wxString& dst, const wxArrayString& src,
1240 wxChar preDelim, wxChar postDelim,
1241 int flags );
1242
1243 // Mostly useful for page switching.
1244 void SwitchState( wxPropertyGridPageState* pNewState );
1245
1246 long GetInternalFlags() const { return m_iFlags; }
1247 bool HasInternalFlag( long flag ) const
1248 { return (m_iFlags & flag) ? true : false; }
1249 void SetInternalFlag( long flag ) { m_iFlags |= flag; }
1250 void ClearInternalFlag( long flag ) { m_iFlags &= ~(flag); }
1251 void IncFrozen() { m_frozen++; }
1252 void DecFrozen() { m_frozen--; }
1253
1254 void OnComboItemPaint( const wxPGComboBox* pCb,
1255 int item,
1256 wxDC* pDc,
1257 wxRect& rect,
1258 int flags );
1259
1260 /** Standardized double-to-string conversion.
1261 */
1262 static void DoubleToString( wxString& target,
1263 double value,
1264 int precision,
1265 bool removeZeroes,
1266 wxString* precTemplate );
1267
1268 /**
1269 Call this from wxPGProperty::OnEvent() to cause property value to be
1270 changed after the function returns (with true as return value).
1271 ValueChangeInEvent() must be used if you wish the application to be
1272 able to use wxEVT_PG_CHANGING to potentially veto the given value.
1273 */
1274 void ValueChangeInEvent( wxVariant variant )
1275 {
1276 m_changeInEventValue = variant;
1277 m_iFlags |= wxPG_FL_VALUE_CHANGE_IN_EVENT;
1278 }
1279
1280 /** Returns true if given event is from first of an array of buttons
1281 (as can be in case when wxPGMultiButton is used).
1282 */
1283 bool IsMainButtonEvent( const wxEvent& event )
1284 {
1285 return (event.GetEventType() == wxEVT_COMMAND_BUTTON_CLICKED)
1286 && (m_wndSecId == event.GetId());
1287 }
1288
1289 /** Pending value is expected to be passed in PerformValidation().
1290 */
1291 virtual bool DoPropertyChanged( wxPGProperty* p,
1292 unsigned int selFlags = 0 );
1293
1294 /** Called when validation for given property fails.
1295 @param invalidValue
1296 Value which failed in validation.
1297 @return
1298 Return true if user is allowed to change to another property even
1299 if current has invalid value.
1300 @remarks
1301 To add your own validation failure behavior, override
1302 wxPropertyGrid::DoOnValidationFailure().
1303 */
1304 bool OnValidationFailure( wxPGProperty* property,
1305 wxVariant& invalidValue );
1306
1307 /** Called to indicate property and editor has valid value now.
1308 */
1309 void OnValidationFailureReset( wxPGProperty* property )
1310 {
1311 if ( property && property->HasFlag(wxPG_PROP_INVALID_VALUE) )
1312 {
1313 DoOnValidationFailureReset(property);
1314 property->ClearFlag(wxPG_PROP_INVALID_VALUE);
1315 }
1316 m_validationInfo.m_failureMessage.clear();
1317 }
1318
1319 /** Override in derived class to display error messages in custom manner
1320 (these message usually only result from validation failure).
1321 */
1322 virtual void DoShowPropertyError( wxPGProperty* property,
1323 const wxString& msg );
1324
1325 /** Override to customize property validation failure behavior.
1326 @param invalidValue
1327 Value which failed in validation.
1328 @return
1329 Return true if user is allowed to change to another property even
1330 if current has invalid value.
1331 */
1332 virtual bool DoOnValidationFailure( wxPGProperty* property,
1333 wxVariant& invalidValue );
1334
1335 /** Override to customize resetting of property validation failure status.
1336 @remarks
1337 Property is guaranteed to have flag wxPG_PROP_INVALID_VALUE set.
1338 */
1339 virtual void DoOnValidationFailureReset( wxPGProperty* property );
1340
1341 int GetSpacingY() const { return m_spacingy; }
1342
1343 /**
1344 Must be called in wxPGEditor::CreateControls() if primary editor window
1345 is wxTextCtrl, just before textctrl is created.
1346 @param text
1347 Initial text value of created wxTextCtrl.
1348 */
1349 void SetupTextCtrlValue( const wxString text ) { m_prevTcValue = text; }
1350
1351 /**
1352 Unfocuses or closes editor if one was open, but does not deselect
1353 property.
1354 */
1355 bool UnfocusEditor();
1356
1357 virtual void SetWindowStyleFlag( long style );
1358
1359 void DrawItems( const wxPGProperty* p1, const wxPGProperty* p2 );
1360
1361 void DrawItem( wxPGProperty* p )
1362 {
1363 DrawItems(p,p);
1364 }
1365
1366 virtual void DrawItemAndChildren( wxPGProperty* p );
1367
1368 /**
1369 Draws item, children, and consequtive parents as long as category is
1370 not met.
1371 */
1372 void DrawItemAndValueRelated( wxPGProperty* p );
1373
1374protected:
1375
1376 /**
1377 wxPropertyGridPageState used by the grid is created here.
1378
1379 If grid is used in wxPropertyGridManager, there is no point overriding
1380 this - instead, set custom wxPropertyGridPage classes.
1381 */
1382 virtual wxPropertyGridPageState* CreateState() const;
1383
1384 enum PerformValidationFlags
1385 {
1386 SendEvtChanging = 0x0001,
1387 IsStandaloneValidation = 0x0002 // Not called in response to event
1388 };
1389
1390 /**
1391 Runs all validation functionality (includes sending wxEVT_PG_CHANGING).
1392 Returns true if all tests passed. Implement in derived class to
1393 add additional validation behavior.
1394 */
1395 virtual bool PerformValidation( wxPGProperty* p,
1396 wxVariant& pendingValue,
1397 int flags = SendEvtChanging );
1398
1399public:
1400
1401 // Control font changer helper.
1402 void SetCurControlBoldFont();
1403
1404 wxPGCell& GetPropertyDefaultCell()
1405 {
1406 return m_propertyDefaultCell;
1407 }
1408
1409 wxPGCell& GetCategoryDefaultCell()
1410 {
1411 return m_categoryDefaultCell;
1412 }
1413
1414 //
1415 // Public methods for semi-public use
1416 // (not protected for optimization)
1417 //
1418 bool DoSelectProperty( wxPGProperty* p, unsigned int flags = 0 );
1419
1420 // Overridden functions.
1421 virtual bool Destroy();
1422 // Returns property at given y coordinate (relative to grid's top left).
1423 wxPGProperty* GetItemAtY( int y ) const { return DoGetItemAtY(y); }
1424
1425 virtual void Refresh( bool eraseBackground = true,
1426 const wxRect *rect = (const wxRect *) NULL );
1427 virtual bool SetFont( const wxFont& font );
1428#if wxPG_SUPPORT_TOOLTIPS
1429 void SetToolTip( const wxString& tipString );
1430#endif
1431 virtual void Freeze();
1432 virtual void SetExtraStyle( long exStyle );
1433 virtual void Thaw();
1434
1435
1436protected:
1437 virtual wxSize DoGetBestSize() const;
1438
1439#ifndef wxPG_ICON_WIDTH
1440 wxBitmap *m_expandbmp, *m_collbmp;
1441#endif
1442
1443 wxCursor *m_cursorSizeWE;
1444
1445 /** wxWindow pointers to editor control(s). */
1446 wxWindow *m_wndEditor;
1447 wxWindow *m_wndEditor2;
1448
1449 /** wxPGCanvas instance. */
1450 wxPanel *m_canvas;
1451
1452#if wxPG_DOUBLE_BUFFER
1453 wxBitmap *m_doubleBuffer;
1454#endif
1455
1456 /** Local time ms when control was created. */
1457 wxLongLong m_timeCreated;
1458
1459 /** wxPGProperty::OnEvent can change value by setting this. */
1460 wxVariant m_changeInEventValue;
1461
1462 /** Id of m_wndEditor2, or its first child, if any. */
1463 int m_wndSecId;
1464
1465 /** Extra Y spacing between the items. */
1466 int m_spacingy;
1467
1468 /** Control client area width; updated on resize. */
1469 int m_width;
1470
1471 /** Control client area height; updated on resize. */
1472 int m_height;
1473
1474 /** Current non-client width (needed when auto-centering). */
1475 int m_ncWidth;
1476
1477 /** Non-client width (auto-centering helper). */
1478 //int m_fWidth;
1479
1480 /** Previously recorded scroll start position. */
1481 int m_prevVY;
1482
1483 /**
1484 The gutter spacing in front and back of the image.
1485 This determines the amount of spacing in front of each item
1486 */
1487 int m_gutterWidth;
1488
1489 /** Includes separator line. */
1490 int m_lineHeight;
1491
1492 /** Gutter*2 + image width. */
1493 int m_marginWidth;
1494
1495 // y spacing for expand/collapse button.
1496 int m_buttonSpacingY;
1497
1498 /** Extra margin for expanded sub-group items. */
1499 int m_subgroup_extramargin;
1500
1501 /**
1502 The image width of the [+] icon.
1503
1504 This is also calculated in the gutter
1505 */
1506 int m_iconWidth;
1507
1508#ifndef wxPG_ICON_WIDTH
1509
1510 /**
1511 The image height of the [+] icon.
1512
1513 This is calculated as minimal size and to align
1514 */
1515 int m_iconHeight;
1516#endif
1517
1518 /** Current cursor id. */
1519 int m_curcursor;
1520
1521 /**
1522 This captionFont is made equal to the font of the wxScrolledWindow.
1523
1524 As extra the bold face is set on it when this is wanted by the user
1525 (see flags)
1526 */
1527 wxFont m_captionFont;
1528
1529 int m_fontHeight; // Height of the font.
1530
1531 /** m_splitterx when drag began. */
1532 int m_startingSplitterX;
1533
1534 /**
1535 Index to splitter currently being dragged (0=one after the first
1536 column).
1537 */
1538 int m_draggedSplitter;
1539
1540 /** Changed property, calculated in PerformValidation(). */
1541 wxPGProperty* m_chgInfo_changedProperty;
1542
1543 /**
1544 Lowest property for which editing happened, but which does not have
1545 aggregate parent
1546 */
1547 wxPGProperty* m_chgInfo_baseChangedProperty;
1548
1549 /** Changed property value, calculated in PerformValidation(). */
1550 wxVariant m_chgInfo_pendingValue;
1551
1552 /** Passed to SetValue. */
1553 wxVariant m_chgInfo_valueList;
1554
1555 /** Validation information. */
1556 wxPGValidationInfo m_validationInfo;
1557
1558 /** Actions and keys that trigger them. */
1559 wxPGHashMapI2I m_actionTriggers;
1560
1561 //
1562 // Temporary values
1563 //
1564
1565 /** Bits are used to indicate which colours are customized. */
1566 unsigned short m_coloursCustomized;
1567
1568 /** x - m_splitterx. */
1569 signed char m_dragOffset;
1570
1571 /** 0 = not dragging, 1 = drag just started, 2 = drag in progress */
1572 unsigned char m_dragStatus;
1573
1574 /** 0 = margin, 1 = label, 2 = value. */
1575 unsigned char m_mouseSide;
1576
1577 /** True when editor control is focused. */
1578 unsigned char m_editorFocused;
1579
1580 /** 1 if m_latsCaption is also the bottommost caption. */
1581 //unsigned char m_lastCaptionBottomnest;
1582
1583 /** Set to 1 when graphics frozen. */
1584 unsigned char m_frozen;
1585
1586 unsigned char m_vspacing;
1587
1588 // Used to track when Alt/Ctrl+Key was consumed.
1589 unsigned char m_keyComboConsumed;
1590
1591 /** 1 if in DoPropertyChanged() */
1592 unsigned char m_inDoPropertyChanged;
1593
1594 /** 1 if in CommitChangesFromEditor() */
1595 unsigned char m_inCommitChangesFromEditor;
1596
1597 /** 1 if in DoSelectProperty() */
1598 unsigned char m_inDoSelectProperty;
1599
1600 wxPGVFBFlags m_permanentValidationFailureBehavior; // Set by app
1601
1602 /** Internal flags - see wxPG_FL_XXX constants. */
1603 wxUint32 m_iFlags;
1604
1605 /** When drawing next time, clear this many item slots at the end. */
1606 int m_clearThisMany;
1607
1608 /** Pointer to selected property. Note that this is duplicated in
1609 m_state for better transiency between pages so that the selected
1610 item can be retained.
1611 */
1612 wxPGProperty* m_selected;
1613
1614 // pointer to property that has mouse hovering
1615 wxPGProperty* m_propHover;
1616
1617 // EventObject for wxPropertyGridEvents
1618 wxWindow* m_eventObject;
1619
1620 // What (global) window is currently focused (needed to resolve event
1621 // handling mess).
1622 wxWindow* m_curFocused;
1623
1624 // wxPGTLWHandler
1625 wxEvtHandler* m_tlwHandler;
1626
1627 // Top level parent
1628 wxWindow* m_tlp;
1629
1630 // Sort function
1631 wxPGSortCallback m_sortFunction;
1632
1633 // y coordinate of property that mouse hovering
1634 int m_propHoverY;
1635 // Which column's editor is selected (usually 1)?
1636 int m_selColumn;
1637
1638 // x relative to splitter (needed for resize).
1639 int m_ctrlXAdjust;
1640
1641 // lines between cells
1642 wxColour m_colLine;
1643 // property labels and values are written in this colour
1644 wxColour m_colPropFore;
1645 // or with this colour when disabled
1646 wxColour m_colDisPropFore;
1647 // background for m_colPropFore
1648 wxColour m_colPropBack;
1649 // text color for captions
1650 wxColour m_colCapFore;
1651 // background color for captions
1652 wxColour m_colCapBack;
1653 // foreground for selected property
1654 wxColour m_colSelFore;
1655 // background for selected property (actually use background color when
1656 // control out-of-focus)
1657 wxColour m_colSelBack;
1658 // background colour for margin
1659 wxColour m_colMargin;
1660 // background colour for empty space below the grid
1661 wxColour m_colEmptySpace;
1662
1663 // Default property colours
1664 wxPGCell m_propertyDefaultCell;
1665
1666 // Default property category
1667 wxPGCell m_categoryDefaultCell;
1668
1669 // Backup of selected property's cells
1670 wxVector<wxPGCell> m_propCellsBackup;
1671
1672 // NB: These *cannot* be moved to globals.
1673
1674 // labels when properties use common values
1675 wxVector<wxPGCommonValue*> m_commonValues;
1676
1677 // Which cv selection really sets value to unspecified?
1678 int m_cvUnspecified;
1679
1680 // Used to skip excess text editor events
1681 wxString m_prevTcValue;
1682
1683protected:
1684
1685 // Sets some members to defaults (called constructors).
1686 void Init1();
1687
1688 // Initializes some members (called by Create and complex constructor).
1689 void Init2();
1690
1691 void OnPaint(wxPaintEvent &event );
1692
1693 // main event receivers
1694 void OnMouseMove( wxMouseEvent &event );
1695 void OnMouseMoveBottom( wxMouseEvent &event );
1696 void OnMouseClick( wxMouseEvent &event );
1697 void OnMouseRightClick( wxMouseEvent &event );
1698 void OnMouseDoubleClick( wxMouseEvent &event );
1699 void OnMouseUp( wxMouseEvent &event );
1700 void OnKey( wxKeyEvent &event );
1701 void OnResize( wxSizeEvent &event );
1702
1703 // event handlers
1704 bool HandleMouseMove( int x, unsigned int y, wxMouseEvent &event );
1705 bool HandleMouseClick( int x, unsigned int y, wxMouseEvent &event );
1706 bool HandleMouseRightClick( int x, unsigned int y, wxMouseEvent &event );
1707 bool HandleMouseDoubleClick( int x, unsigned int y, wxMouseEvent &event );
1708 bool HandleMouseUp( int x, unsigned int y, wxMouseEvent &event );
1709 void HandleKeyEvent( wxKeyEvent &event, bool fromChild );
1710
1711 void OnMouseEntry( wxMouseEvent &event );
1712
1713 void OnIdle( wxIdleEvent &event );
1714 void OnFocusEvent( wxFocusEvent &event );
1715 void OnChildFocusEvent( wxChildFocusEvent& event );
1716
1717 bool OnMouseCommon( wxMouseEvent &event, int* px, int *py );
1718 bool OnMouseChildCommon( wxMouseEvent &event, int* px, int *py );
1719
1720 // sub-control event handlers
1721 void OnMouseClickChild( wxMouseEvent &event );
1722 void OnMouseRightClickChild( wxMouseEvent &event );
1723 void OnMouseMoveChild( wxMouseEvent &event );
1724 void OnMouseUpChild( wxMouseEvent &event );
1725 void OnChildKeyDown( wxKeyEvent &event );
1726
1727 void OnCaptureChange( wxMouseCaptureChangedEvent &event );
1728
1729 void OnScrollEvent( wxScrollWinEvent &event );
1730
1731 void OnSysColourChanged( wxSysColourChangedEvent &event );
1732
1733protected:
1734
1735 /**
1736 Adjust the centering of the bitmap icons (collapse / expand) when the
1737 caption font changes.
1738
1739 They need to be centered in the middle of the font, so a bit of deltaY
1740 adjustment is needed. On entry, m_captionFont must be set to window
1741 font. It will be modified properly.
1742 */
1743 void CalculateFontAndBitmapStuff( int vspacing );
1744
1745 wxRect GetEditorWidgetRect( wxPGProperty* p, int column ) const;
1746
1747 void CorrectEditorWidgetSizeX();
1748
1749 /** Called in RecalculateVirtualSize() to reposition control
1750 on virtual height changes.
1751 */
1752 void CorrectEditorWidgetPosY();
1753
1754 /** Deselect current selection, if any. Returns true if success
1755 (ie. validator did not intercept). */
1756 bool DoClearSelection();
1757
1758 int DoDrawItems( wxDC& dc,
1759 const wxRect* clipRect,
1760 bool isBuffered ) const;
1761
1762 /** Draws an expand/collapse (ie. +/-) button.
1763 */
1764 virtual void DrawExpanderButton( wxDC& dc, const wxRect& rect,
1765 wxPGProperty* property ) const;
1766
1767 /** Draws items from topitemy to bottomitemy */
1768 void DrawItems( wxDC& dc, unsigned int topitemy, unsigned int bottomitemy,
1769 const wxRect* clip_rect = (const wxRect*) NULL );
1770
1771 // Translate wxKeyEvent to wxPG_ACTION_XXX
1772 int KeyEventToActions(wxKeyEvent &event, int* pSecond) const;
1773
1774 int KeyEventToAction(wxKeyEvent &event) const
1775 {
1776 return KeyEventToActions(event, NULL);
1777 }
1778
1779 void ImprovedClientToScreen( int* px, int* py );
1780
1781 // Called by focus event handlers. newFocused is the window that becomes
1782 // focused.
1783 void HandleFocusChange( wxWindow* newFocused );
1784
1785 /** Reloads all non-customized colours from system settings. */
1786 void RegainColours();
1787
1788 bool DoEditorValidate();
1789
1790 wxPGProperty* DoGetItemAtY( int y ) const;
1791
1792 void DoSetSplitterPosition_( int newxpos,
1793 bool refresh = true,
1794 int splitterIndex = 0,
1795 bool allPages = false );
1796
1797 void FreeEditors();
1798
1799 virtual bool DoExpand( wxPGProperty* p, bool sendEvent = false );
1800
1801 virtual bool DoCollapse( wxPGProperty* p, bool sendEvent = false );
1802
1803 // Returns nearest paint visible property (such that will be painted unless
1804 // window is scrolled or resized). If given property is paint visible, then
1805 // it itself will be returned.
1806 wxPGProperty* GetNearestPaintVisible( wxPGProperty* p ) const;
1807
1808 static void RegisterDefaultEditors();
1809
1810 // Sets up basic event handling for child control
1811 void SetupChildEventHandling( wxWindow* wnd );
1812
1813 void CustomSetCursor( int type, bool override = false );
1814
1815 /**
1816 Repositions scrollbar and underlying panel according to changed virtual
1817 size.
1818 */
1819 void RecalculateVirtualSize( int forceXPos = -1 );
1820
1821 void PrepareAfterItemsAdded();
1822
1823 bool SendEvent( int eventType,
1824 wxPGProperty* p,
1825 wxVariant* pValue = NULL,
1826 unsigned int selFlags = 0 );
1827
1828 void SetFocusOnCanvas();
1829
1830 bool DoHideProperty( wxPGProperty* p, bool hide, int flags );
1831
1832private:
1833
1834 bool ButtonTriggerKeyTest( int action, wxKeyEvent& event );
1835
1836 DECLARE_EVENT_TABLE()
1837#endif // #ifndef SWIG
1838};
1839
1840// -----------------------------------------------------------------------
1841//
1842// Bunch of inlines that need to resolved after all classes have been defined.
1843//
1844
1845#ifndef SWIG
1846inline bool wxPropertyGridPageState::IsDisplayed() const
1847{
1848 return ( this == m_pPropGrid->GetState() );
1849}
1850
1851inline unsigned int wxPropertyGridPageState::GetActualVirtualHeight() const
1852{
1853 return DoGetRoot()->GetChildrenHeight(GetGrid()->GetRowHeight());
1854}
1855#endif
1856
1857inline int wxPGProperty::GetDisplayedCommonValueCount() const
1858{
1859 if ( HasFlag(wxPG_PROP_USES_COMMON_VALUE) )
1860 {
1861 wxPropertyGrid* pg = GetGrid();
1862 if ( pg )
1863 return (int) pg->GetCommonValueCount();
1864 }
1865 return 0;
1866}
1867
1868inline void wxPGProperty::SetEditor( const wxString& editorName )
1869{
1870 m_customEditor = wxPropertyGridInterface::GetEditorByName(editorName);
1871}
1872
1873inline void wxPGProperty::SetName( const wxString& newName )
1874{
1875 GetGrid()->SetPropertyName(this, newName);
1876}
1877
1878inline bool wxPGProperty::Hide( bool hide, int flags )
1879{
1880 return GetGrid()->HideProperty(this, hide, flags);
1881}
1882
1883inline bool wxPGProperty::SetMaxLength( int maxLen )
1884{
1885 return GetGrid()->SetPropertyMaxLength(this,maxLen);
1886}
1887
1888// -----------------------------------------------------------------------
1889
1890#define wxPG_BASE_EVT_PRE_ID 1775
1891
1892#ifndef SWIG
1893
1894wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_PROPGRID, wxEVT_PG_SELECTED, wxPropertyGridEvent );
1895wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_PROPGRID, wxEVT_PG_CHANGING, wxPropertyGridEvent );
1896wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_PROPGRID, wxEVT_PG_CHANGED, wxPropertyGridEvent );
1897wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_PROPGRID, wxEVT_PG_HIGHLIGHTED, wxPropertyGridEvent );
1898wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_PROPGRID, wxEVT_PG_RIGHT_CLICK, wxPropertyGridEvent );
1899wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_PROPGRID, wxEVT_PG_PAGE_CHANGED, wxPropertyGridEvent );
1900wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_PROPGRID, wxEVT_PG_ITEM_COLLAPSED, wxPropertyGridEvent );
1901wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_PROPGRID, wxEVT_PG_ITEM_EXPANDED, wxPropertyGridEvent );
1902wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_PROPGRID, wxEVT_PG_DOUBLE_CLICK, wxPropertyGridEvent );
1903
1904#else
1905 enum {
1906 wxEVT_PG_SELECTED = wxPG_BASE_EVT_PRE_ID,
1907 wxEVT_PG_CHANGING,
1908 wxEVT_PG_CHANGED,
1909 wxEVT_PG_HIGHLIGHTED,
1910 wxEVT_PG_RIGHT_CLICK,
1911 wxEVT_PG_PAGE_CHANGED,
1912 wxEVT_PG_ITEM_COLLAPSED,
1913 wxEVT_PG_ITEM_EXPANDED,
1914 wxEVT_PG_DOUBLE_CLICK
1915 };
1916#endif
1917
1918
1919#define wxPG_BASE_EVT_TYPE wxEVT_PG_SELECTED
1920#define wxPG_MAX_EVT_TYPE (wxPG_BASE_EVT_TYPE+30)
1921
1922
1923#ifndef SWIG
1924typedef void (wxEvtHandler::*wxPropertyGridEventFunction)(wxPropertyGridEvent&);
1925
1926#define EVT_PG_SELECTED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_SELECTED, id, -1, wxEVENT_HANDLER_CAST( wxPropertyGridEventFunction, fn ), NULL ),
1927#define EVT_PG_CHANGING(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_CHANGING, id, -1, wxEVENT_HANDLER_CAST( wxPropertyGridEventFunction, fn ), NULL ),
1928#define EVT_PG_CHANGED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_CHANGED, id, -1, wxEVENT_HANDLER_CAST( wxPropertyGridEventFunction, fn ), NULL ),
1929#define EVT_PG_HIGHLIGHTED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_HIGHLIGHTED, id, -1, wxEVENT_HANDLER_CAST( wxPropertyGridEventFunction, fn ), NULL ),
1930#define EVT_PG_RIGHT_CLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_RIGHT_CLICK, id, -1, wxEVENT_HANDLER_CAST( wxPropertyGridEventFunction, fn ), NULL ),
1931#define EVT_PG_DOUBLE_CLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_DOUBLE_CLICK, id, -1, wxEVENT_HANDLER_CAST( wxPropertyGridEventFunction, fn ), NULL ),
1932#define EVT_PG_PAGE_CHANGED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_PAGE_CHANGED, id, -1, wxEVENT_HANDLER_CAST( wxPropertyGridEventFunction, fn ), NULL ),
1933#define EVT_PG_ITEM_COLLAPSED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_ITEM_COLLAPSED, id, -1, wxEVENT_HANDLER_CAST( wxPropertyGridEventFunction, fn ), NULL ),
1934#define EVT_PG_ITEM_EXPANDED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_ITEM_EXPANDED, id, -1, wxEVENT_HANDLER_CAST( wxPropertyGridEventFunction, fn ), NULL ),
1935
1936#define wxPropertyGridEventHandler(fn) \
1937 wxEVENT_HANDLER_CAST( wxPropertyGridEventFunction, fn )
1938
1939#endif
1940
1941
1942/** @class wxPropertyGridEvent
1943
1944 A propertygrid event holds information about events associated with
1945 wxPropertyGrid objects.
1946
1947 @library{wxpropgrid}
1948 @category{propgrid}
1949*/
1950class WXDLLIMPEXP_PROPGRID wxPropertyGridEvent : public wxCommandEvent
1951{
1952public:
1953
1954 /** Constructor. */
1955 wxPropertyGridEvent(wxEventType commandType=0, int id=0);
1956#ifndef SWIG
1957 /** Copy constructor. */
1958 wxPropertyGridEvent(const wxPropertyGridEvent& event);
1959#endif
1960 /** Destructor. */
1961 ~wxPropertyGridEvent();
1962
1963 /** Copyer. */
1964 virtual wxEvent* Clone() const;
1965
1966 wxPGProperty* GetMainParent() const
1967 {
1968 wxASSERT(m_property);
1969 return m_property->GetMainParent();
1970 }
1971
1972 /** Returns id of associated property. */
1973 wxPGProperty* GetProperty() const
1974 {
1975 return m_property;
1976 }
1977
1978 wxPGValidationInfo& GetValidationInfo()
1979 {
1980 wxASSERT(m_validationInfo);
1981 return *m_validationInfo;
1982 }
1983
1984 /** Returns true if you can veto the action that the event is signaling.
1985 */
1986 bool CanVeto() const { return m_canVeto; }
1987
1988 /**
1989 Call this from your event handler to veto action that the event is
1990 signaling.
1991
1992 You can only veto a shutdown if wxPropertyGridEvent::CanVeto returns
1993 true.
1994 @remarks
1995 Currently only wxEVT_PG_CHANGING supports vetoing.
1996 */
1997 void Veto( bool veto = true ) { m_wasVetoed = veto; }
1998
1999 /** Returns value that is about to be set for wxEVT_PG_CHANGING.
2000 */
2001 const wxVariant& GetValue() const
2002 {
2003 wxASSERT_MSG( m_validationInfo,
2004 "Only call GetValue from a handler "
2005 "of event type that supports it" );
2006 return m_validationInfo->GetValue();
2007 }
2008
2009 /**
2010 Set override validation failure behavior.
2011
2012 Only effective if Veto was also called, and only allowed if event type
2013 is wxEVT_PG_CHANGING.
2014 */
2015 void SetValidationFailureBehavior( wxPGVFBFlags flags )
2016 {
2017 wxASSERT( GetEventType() == wxEVT_PG_CHANGING );
2018 m_validationInfo->SetFailureBehavior( flags );
2019 }
2020
2021 /** Sets custom failure message for this time only. Only applies if
2022 wxPG_VFB_SHOW_MESSAGE is set in validation failure flags.
2023 */
2024 void SetValidationFailureMessage( const wxString& message )
2025 {
2026 wxASSERT( GetEventType() == wxEVT_PG_CHANGING );
2027 m_validationInfo->SetFailureMessage( message );
2028 }
2029
2030#ifndef SWIG
2031 wxPGVFBFlags GetValidationFailureBehavior() const
2032 {
2033 wxASSERT( GetEventType() == wxEVT_PG_CHANGING );
2034 return m_validationInfo->GetFailureBehavior();
2035 }
2036
2037 void SetCanVeto( bool canVeto ) { m_canVeto = canVeto; }
2038 bool WasVetoed() const { return m_wasVetoed; }
2039
2040 /** Changes the associated property. */
2041 void SetProperty( wxPGProperty* p ) { m_property = p; }
2042
2043 void SetPropertyGrid( wxPropertyGrid* pg ) { m_pg = pg; }
2044
2045 void SetupValidationInfo()
2046 {
2047 wxASSERT(m_pg);
2048 wxASSERT( GetEventType() == wxEVT_PG_CHANGING );
2049 m_validationInfo = &m_pg->GetValidationInfo();
2050 }
2051
2052private:
2053 void Init();
2054 DECLARE_DYNAMIC_CLASS(wxPropertyGridEvent)
2055
2056 wxPGProperty* m_property;
2057 wxPropertyGrid* m_pg;
2058 wxPGValidationInfo* m_validationInfo;
2059
2060 bool m_canVeto;
2061 bool m_wasVetoed;
2062
2063#endif
2064};
2065
2066
2067// -----------------------------------------------------------------------
2068
2069/** @class wxPropertyGridPopulator
2070 @ingroup classes
2071 Allows populating wxPropertyGrid from arbitrary text source.
2072*/
2073class WXDLLIMPEXP_PROPGRID wxPropertyGridPopulator
2074{
2075public:
2076 /** Default constructor.
2077 */
2078 wxPropertyGridPopulator();
2079
2080 /** Destructor. */
2081 virtual ~wxPropertyGridPopulator();
2082
2083 void SetState( wxPropertyGridPageState* state );
2084
2085 void SetGrid( wxPropertyGrid* pg );
2086
2087 /** Appends a new property under bottommost parent.
2088 @param propClass
2089 Property class as string.
2090 */
2091 wxPGProperty* Add( const wxString& propClass,
2092 const wxString& propLabel,
2093 const wxString& propName,
2094 const wxString* propValue,
2095 wxPGChoices* pChoices = NULL );
2096
2097 /**
2098 Pushes property to the back of parent array (ie it becomes bottommost
2099 parent), and starts scanning/adding children for it.
2100
2101 When finished, parent array is returned to the original state.
2102 */
2103 void AddChildren( wxPGProperty* property );
2104
2105 /** Adds attribute to the bottommost property.
2106 @param type
2107 Allowed values: "string", (same as string), "int", "bool". Empty string
2108 mean autodetect.
2109 */
2110 bool AddAttribute( const wxString& name,
2111 const wxString& type,
2112 const wxString& value );
2113
2114 /** Called once in AddChildren.
2115 */
2116 virtual void DoScanForChildren() = 0;
2117
2118 /**
2119 Returns id of parent property for which children can currently be
2120 added.
2121 */
2122 wxPGProperty* GetCurParent() const
2123 {
2124 return (wxPGProperty*) m_propHierarchy[m_propHierarchy.size()-1];
2125 }
2126
2127 wxPropertyGridPageState* GetState() { return m_state; }
2128 const wxPropertyGridPageState* GetState() const { return m_state; }
2129
2130 /** Like wxString::ToLong, except allows N% in addition of N.
2131 */
2132 static bool ToLongPCT( const wxString& s, long* pval, long max );
2133
2134 /** Parses strings of format "choice1"[=value1] ... "choiceN"[=valueN] into
2135 wxPGChoices. Registers parsed result using idString (if not empty).
2136 Also, if choices with given id already registered, then don't parse but
2137 return those choices instead.
2138 */
2139 wxPGChoices ParseChoices( const wxString& choicesString,
2140 const wxString& idString );
2141
2142 /** Implement in derived class to do custom process when an error occurs.
2143 Default implementation uses wxLogError.
2144 */
2145 virtual void ProcessError( const wxString& msg );
2146
2147protected:
2148
2149 /** Used property grid. */
2150 wxPropertyGrid* m_pg;
2151
2152 /** Used property grid state. */
2153 wxPropertyGridPageState* m_state;
2154
2155 /** Tree-hierarchy of added properties (that can have children). */
2156 wxArrayPGProperty m_propHierarchy;
2157
2158 /** Hashmap for string-id to wxPGChoicesData mapping. */
2159 wxPGHashMapS2P m_dictIdChoices;
2160};
2161
2162// -----------------------------------------------------------------------
2163
2164//
2165// Undefine macros that are not needed outside propertygrid sources
2166//
2167#ifndef __wxPG_SOURCE_FILE__
2168 #undef wxPG_FL_DESC_REFRESH_REQUIRED
2169 #undef wxPG_FL_SCROLLBAR_DETECTED
2170 #undef wxPG_FL_CREATEDSTATE
2171 #undef wxPG_FL_NOSTATUSBARHELP
2172 #undef wxPG_FL_SCROLLED
2173 #undef wxPG_FL_FOCUS_INSIDE_CHILD
2174 #undef wxPG_FL_FOCUS_INSIDE
2175 #undef wxPG_FL_MOUSE_INSIDE_CHILD
2176 #undef wxPG_FL_CUR_USES_CUSTOM_IMAGE
2177 #undef wxPG_FL_PRIMARY_FILLS_ENTIRE
2178 #undef wxPG_FL_VALUE_MODIFIED
2179 #undef wxPG_FL_MOUSE_INSIDE
2180 #undef wxPG_FL_FOCUSED
2181 #undef wxPG_FL_MOUSE_CAPTURED
2182 #undef wxPG_FL_INITIALIZED
2183 #undef wxPG_FL_ACTIVATION_BY_CLICK
2184 #undef wxPG_FL_DONT_CENTER_SPLITTER
2185 #undef wxPG_SUPPORT_TOOLTIPS
2186 #undef wxPG_DOUBLE_BUFFER
2187 #undef wxPG_ICON_WIDTH
2188 #undef wxPG_USE_RENDERER_NATIVE
2189// Following are needed by the manager headers
2190// #undef const wxString&
2191#endif
2192
2193// -----------------------------------------------------------------------
2194
2195#endif
2196
2197#endif // _WX_PROPGRID_PROPGRID_H_
2198