]> git.saurik.com Git - wxWidgets.git/blame - include/wx/propgrid/propgridiface.h
Change wxPGProperty::SetChoices() to accept 'const wxPGChoices&'
[wxWidgets.git] / include / wx / propgrid / propgridiface.h
CommitLineData
1c4293cb
VZ
1/////////////////////////////////////////////////////////////////////////////
2// Name: wx/propgeid/propgridiface.h
3// Purpose: wxPropertyGridInterface class
4// Author: Jaakko Salli
5// Modified by:
6// Created: 2008-08-24
ea5af9c5 7// RCS-ID: $Id$
1c4293cb
VZ
8// Copyright: (c) Jaakko Salli
9// Licence: wxWindows license
10/////////////////////////////////////////////////////////////////////////////
11
12#ifndef __WX_PROPGRID_PROPGRIDIFACE_H__
13#define __WX_PROPGRID_PROPGRIDIFACE_H__
14
f4bc1aa2
JS
15#if wxUSE_PROPGRID
16
1c4293cb
VZ
17#include "wx/propgrid/property.h"
18#include "wx/propgrid/propgridpagestate.h"
19
20// -----------------------------------------------------------------------
21
1c4293cb
VZ
22/** @section wxPGPropArgCls
23
24 Most property grid functions have this type as their argument, as it can
25 convey a property by either a pointer or name.
26*/
27class WXDLLIMPEXP_PROPGRID wxPGPropArgCls
28{
29public:
30 wxPGPropArgCls() { }
31 wxPGPropArgCls( const wxPGProperty* property )
32 {
33 m_ptr.property = (wxPGProperty*) property;
f3793429 34 m_flags = IsProperty;
1c4293cb
VZ
35 }
36 wxPGPropArgCls( const wxString& str )
37 {
f3793429
JS
38 m_ptr.stringName = &str;
39 m_flags = IsWxString;
1c4293cb
VZ
40 }
41 wxPGPropArgCls( const wxPGPropArgCls& id )
42 {
43 m_ptr = id.m_ptr;
f3793429 44 m_flags = id.m_flags;
1c4293cb
VZ
45 }
46 // This is only needed for wxPython bindings
47 wxPGPropArgCls( wxString* str, bool WXUNUSED(deallocPtr) )
48 {
f3793429
JS
49 m_ptr.stringName = str;
50 m_flags = IsWxString | OwnsWxString;
1c4293cb
VZ
51 }
52 ~wxPGPropArgCls()
53 {
f3793429
JS
54 if ( m_flags & OwnsWxString )
55 delete m_ptr.stringName;
1c4293cb
VZ
56 }
57 wxPGProperty* GetPtr() const
58 {
f3793429 59 wxCHECK( m_flags == IsProperty, NULL );
1c4293cb
VZ
60 return m_ptr.property;
61 }
f3793429 62 wxPGPropArgCls( const char* str )
1c4293cb 63 {
f3793429
JS
64 m_ptr.charName = str;
65 m_flags = IsCharPtr;
1c4293cb 66 }
f3793429
JS
67 wxPGPropArgCls( const wchar_t* str )
68 {
69 m_ptr.wcharName = str;
70 m_flags = IsWCharPtr;
71 }
1c4293cb
VZ
72 /** This constructor is required for NULL. */
73 wxPGPropArgCls( int )
74 {
d3b9f782 75 m_ptr.property = NULL;
f3793429 76 m_flags = IsProperty;
1c4293cb 77 }
f3793429
JS
78 wxPGProperty* GetPtr( wxPropertyGridInterface* iface ) const;
79 wxPGProperty* GetPtr( const wxPropertyGridInterface* iface ) const
1c4293cb 80 {
f3793429 81 return GetPtr((wxPropertyGridInterface*)iface);
1c4293cb
VZ
82 }
83 wxPGProperty* GetPtr0() const { return m_ptr.property; }
f3793429
JS
84 bool HasName() const { return (m_flags != IsProperty); }
85 const wxString& GetName() const { return *m_ptr.stringName; }
1c4293cb 86private:
f3793429
JS
87
88 enum
89 {
90 IsProperty = 0x00,
91 IsWxString = 0x01,
92 IsCharPtr = 0x02,
93 IsWCharPtr = 0x04,
35524f61 94 OwnsWxString = 0x10
f3793429
JS
95 };
96
1c4293cb
VZ
97 union
98 {
99 wxPGProperty* property;
f3793429 100 const char* charName;
f3793429 101 const wchar_t* wcharName;
f3793429 102 const wxString* stringName;
1c4293cb 103 } m_ptr;
f3793429 104 unsigned char m_flags;
1c4293cb
VZ
105};
106
1c4293cb
VZ
107typedef const wxPGPropArgCls& wxPGPropArg;
108
109// -----------------------------------------------------------------------
110
111WXDLLIMPEXP_PROPGRID
112void wxPGTypeOperationFailed( const wxPGProperty* p,
0372d42e
JS
113 const wxString& typestr,
114 const wxString& op );
1c4293cb 115WXDLLIMPEXP_PROPGRID
0372d42e 116void wxPGGetFailed( const wxPGProperty* p, const wxString& typestr );
1c4293cb
VZ
117
118// -----------------------------------------------------------------------
119
120// Helper macro that does necessary preparations when calling
121// some wxPGProperty's member function.
122#define wxPG_PROP_ARG_CALL_PROLOG_0(PROPERTY) \
123 PROPERTY *p = (PROPERTY*)id.GetPtr(this); \
124 if ( !p ) return;
125
126#define wxPG_PROP_ARG_CALL_PROLOG_RETVAL_0(PROPERTY, RETVAL) \
127 PROPERTY *p = (PROPERTY*)id.GetPtr(this); \
128 if ( !p ) return RETVAL;
129
130#define wxPG_PROP_ARG_CALL_PROLOG() \
131 wxPG_PROP_ARG_CALL_PROLOG_0(wxPGProperty)
132
133#define wxPG_PROP_ARG_CALL_PROLOG_RETVAL(RVAL) \
134 wxPG_PROP_ARG_CALL_PROLOG_RETVAL_0(wxPGProperty, RVAL)
135
136#define wxPG_PROP_ID_CONST_CALL_PROLOG() \
137 wxPG_PROP_ARG_CALL_PROLOG_0(const wxPGProperty)
138
139#define wxPG_PROP_ID_CONST_CALL_PROLOG_RETVAL(RVAL) \
140 wxPG_PROP_ARG_CALL_PROLOG_RETVAL_0(const wxPGProperty, RVAL)
141
142// -----------------------------------------------------------------------
143
144
145/** @class wxPropertyGridInterface
146
147 Most of the shared property manipulation interface shared by wxPropertyGrid,
148 wxPropertyGridPage, and wxPropertyGridManager is defined in this class.
149
150 @remarks
151 - In separate wxPropertyGrid component this class was known as
152 wxPropertyContainerMethods.
153
154 @library{wxpropgrid}
155 @category{propgrid}
156*/
157class WXDLLIMPEXP_PROPGRID wxPropertyGridInterface
158{
159public:
160
161 /** Destructor */
162 virtual ~wxPropertyGridInterface() { }
163
1c4293cb
VZ
164 /**
165 Appends property to the list.
166
167 wxPropertyGrid assumes ownership of the object.
168 Becomes child of most recently added category.
169 @remarks
170 - wxPropertyGrid takes the ownership of the property pointer.
171 - If appending a category with name identical to a category already in
172 the wxPropertyGrid, then newly created category is deleted, and most
173 recently added category (under which properties are appended) is set
174 to the one with same name. This allows easier adding of items to same
175 categories in multiple passes.
176 - Does not automatically redraw the control, so you may need to call
177 Refresh when calling this function after control has been shown for
178 the first time.
179 */
180 wxPGProperty* Append( wxPGProperty* property );
181
182 wxPGProperty* AppendIn( wxPGPropArg id, wxPGProperty* newproperty );
183
184 /**
185 In order to add new items into a property with fixed children (for
186 instance, wxFlagsProperty), you need to call this method. After
187 populating has been finished, you need to call EndAddChildren.
188 */
189 void BeginAddChildren( wxPGPropArg id );
190
191 /** Deletes all properties.
192 */
193 virtual void Clear() = 0;
194
1621f192
JS
195 /**
196 Clears current selection, if any.
197
198 @param validation
199 If set to @false, deselecting the property will always work,
200 even if its editor had invalid value in it.
201
202 @return Returns @true if successful or if there was no selection. May
203 fail if validation was enabled and active editor had invalid
204 value.
01b5ad3b
JS
205
206 @remarks In wxPropertyGrid 1.4, this member function used to send
207 wxPG_EVT_SELECTED. In wxWidgets 2.9 and later, it no longer
208 does that.
1621f192 209 */
01b5ad3b 210 bool ClearSelection( bool validation = false );
1c4293cb
VZ
211
212 /** Resets modified status of all properties.
213 */
89b44158 214 void ClearModifiedStatus();
1c4293cb
VZ
215
216 /** Collapses given category or property with children.
217 Returns true if actually collapses.
218 */
219 bool Collapse( wxPGPropArg id );
220
221 /** Collapses all items that can be collapsed.
222
223 @return
224 Return false if failed (may fail if editor value cannot be validated).
225 */
226 bool CollapseAll() { return ExpandAll(false); }
227
228 /**
229 Changes value of a property, as if from an editor.
230 Use this instead of SetPropertyValue() if you need the value to run
231 through validation process, and also send the property change event.
232
233 @return
234 Returns true if value was successfully changed.
235 */
236 bool ChangePropertyValue( wxPGPropArg id, wxVariant newValue );
237
1c4293cb 238 /**
f231df8a
JS
239 Removes and deletes a property and any children.
240
241 @param id
242 Pointer or name of a property.
243
244 @remarks If you delete a property in a wxPropertyGrid event
245 handler, the actual deletion is postponed until the next
246 idle event.
247
248 This functions deselects selected property, if any.
249 Validation failure option wxPG_VFB_STAY_IN_PROPERTY is not
250 respected, ie. selection is cleared even if editor had
251 invalid value.
252 */
1c4293cb
VZ
253 void DeleteProperty( wxPGPropArg id );
254
f915d44b 255 /**
f231df8a
JS
256 Removes a property. Does not delete the property object, but
257 instead returns it.
f915d44b
JS
258
259 @param id
260 Pointer or name of a property.
261
262 @remarks Removed property cannot have any children.
f231df8a
JS
263
264 Also, if you remove property in a wxPropertyGrid event
265 handler, the actual removal is postponed until the next
266 idle event.
f915d44b
JS
267 */
268 wxPGProperty* RemoveProperty( wxPGPropArg id );
269
1c4293cb
VZ
270 /** Disables property. */
271 bool DisableProperty( wxPGPropArg id ) { return EnableProperty(id,false); }
272
273 /**
274 Returns true if all property grid data changes have been committed.
275
276 Usually only returns false if value in active editor has been
277 invalidated by a wxValidator.
278 */
279 bool EditorValidate();
280
281 /**
282 Enables or disables property, depending on whether enable is true or
283 false.
284 */
285 bool EnableProperty( wxPGPropArg id, bool enable = true );
286
287 /** Called after population of property with fixed children has finished.
288 */
289 void EndAddChildren( wxPGPropArg id );
290
291 /** Expands given category or property with children.
292 Returns true if actually expands.
293 */
294 bool Expand( wxPGPropArg id );
295
296 /** Expands all items that can be expanded.
297 */
298 bool ExpandAll( bool expand = true );
299
1c4293cb
VZ
300 /** Returns id of first child of given property.
301 @remarks
302 Does not return sub-properties!
303 */
304 wxPGProperty* GetFirstChild( wxPGPropArg id )
305 {
306 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
307
308 if ( !p->GetChildCount() || p->HasFlag(wxPG_PROP_AGGREGATE) )
309 return wxNullProperty;
310
311 return p->Item(0);
312 }
313
314 //@{
315 /** Returns iterator class instance.
316 @param flags
317 See @ref propgrid_iterator_flags. Value wxPG_ITERATE_DEFAULT causes
318 iteration over everything except private child properties.
319 @param firstProp
320 Property to start iteration from. If NULL, then first child of root
321 is used.
322 @param startPos
323 Either wxTOP or wxBOTTOM. wxTOP will indicate that iterations start
324 from the first property from the top, and wxBOTTOM means that the
325 iteration will instead begin from bottommost valid item.
326 */
327 wxPropertyGridIterator GetIterator( int flags = wxPG_ITERATE_DEFAULT,
328 wxPGProperty* firstProp = NULL )
329 {
330 return wxPropertyGridIterator( m_pState, flags, firstProp );
331 }
332
333 wxPropertyGridConstIterator
334 GetIterator( int flags = wxPG_ITERATE_DEFAULT,
335 wxPGProperty* firstProp = NULL ) const
336 {
337 return wxPropertyGridConstIterator( m_pState, flags, firstProp );
338 }
339
340 wxPropertyGridIterator GetIterator( int flags, int startPos )
341 {
342 return wxPropertyGridIterator( m_pState, flags, startPos );
343 }
344
345 wxPropertyGridConstIterator GetIterator( int flags, int startPos ) const
346 {
347 return wxPropertyGridConstIterator( m_pState, flags, startPos );
348 }
349 //@}
350
351 /** Returns id of first item, whether it is a category or property.
352 @param flags
353 @link iteratorflags List of iterator flags@endlink
354 */
355 wxPGProperty* GetFirst( int flags = wxPG_ITERATE_ALL )
356 {
357 wxPropertyGridIterator it( m_pState, flags, wxNullProperty, 1 );
358 return *it;
359 }
360
361 const wxPGProperty* GetFirst( int flags = wxPG_ITERATE_ALL ) const
362 {
363 return ((wxPropertyGridInterface*)this)->GetFirst(flags);
364 }
365
366 /**
d85635c5
JS
367 Returns pointer to a property with given name (case-sensitive).
368 If there is no property with such name, @NULL pointer is returned.
1c4293cb 369
d85635c5
JS
370 @remarks Properties which have non-category, non-root parent
371 can not be accessed globally by their name. Instead, use
372 "<property>.<subproperty>" instead of "<subproperty>".
1c4293cb
VZ
373 */
374 wxPGProperty* GetProperty( const wxString& name ) const
375 {
376 return GetPropertyByName(name);
377 }
378
379 /** Returns map-like storage of property's attributes.
380 @remarks
381 Note that if extra style wxPG_EX_WRITEONLY_BUILTIN_ATTRIBUTES is set,
382 then builtin-attributes are not included in the storage.
383 */
384 const wxPGAttributeStorage& GetPropertyAttributes( wxPGPropArg id ) const
385 {
e9cc4973
JS
386 // If 'id' refers to invalid property, then we will return dummy
387 // attributes (ie. root property's attributes, which contents should
388 // should always be empty and of no consequence).
389 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(m_pState->DoGetRoot()->GetAttributes());
1c4293cb
VZ
390 return p->GetAttributes();
391 }
392
393 /** Adds to 'targetArr' pointers to properties that have given
394 flags 'flags' set. However, if 'inverse' is set to true, then
395 only properties without given flags are stored.
396 @param flags
397 Property flags to use.
398 @param iterFlags
399 Iterator flags to use. Default is everything expect private children.
400 */
401 void GetPropertiesWithFlag( wxArrayPGProperty* targetArr,
402 wxPGProperty::FlagType flags,
403 bool inverse = false,
404 int iterFlags = wxPG_ITERATE_PROPERTIES |
405 wxPG_ITERATE_HIDDEN |
406 wxPG_ITERATE_CATEGORIES) const;
407
408 /** Returns value of given attribute. If none found, returns NULL-variant.
409 */
410 wxVariant GetPropertyAttribute( wxPGPropArg id,
411 const wxString& attrName ) const
412 {
413 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullVariant)
414 return p->GetAttribute(attrName);
415 }
416
417 /** Returns pointer of property's nearest parent category. If no category
418 found, returns NULL.
419 */
420 wxPropertyCategory* GetPropertyCategory( wxPGPropArg id ) const
421 {
422 wxPG_PROP_ID_CONST_CALL_PROLOG_RETVAL(NULL)
423 return m_pState->GetPropertyCategory(p);
424 }
425
1c4293cb
VZ
426 /** Returns client data (void*) of a property. */
427 void* GetPropertyClientData( wxPGPropArg id ) const
428 {
429 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
430 return p->GetClientData();
431 }
1c4293cb
VZ
432
433 /**
434 Returns first property which label matches given string.
435
436 NULL if none found. Note that this operation is extremely slow when
437 compared to GetPropertyByName().
438 */
439 wxPGProperty* GetPropertyByLabel( const wxString& label ) const;
440
441 /** Returns property with given name. NULL if none found.
442 */
443 wxPGProperty* GetPropertyByName( const wxString& name ) const;
444
445 /** Returns child property 'subname' of property 'name'. Same as
446 calling GetPropertyByName("name.subname"), albeit slightly faster.
447 */
448 wxPGProperty* GetPropertyByName( const wxString& name,
449 const wxString& subname ) const;
450
1c4293cb
VZ
451 /** Returns property's editor. */
452 const wxPGEditor* GetPropertyEditor( wxPGPropArg id ) const
453 {
454 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
455 return p->GetEditorClass();
456 }
457
458 /** Returns help string associated with a property. */
459 wxString GetPropertyHelpString( wxPGPropArg id ) const
460 {
461 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(m_emptyString)
462 return p->GetHelpString();
463 }
464
465 /** Returns property's custom value image (NULL of none). */
466 wxBitmap* GetPropertyImage( wxPGPropArg id ) const
467 {
468 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
469 return p->GetValueImage();
470 }
471
1c4293cb
VZ
472 /** Returns label of a property. */
473 const wxString& GetPropertyLabel( wxPGPropArg id )
474 {
475 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(m_emptyString)
476 return p->GetLabel();
477 }
478
479 /** Returns name of a property, by which it is globally accessible. */
effb029c 480 wxString GetPropertyName( wxPGProperty* property )
1c4293cb 481 {
effb029c 482 return property->GetName();
1c4293cb
VZ
483 }
484
485 /** Returns parent item of a property. */
486 wxPGProperty* GetPropertyParent( wxPGPropArg id )
487 {
488 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
489 return p->GetParent();
490 }
491
492#if wxUSE_VALIDATORS
493 /** Returns validator of a property as a reference, which you
494 can pass to any number of SetPropertyValidator.
495 */
496 wxValidator* GetPropertyValidator( wxPGPropArg id )
497 {
498 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
499 return p->GetValidator();
500 }
501#endif
502
503 /** Returns value as wxVariant. To get wxObject pointer from it,
504 you will have to use WX_PG_VARIANT_TO_WXOBJECT(VARIANT,CLASSNAME) macro.
505
506 If property value is unspecified, Null variant is returned.
507 */
508 wxVariant GetPropertyValue( wxPGPropArg id )
509 {
510 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxVariant())
511 return p->GetValue();
512 }
513
514 wxString GetPropertyValueAsString( wxPGPropArg id ) const;
515 long GetPropertyValueAsLong( wxPGPropArg id ) const;
516 unsigned long GetPropertyValueAsULong( wxPGPropArg id ) const
517 {
518 return (unsigned long) GetPropertyValueAsLong(id);
519 }
1c4293cb
VZ
520 int GetPropertyValueAsInt( wxPGPropArg id ) const
521 { return (int)GetPropertyValueAsLong(id); }
1c4293cb
VZ
522 bool GetPropertyValueAsBool( wxPGPropArg id ) const;
523 double GetPropertyValueAsDouble( wxPGPropArg id ) const;
1c4293cb
VZ
524
525#define wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(TYPENAME, DEFVAL) \
526 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(DEFVAL) \
0372d42e
JS
527 wxString typeName(wxS(TYPENAME)); \
528 wxVariant value = p->GetValue(); \
529 if ( value.GetType() != typeName ) \
1c4293cb 530 { \
0372d42e 531 wxPGGetFailed(p, typeName); \
1c4293cb
VZ
532 return DEFVAL; \
533 }
534
535#define wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL_WFALLBACK(TYPENAME, DEFVAL) \
536 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(DEFVAL) \
0372d42e
JS
537 wxVariant value = p->GetValue(); \
538 if ( value.GetType() != wxS(TYPENAME) ) \
1c4293cb
VZ
539 return DEFVAL; \
540
541 wxArrayString GetPropertyValueAsArrayString( wxPGPropArg id ) const
542 {
0372d42e 543 wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL("arrstring",
1c4293cb 544 wxArrayString())
0372d42e 545 return value.GetArrayString();
1c4293cb
VZ
546 }
547
4e00b908 548#ifdef wxLongLong_t
1c4293cb
VZ
549 wxLongLong_t GetPropertyValueAsLongLong( wxPGPropArg id ) const
550 {
4e00b908
JS
551 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(0)
552 return p->GetValue().GetLongLong().GetValue();
1c4293cb
VZ
553 }
554
555 wxULongLong_t GetPropertyValueAsULongLong( wxPGPropArg id ) const
556 {
4e00b908
JS
557 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(0)
558 return p->GetValue().GetULongLong().GetValue();
1c4293cb 559 }
0dc44cac 560#endif
1c4293cb
VZ
561
562 wxArrayInt GetPropertyValueAsArrayInt( wxPGPropArg id ) const
563 {
0372d42e 564 wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL("wxArrayInt",
1c4293cb 565 wxArrayInt())
0372d42e
JS
566 wxArrayInt arr;
567 arr << value;
1c4293cb
VZ
568 return arr;
569 }
570
571#if wxUSE_DATETIME
572 wxDateTime GetPropertyValueAsDateTime( wxPGPropArg id ) const
573 {
0372d42e
JS
574 wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL("datetime",
575 wxDateTime())
576 return value.GetDateTime();
1c4293cb
VZ
577 }
578#endif
579
1c4293cb
VZ
580 /** Returns a wxVariant list containing wxVariant versions of all
581 property values. Order is not guaranteed.
582 @param flags
583 Use wxPG_KEEP_STRUCTURE to retain category structure; each sub
584 category will be its own wxVariantList of wxVariant.
585 Use wxPG_INC_ATTRIBUTES to include property attributes as well.
586 Each attribute will be stored as list variant named
587 "@@<propname>@@attr."
588 @remarks
589 */
590 wxVariant GetPropertyValues( const wxString& listname = wxEmptyString,
591 wxPGProperty* baseparent = NULL, long flags = 0 ) const
592 {
593 return m_pState->DoGetPropertyValues(listname, baseparent, flags);
594 }
1c4293cb 595
fc72fab6
JS
596 /**
597 Returns currently selected property. NULL if none.
598
599 @remarks When wxPG_EX_MULTIPLE_SELECTION extra style is used, this
600 member function returns the focused property, that is the
601 one which can have active editor.
602 */
603 wxPGProperty* GetSelection() const;
604
605 /**
606 Returns list of currently selected properties.
607
608 @remarks wxArrayPGProperty should be compatible with std::vector API.
609 */
610 const wxArrayPGProperty& GetSelectedProperties() const
1c4293cb 611 {
fc72fab6 612 return m_pState->m_selection;
1c4293cb
VZ
613 }
614
1c4293cb 615 wxPropertyGridPageState* GetState() const { return m_pState; }
1c4293cb
VZ
616
617 /** Similar to GetIterator(), but instead returns wxPGVIterator instance,
618 which can be useful for forward-iterating through arbitrary property
619 containers.
620
621 @param flags
622 See @ref propgrid_iterator_flags.
623 */
624 virtual wxPGVIterator GetVIterator( int flags ) const;
625
626 /** Hides or reveals a property.
627 @param hide
628 If true, hides property, otherwise reveals it.
629 @param flags
630 By default changes are applied recursively. Set this paramter
631 wxPG_DONT_RECURSE to prevent this.
632 */
633 bool HideProperty( wxPGPropArg id,
634 bool hide = true,
635 int flags = wxPG_RECURSE );
636
637#if wxPG_INCLUDE_ADVPROPS
638 /** Initializes *all* property types. Causes references to most object
639 files in the library, so calling this may cause significant increase
640 in executable size when linking with static library.
641 */
642 static void InitAllTypeHandlers();
643#else
644 static void InitAllTypeHandlers() { }
645#endif
646
647 //@{
648 /** Inserts property to the property container.
649
650 @param priorThis
651 New property is inserted just prior to this. Available only
652 in the first variant. There are two versions of this function
653 to allow this parameter to be either an id or name to
654 a property.
655
656 @param newproperty
657 Pointer to the inserted property. wxPropertyGrid will take
658 ownership of this object.
659
660 @param parent
661 New property is inserted under this category. Available only
662 in the second variant. There are two versions of this function
663 to allow this parameter to be either an id or name to
664 a property.
665
666 @param index
667 Index under category. Available only in the second variant.
668 If index is < 0, property is appended in category.
669
670 @return
671 Returns id for the property,
672
673 @remarks
674
675 - wxPropertyGrid takes the ownership of the property pointer.
676
677 - While Append may be faster way to add items, make note that when
678 both types of data storage (categoric and
679 non-categoric) are active, Insert becomes even more slow. This is
680 especially true if current mode is non-categoric.
681
682 Example of use:
683
684 @code
685
686 // append category
687 wxPGProperty* my_cat_id = propertygrid->Append(
688 new wxPropertyCategory("My Category") );
689
690 ...
691
692 // insert into category - using second variant
693 wxPGProperty* my_item_id_1 = propertygrid->Insert(
694 my_cat_id, 0, new wxStringProperty("My String 1") );
695
696 // insert before to first item - using first variant
697 wxPGProperty* my_item_id_2 = propertygrid->Insert(
698 my_item_id, new wxStringProperty("My String 2") );
699
700 @endcode
701
702 */
703 wxPGProperty* Insert( wxPGPropArg priorThis, wxPGProperty* newproperty );
704 wxPGProperty* Insert( wxPGPropArg parent,
705 int index,
706 wxPGProperty* newproperty );
707 //@}
708
709 /** Returns true if property is a category. */
710 bool IsPropertyCategory( wxPGPropArg id ) const
711 {
712 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
713 return p->IsCategory();
714 }
715
1c4293cb
VZ
716 /** Returns true if property is enabled. */
717 bool IsPropertyEnabled( wxPGPropArg id ) const
718 {
719 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
720 return (!(p->GetFlags() & wxPG_PROP_DISABLED))?true:false;
721 }
722
723 /**
724 Returns true if given property is expanded.
725
726 Naturally, always returns false for properties that cannot be expanded.
727 */
728 bool IsPropertyExpanded( wxPGPropArg id ) const;
729
730 /**
731 Returns true if property has been modified after value set or modify
732 flag clear by software.
733 */
734 bool IsPropertyModified( wxPGPropArg id ) const
735 {
736 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
737 return ( (p->GetFlags() & wxPG_PROP_MODIFIED) ? true : false );
738 }
739
fc72fab6
JS
740 /**
741 Returns true if property is selected.
742 */
743 bool IsPropertySelected( wxPGPropArg id ) const
744 {
745 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
746 return m_pState->DoIsPropertySelected(p);
747 }
748
1c4293cb
VZ
749 /**
750 Returns true if property is shown (ie hideproperty with true not
751 called for it).
fc72fab6 752 */
1c4293cb
VZ
753 bool IsPropertyShown( wxPGPropArg id ) const
754 {
755 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
756 return (!(p->GetFlags() & wxPG_PROP_HIDDEN))?true:false;
757 }
758
759 /** Returns true if property value is set to unspecified.
760 */
761 bool IsPropertyValueUnspecified( wxPGPropArg id ) const
762 {
763 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
764 return p->IsValueUnspecified();
765 }
766
767 /**
768 Disables (limit = true) or enables (limit = false) wxTextCtrl editor of
769 a property, if it is not the sole mean to edit the value.
770 */
771 void LimitPropertyEditing( wxPGPropArg id, bool limit = true );
772
773 /** If state is shown in it's grid, refresh it now.
774 */
775 virtual void RefreshGrid( wxPropertyGridPageState* state = NULL );
776
777#if wxPG_INCLUDE_ADVPROPS
778 /**
779 Initializes additional property editors (SpinCtrl etc.). Causes
780 references to most object files in the library, so calling this may
781 cause significant increase in executable size when linking with static
782 library.
783 */
784 static void RegisterAdditionalEditors();
785#else
786 static void RegisterAdditionalEditors() { }
787#endif
788
789 /** Replaces property with id with newly created property. For example,
790 this code replaces existing property named "Flags" with one that
791 will have different set of items:
792 @code
793 pg->ReplaceProperty("Flags",
794 wxFlagsProperty("Flags", wxPG_LABEL, newItems))
795 @endcode
796 For more info, see wxPropertyGrid::Insert.
797 */
798 wxPGProperty* ReplaceProperty( wxPGPropArg id, wxPGProperty* property );
799
800 /** @anchor propgridinterface_editablestate_flags
801
802 Flags for wxPropertyGridInterface::SaveEditableState() and
803 wxPropertyGridInterface::RestoreEditableState().
804 */
805 enum EditableStateFlags
806 {
807 /** Include selected property. */
808 SelectionState = 0x01,
809 /** Include expanded/collapsed property information. */
810 ExpandedState = 0x02,
811 /** Include scrolled position. */
812 ScrollPosState = 0x04,
813 /** Include selected page information.
814 Only applies to wxPropertyGridManager. */
815 PageState = 0x08,
816 /** Include splitter position. Stored for each page. */
817 SplitterPosState = 0x10,
62805170
JS
818 /** Include description box size.
819 Only applies to wxPropertyGridManager. */
820 DescBoxState = 0x20,
1c4293cb
VZ
821
822 /**
823 Include all supported user editable state information.
824 This is usually the default value. */
825 AllStates = SelectionState |
826 ExpandedState |
827 ScrollPosState |
828 PageState |
62805170
JS
829 SplitterPosState |
830 DescBoxState
1c4293cb
VZ
831 };
832
833 /**
834 Restores user-editable state.
835
836 See also wxPropertyGridInterface::SaveEditableState().
837
838 @param src
839 String generated by SaveEditableState.
840
841 @param restoreStates
842 Which parts to restore from source string. See @ref
843 propgridinterface_editablestate_flags "list of editable state
844 flags".
845
846 @return
847 False if there was problem reading the string.
848
849 @remarks
850 If some parts of state (such as scrolled or splitter position) fail to
851 restore correctly, please make sure that you call this function after
852 wxPropertyGrid size has been set (this may sometimes be tricky when
853 sizers are used).
854 */
855 bool RestoreEditableState( const wxString& src,
856 int restoreStates = AllStates );
857
858 /**
859 Used to acquire user-editable state (selected property, expanded
860 properties, scrolled position, splitter positions).
861
862 @param includedStates
863 Which parts of state to include. See @ref
864 propgridinterface_editablestate_flags "list of editable state flags".
865 */
866 wxString SaveEditableState( int includedStates = AllStates ) const;
867
868 /**
869 Lets user to set the strings listed in the choice dropdown of a
870 wxBoolProperty. Defaults are "True" and "False", so changing them to,
871 say, "Yes" and "No" may be useful in some less technical applications.
872 */
873 static void SetBoolChoices( const wxString& trueChoice,
874 const wxString& falseChoice );
875
fe01f16e
JS
876 /**
877 Set proportion of a auto-stretchable column. wxPG_SPLITTER_AUTO_CENTER
878 window style needs to be used to indicate that columns are auto-
879 resizeable.
880
881 @returns Returns @false on failure.
882
883 @remarks You should call this for individual pages of
884 wxPropertyGridManager (if used).
4279fdb4
JS
885
886 @see GetColumnProportion()
fe01f16e
JS
887 */
888 bool SetColumnProportion( unsigned int column, int proportion );
889
4279fdb4
JS
890 /**
891 Returns auto-resize proportion of the given column.
892
893 @see SetColumnProportion()
894 */
895 int GetColumnProportion( unsigned int column ) const
896 {
897 return m_pState->DoGetColumnProportion(column);
898 }
899
1c4293cb
VZ
900 /** Sets an attribute for this property.
901 @param name
902 Text identifier of attribute. See @ref propgrid_property_attributes.
903 @param value
904 Value of attribute.
905 @param argFlags
906 Optional. Use wxPG_RECURSE to set the attribute to child properties
907 recursively.
908 */
909 void SetPropertyAttribute( wxPGPropArg id,
910 const wxString& attrName,
911 wxVariant value,
912 long argFlags = 0 )
913 {
914 DoSetPropertyAttribute(id,attrName,value,argFlags);
915 }
916
3c26d11b
JS
917 /** Sets property attribute for all applicapple properties.
918 Be sure to use this method only after all properties have been
919 added to the grid.
920 */
921 void SetPropertyAttributeAll( const wxString& attrName, wxVariant value );
922
e2ca6599
JS
923 /**
924 Sets background colour of a property.
925
926 @param id
927 Property name or pointer.
928
929 @param colour
930 New background colour.
931
e607eac2
JS
932 @param flags
933 Default is wxPG_RECURSE which causes colour to be set recursively.
934 Omit this flag to only set colour for the property in question
935 and not any of its children.
e2ca6599
JS
936 */
937 void SetPropertyBackgroundColour( wxPGPropArg id,
938 const wxColour& colour,
e607eac2 939 int flags = wxPG_RECURSE );
e2ca6599
JS
940
941 /** Resets text and background colours of given property.
942 */
943 void SetPropertyColoursToDefault( wxPGPropArg id );
944
945 /**
946 Sets text colour of a property.
947
948 @param id
949 Property name or pointer.
950
951 @param colour
952 New background colour.
953
e607eac2
JS
954 @param flags
955 Default is wxPG_RECURSE which causes colour to be set recursively.
956 Omit this flag to only set colour for the property in question
957 and not any of its children.
e2ca6599
JS
958 */
959 void SetPropertyTextColour( wxPGPropArg id,
960 const wxColour& col,
e607eac2 961 int flags = wxPG_RECURSE );
e2ca6599
JS
962
963 /**
964 Returns background colour of first cell of a property.
965 */
966 wxColour GetPropertyBackgroundColour( wxPGPropArg id ) const
967 {
968 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxColour())
969 return p->GetCell(0).GetBgCol();
970 }
971
972 /**
973 Returns text colour of first cell of a property.
974 */
975 wxColour GetPropertyTextColour( wxPGPropArg id ) const
976 {
977 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxColour())
978 return p->GetCell(0).GetFgCol();
979 }
980
1c4293cb
VZ
981 /** Sets text, bitmap, and colours for given column's cell.
982
983 @remarks
984 - You can set label cell by setting column to 0.
985 - You can use wxPG_LABEL as text to use default text for column.
986 */
987 void SetPropertyCell( wxPGPropArg id,
988 int column,
989 const wxString& text = wxEmptyString,
990 const wxBitmap& bitmap = wxNullBitmap,
991 const wxColour& fgCol = wxNullColour,
d7e2b522 992 const wxColour& bgCol = wxNullColour );
1c4293cb 993
1c4293cb
VZ
994 /** Sets client data (void*) of a property.
995 @remarks
996 This untyped client data has to be deleted manually.
997 */
998 void SetPropertyClientData( wxPGPropArg id, void* clientData )
999 {
1000 wxPG_PROP_ARG_CALL_PROLOG()
1001 p->SetClientData(clientData);
1002 }
1003
1004 /** Sets editor for a property.
1005
1006 @param editor
1007 For builtin editors, use wxPGEditor_X, where X is builtin editor's
1008 name (TextCtrl, Choice, etc. see wxPGEditor documentation for full
1009 list).
1010
1011 For custom editors, use pointer you received from
1012 wxPropertyGrid::RegisterEditorClass().
1013 */
1014 void SetPropertyEditor( wxPGPropArg id, const wxPGEditor* editor )
1015 {
1016 wxPG_PROP_ARG_CALL_PROLOG()
1017 wxCHECK_RET( editor, wxT("unknown/NULL editor") );
1018 p->SetEditor(editor);
1019 RefreshProperty(p);
1020 }
1c4293cb
VZ
1021
1022 /** Sets editor control of a property. As editor argument, use
1023 editor name string, such as "TextCtrl" or "Choice".
1024 */
1025 void SetPropertyEditor( wxPGPropArg id, const wxString& editorName )
1026 {
1027 SetPropertyEditor(id,GetEditorByName(editorName));
1028 }
1029
1030 /** Sets label of a property.
1c4293cb
VZ
1031 */
1032 void SetPropertyLabel( wxPGPropArg id, const wxString& newproplabel );
1033
020b0041
JS
1034 /**
1035 Sets name of a property.
1036
1037 @param id
1038 Name or pointer of property which name to change.
1039
1040 @param newName
1041 New name for property.
1042 */
1043 void SetPropertyName( wxPGPropArg id, const wxString& newName )
1044 {
1045 wxPG_PROP_ARG_CALL_PROLOG()
1046 m_pState->DoSetPropertyName( p, newName );
1047 }
1048
1c4293cb
VZ
1049 /**
1050 Sets property (and, recursively, its children) to have read-only value.
1051 In other words, user cannot change the value in the editor, but they
1052 can still copy it.
1053 @remarks
1054 This is mainly for use with textctrl editor. Not all other editors fully
1055 support it.
1056 @param flags
1057 By default changes are applied recursively. Set this paramter
1058 wxPG_DONT_RECURSE to prevent this.
1059 */
1060 void SetPropertyReadOnly( wxPGPropArg id,
1061 bool set = true,
1062 int flags = wxPG_RECURSE )
1063 {
1064 wxPG_PROP_ARG_CALL_PROLOG()
1065 if ( flags & wxPG_RECURSE )
1066 p->SetFlagRecursively(wxPG_PROP_READONLY, set);
1067 else
d58526d5 1068 p->ChangeFlag(wxPG_PROP_READONLY, set);
1c4293cb
VZ
1069 }
1070
1071 /** Sets property's value to unspecified.
1072 If it has children (it may be category), then the same thing is done to
1073 them.
1074 */
daeb4e4d
JS
1075 void SetPropertyValueUnspecified( wxPGPropArg id )
1076 {
1077 wxPG_PROP_ARG_CALL_PROLOG()
269619bf 1078 p->SetValueToUnspecified();
daeb4e4d 1079 }
1c4293cb 1080
c9cc9a2f
JS
1081 /**
1082 Sets property values from a list of wxVariants.
1c4293cb
VZ
1083 */
1084 void SetPropertyValues( const wxVariantList& list,
1085 wxPGPropArg defaultCategory = wxNullProperty )
1086 {
1087 wxPGProperty *p;
1088 if ( defaultCategory.HasName() ) p = defaultCategory.GetPtr(this);
1089 else p = defaultCategory.GetPtr0();
1090 m_pState->DoSetPropertyValues(list, p);
1091 }
1092
c9cc9a2f
JS
1093 /**
1094 Sets property values from a list of wxVariants.
1095 */
1c4293cb
VZ
1096 void SetPropertyValues( const wxVariant& list,
1097 wxPGPropArg defaultCategory = wxNullProperty )
1098 {
1099 SetPropertyValues(list.GetList(),defaultCategory);
1100 }
1c4293cb
VZ
1101
1102 /** Associates the help string with property.
1103 @remarks
1104 By default, text is shown either in the manager's "description"
1105 text box or in the status bar. If extra window style
1106 wxPG_EX_HELP_AS_TOOLTIPS is used, then the text will appear as a
1107 tooltip.
1108 */
1109 void SetPropertyHelpString( wxPGPropArg id, const wxString& helpString )
1110 {
1111 wxPG_PROP_ARG_CALL_PROLOG()
1112 p->SetHelpString(helpString);
1113 }
1114
1115 /** Set wxBitmap in front of the value.
1116 @remarks
1117 - Bitmap will be scaled to a size returned by
1118 wxPropertyGrid::GetImageSize();
1119 */
1120 void SetPropertyImage( wxPGPropArg id, wxBitmap& bmp )
1121 {
1122 wxPG_PROP_ARG_CALL_PROLOG()
1123 p->SetValueImage(bmp);
1124 RefreshProperty(p);
1125 }
1126
1127 /** Sets max length of property's text.
1128 */
1129 bool SetPropertyMaxLength( wxPGPropArg id, int maxLen );
1130
1131#if wxUSE_VALIDATORS
1132 /** Sets validator of a property.
1133 */
1134 void SetPropertyValidator( wxPGPropArg id, const wxValidator& validator )
1135 {
1136 wxPG_PROP_ARG_CALL_PROLOG()
1137 p->SetValidator(validator);
1138 }
1139#endif
1140
1c4293cb
VZ
1141 /** Sets value (long integer) of a property.
1142 */
1143 void SetPropertyValue( wxPGPropArg id, long value )
1144 {
1145 wxVariant v(value);
1146 SetPropVal( id, v );
1147 }
1148
1149 /** Sets value (integer) of a property.
1150 */
1151 void SetPropertyValue( wxPGPropArg id, int value )
1152 {
1153 wxVariant v((long)value);
1154 SetPropVal( id, v );
1155 }
1156 /** Sets value (floating point) of a property.
1157 */
1158 void SetPropertyValue( wxPGPropArg id, double value )
1159 {
1160 wxVariant v(value);
1161 SetPropVal( id, v );
1162 }
1163 /** Sets value (bool) of a property.
1164 */
1165 void SetPropertyValue( wxPGPropArg id, bool value )
1166 {
1167 wxVariant v(value);
1168 SetPropVal( id, v );
1169 }
a6f2417d
JS
1170 void SetPropertyValue( wxPGPropArg id, const wchar_t* value )
1171 {
1172 SetPropertyValueString( id, wxString(value) );
1173 }
a6f2417d 1174 void SetPropertyValue( wxPGPropArg id, const char* value )
1c4293cb
VZ
1175 {
1176 SetPropertyValueString( id, wxString(value) );
1177 }
1178 void SetPropertyValue( wxPGPropArg id, const wxString& value )
1179 {
1180 SetPropertyValueString( id, value );
1181 }
1182
1183 /** Sets value (wxArrayString) of a property.
1184 */
1185 void SetPropertyValue( wxPGPropArg id, const wxArrayString& value )
1186 {
1187 wxVariant v(value);
1188 SetPropVal( id, v );
1189 }
1190
1191#if wxUSE_DATETIME
1192 void SetPropertyValue( wxPGPropArg id, const wxDateTime& value )
1193 {
1194 wxVariant v(value);
1195 SetPropVal( id, v );
1196 }
1197#endif
1198
1199 /** Sets value (wxObject*) of a property.
1200 */
1201 void SetPropertyValue( wxPGPropArg id, wxObject* value )
1202 {
1203 wxVariant v(value);
1204 SetPropVal( id, v );
1205 }
1206
1207 void SetPropertyValue( wxPGPropArg id, wxObject& value )
1208 {
1209 wxVariant v(&value);
1210 SetPropVal( id, v );
1211 }
1212
4e00b908 1213#ifdef wxLongLong_t
1c4293cb
VZ
1214 /** Sets value (wxLongLong&) of a property.
1215 */
1216 void SetPropertyValue( wxPGPropArg id, wxLongLong_t value )
1217 {
1218 wxVariant v = WXVARIANT(wxLongLong(value));
1219 SetPropVal( id, v );
1220 }
1221 /** Sets value (wxULongLong&) of a property.
1222 */
1223 void SetPropertyValue( wxPGPropArg id, wxULongLong_t value )
1224 {
1225 wxVariant v = WXVARIANT(wxULongLong(value));
1226 SetPropVal( id, v );
1227 }
0dc44cac
JS
1228#endif
1229
1c4293cb
VZ
1230 /** Sets value (wxArrayInt&) of a property.
1231 */
1232 void SetPropertyValue( wxPGPropArg id, const wxArrayInt& value )
1233 {
1234 wxVariant v = WXVARIANT(value);
1235 SetPropVal( id, v );
1236 }
1c4293cb
VZ
1237
1238 /** Sets value (wxString) of a property.
1239
1240 @remarks
1241 This method uses wxPGProperty::SetValueFromString, which all properties
1242 should implement. This means that there should not be a type error,
1243 and instead the string is converted to property's actual value type.
1244 */
1245 void SetPropertyValueString( wxPGPropArg id, const wxString& value );
1246
1247 /** Sets value (wxVariant&) of a property.
1248
1249 @remarks
1250 Use wxPropertyGrid::ChangePropertyValue() instead if you need to run
1251 through validation process and send property change event.
1252 */
1253 void SetPropertyValue( wxPGPropArg id, wxVariant value )
1254 {
1255 SetPropVal( id, value );
1256 }
1257
1c4293cb
VZ
1258 /** Sets value (wxVariant&) of a property. Same as SetPropertyValue, but
1259 accepts reference. */
1260 void SetPropVal( wxPGPropArg id, wxVariant& value );
1c4293cb
VZ
1261
1262 /** Adjusts how wxPropertyGrid behaves when invalid value is entered
1263 in a property.
1264 @param vfbFlags
1265 See @link vfbflags list of valid flags values@endlink
1266 */
1267 void SetValidationFailureBehavior( int vfbFlags );
1268
43396981 1269 /**
0eb877f2
JS
1270 Sorts all properties recursively.
1271
1272 @param flags
1273 This can contain any of the following options:
1274 wxPG_SORT_TOP_LEVEL_ONLY: Only sort categories and their
1275 immediate children. Sorting done by wxPG_AUTO_SORT option
1276 uses this.
43396981
JS
1277
1278 @see SortChildren, wxPropertyGrid::SetSortFunction
1279 */
0eb877f2 1280 void Sort( int flags = 0 );
43396981
JS
1281
1282 /**
1283 Sorts children of a property.
1284
1285 @param id
1286 Name or pointer to a property.
1287
0eb877f2
JS
1288 @param flags
1289 This can contain any of the following options:
1290 wxPG_RECURSE: Sorts recursively.
43396981
JS
1291
1292 @see Sort, wxPropertyGrid::SetSortFunction
1293 */
0eb877f2 1294 void SortChildren( wxPGPropArg id, int flags = 0 )
43396981
JS
1295 {
1296 wxPG_PROP_ARG_CALL_PROLOG()
0eb877f2 1297 m_pState->DoSortChildren(p, flags);
43396981
JS
1298 }
1299
1c4293cb
VZ
1300 // GetPropertyByName With nice assertion error message.
1301 wxPGProperty* GetPropertyByNameA( const wxString& name ) const;
1302
1303 static wxPGEditor* GetEditorByName( const wxString& editorName );
1304
58935d4a
JS
1305 // NOTE: This function reselects the property and may cause
1306 // excess flicker, so to just call Refresh() on a rect
1307 // of single property, call DrawItem() instead.
1c4293cb
VZ
1308 virtual void RefreshProperty( wxPGProperty* p ) = 0;
1309
1310protected:
1311
fc72fab6
JS
1312 bool DoClearSelection( bool validation = false,
1313 int selFlags = 0 );
1314
62805170
JS
1315 /**
1316 In derived class, implement to set editable state component with
1317 given name to given value.
1318 */
1319 virtual bool SetEditableStateItem( const wxString& name, wxVariant value )
1320 {
1321 wxUnusedVar(name);
1322 wxUnusedVar(value);
1323 return false;
1324 }
1325
1326 /**
1327 In derived class, implement to return editable state component with
1328 given name.
1329 */
1330 virtual wxVariant GetEditableStateItem( const wxString& name ) const
1331 {
1332 wxUnusedVar(name);
1333 return wxNullVariant;
1334 }
1335
1c4293cb
VZ
1336 // Returns page state data for given (sub) page (-1 means current page).
1337 virtual wxPropertyGridPageState* GetPageState( int pageIndex ) const
1338 {
1339 if ( pageIndex <= 0 )
1340 return m_pState;
1341 return NULL;
1342 }
1343
1344 virtual bool DoSelectPage( int WXUNUSED(index) ) { return true; }
1345
1346 // Default call's m_pState's BaseGetPropertyByName
1347 virtual wxPGProperty* DoGetPropertyByName( const wxString& name ) const;
1348
1c4293cb
VZ
1349 // Deriving classes must set this (it must be only or current page).
1350 wxPropertyGridPageState* m_pState;
1351
1352 // Intermediate version needed due to wxVariant copying inefficiency
1353 void DoSetPropertyAttribute( wxPGPropArg id,
1354 const wxString& name,
1355 wxVariant& value, long argFlags );
1356
1357 // Empty string object to return from member functions returning const
1358 // wxString&.
1359 wxString m_emptyString;
1360
1361private:
1362 // Cannot be GetGrid() due to ambiguity issues.
1363 wxPropertyGrid* GetPropertyGrid()
1364 {
9a30da4d
JS
1365 if ( !m_pState )
1366 return NULL;
1c4293cb
VZ
1367 return m_pState->GetGrid();
1368 }
1369
1370 // Cannot be GetGrid() due to ambiguity issues.
1371 const wxPropertyGrid* GetPropertyGrid() const
1372 {
9a30da4d
JS
1373 if ( !m_pState )
1374 return NULL;
1375 return static_cast<const wxPropertyGrid*>(m_pState->GetGrid());
1c4293cb 1376 }
1c4293cb
VZ
1377
1378 friend class wxPropertyGrid;
1379 friend class wxPropertyGridManager;
1380};
1381
f4bc1aa2
JS
1382#endif // wxUSE_PROPGRID
1383
1c4293cb 1384#endif // __WX_PROPGRID_PROPGRIDIFACE_H__