]> git.saurik.com Git - wxWidgets.git/blame - include/wx/propgrid/propgridiface.h
wxVariant list used to translate between list of property child values and composite...
[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
7// RCS-ID: $Id:
8// Copyright: (c) Jaakko Salli
9// Licence: wxWindows license
10/////////////////////////////////////////////////////////////////////////////
11
12#ifndef __WX_PROPGRID_PROPGRIDIFACE_H__
13#define __WX_PROPGRID_PROPGRIDIFACE_H__
14
15#include "wx/propgrid/property.h"
16#include "wx/propgrid/propgridpagestate.h"
17
18// -----------------------------------------------------------------------
19
20#ifndef SWIG
21
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;
34 m_isName = false;
35 }
36 wxPGPropArgCls( const wxString& str )
37 {
38 m_ptr.name = &str;
39 m_isName = 1;
40 }
41 wxPGPropArgCls( const wxPGPropArgCls& id )
42 {
43 m_ptr = id.m_ptr;
44 m_isName = id.m_isName;
45 }
46 // This is only needed for wxPython bindings
47 wxPGPropArgCls( wxString* str, bool WXUNUSED(deallocPtr) )
48 {
49 m_ptr.name = str;
50 m_isName = 3; // Like 1, but causes ptr to be deallocated in dtor
51 }
52 ~wxPGPropArgCls()
53 {
54 if ( m_isName == 3 )
55 delete m_ptr.name;
56 }
57 wxPGProperty* GetPtr() const
58 {
59 wxCHECK( !m_isName, NULL );
60 return m_ptr.property;
61 }
62 wxPGPropArgCls( const wxChar* str )
63 {
64 m_ptr.rawname = str;
65 m_isName = 2;
66 }
67 /** This constructor is required for NULL. */
68 wxPGPropArgCls( int )
69 {
70 m_ptr.property = (wxPGProperty*) NULL;
71 m_isName = false;
72 }
73 wxPGProperty* GetPtr( wxPropertyGridInterface* methods ) const;
74 wxPGProperty* GetPtr( const wxPropertyGridInterface* methods ) const
75 {
76 return GetPtr((wxPropertyGridInterface*)methods);
77 }
78 wxPGProperty* GetPtr0() const { return m_ptr.property; }
79 unsigned char HasName() const { return m_isName; }
80 const wxString& GetName() const { return *m_ptr.name; }
81private:
82 union
83 {
84 wxPGProperty* property;
85 const wxChar* rawname;
86 const wxString* name;
87 } m_ptr;
88 unsigned char m_isName;
89};
90
91#endif
92
93typedef const wxPGPropArgCls& wxPGPropArg;
94
95// -----------------------------------------------------------------------
96
97WXDLLIMPEXP_PROPGRID
98void wxPGTypeOperationFailed( const wxPGProperty* p,
99 const wxChar* typestr,
100 const wxChar* op );
101WXDLLIMPEXP_PROPGRID
102void wxPGGetFailed( const wxPGProperty* p, const wxChar* typestr );
103
104// -----------------------------------------------------------------------
105
106// Helper macro that does necessary preparations when calling
107// some wxPGProperty's member function.
108#define wxPG_PROP_ARG_CALL_PROLOG_0(PROPERTY) \
109 PROPERTY *p = (PROPERTY*)id.GetPtr(this); \
110 if ( !p ) return;
111
112#define wxPG_PROP_ARG_CALL_PROLOG_RETVAL_0(PROPERTY, RETVAL) \
113 PROPERTY *p = (PROPERTY*)id.GetPtr(this); \
114 if ( !p ) return RETVAL;
115
116#define wxPG_PROP_ARG_CALL_PROLOG() \
117 wxPG_PROP_ARG_CALL_PROLOG_0(wxPGProperty)
118
119#define wxPG_PROP_ARG_CALL_PROLOG_RETVAL(RVAL) \
120 wxPG_PROP_ARG_CALL_PROLOG_RETVAL_0(wxPGProperty, RVAL)
121
122#define wxPG_PROP_ID_CONST_CALL_PROLOG() \
123 wxPG_PROP_ARG_CALL_PROLOG_0(const wxPGProperty)
124
125#define wxPG_PROP_ID_CONST_CALL_PROLOG_RETVAL(RVAL) \
126 wxPG_PROP_ARG_CALL_PROLOG_RETVAL_0(const wxPGProperty, RVAL)
127
128// -----------------------------------------------------------------------
129
130
131/** @class wxPropertyGridInterface
132
133 Most of the shared property manipulation interface shared by wxPropertyGrid,
134 wxPropertyGridPage, and wxPropertyGridManager is defined in this class.
135
136 @remarks
137 - In separate wxPropertyGrid component this class was known as
138 wxPropertyContainerMethods.
139
140 @library{wxpropgrid}
141 @category{propgrid}
142*/
143class WXDLLIMPEXP_PROPGRID wxPropertyGridInterface
144{
145public:
146
147 /** Destructor */
148 virtual ~wxPropertyGridInterface() { }
149
150 /** Adds choice to a property that can accept one.
151 @remarks
152 - If you need to make sure that you modify only the set of choices of
153 a single property (and not also choices of other properties with
154 initially identical set), call
155 wxPropertyGrid::SetPropertyChoicesPrivate.
156 - This usually only works for wxEnumProperty and derivatives
157 (wxFlagsProperty can get accept new items but its items may not get
158 updated).
159 */
160 void AddPropertyChoice( wxPGPropArg id,
161 const wxString& label,
162 int value = wxPG_INVALID_VALUE );
163
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
195 /** Deselect current selection, if any. Returns true if success
196 (ie. validator did not intercept). */
197 bool ClearSelection();
198
199 /** Resets modified status of all properties.
200 */
201 void ClearModifiedStatus()
202 {
203 SetPropertyModifiedStatus(m_pState->m_properties, false);
204 m_pState->m_anyModified = false;
205 }
206
207 /** Collapses given category or property with children.
208 Returns true if actually collapses.
209 */
210 bool Collapse( wxPGPropArg id );
211
212 /** Collapses all items that can be collapsed.
213
214 @return
215 Return false if failed (may fail if editor value cannot be validated).
216 */
217 bool CollapseAll() { return ExpandAll(false); }
218
219 /**
220 Changes value of a property, as if from an editor.
221 Use this instead of SetPropertyValue() if you need the value to run
222 through validation process, and also send the property change event.
223
224 @return
225 Returns true if value was successfully changed.
226 */
227 bool ChangePropertyValue( wxPGPropArg id, wxVariant newValue );
228
229 /** Resets value of a property to its default. */
230 bool ClearPropertyValue( wxPGPropArg id )
231 {
232 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
233 p->SetValue(p->GetDefaultValue());
234 RefreshProperty(p);
235 return true;
236 }
237
238 /**
239 Deletes a property by id. If category is deleted, all children are
240 automatically deleted as well.
241 */
242 void DeleteProperty( wxPGPropArg id );
243
244 /** Deletes choice from a property.
245
246 If selected item is deleted, then the value is set to unspecified.
247
248 See AddPropertyChoice for more details.
249 */
250 void DeletePropertyChoice( wxPGPropArg id, int index );
251
252 /** Disables property. */
253 bool DisableProperty( wxPGPropArg id ) { return EnableProperty(id,false); }
254
255 /**
256 Returns true if all property grid data changes have been committed.
257
258 Usually only returns false if value in active editor has been
259 invalidated by a wxValidator.
260 */
261 bool EditorValidate();
262
263 /**
264 Enables or disables property, depending on whether enable is true or
265 false.
266 */
267 bool EnableProperty( wxPGPropArg id, bool enable = true );
268
269 /** Called after population of property with fixed children has finished.
270 */
271 void EndAddChildren( wxPGPropArg id );
272
273 /** Expands given category or property with children.
274 Returns true if actually expands.
275 */
276 bool Expand( wxPGPropArg id );
277
278 /** Expands all items that can be expanded.
279 */
280 bool ExpandAll( bool expand = true );
281
282 /** Returns list of expanded properties.
283 */
284 wxArrayPGProperty GetExpandedProperties() const
285 {
286 wxArrayPGProperty array;
287 GetPropertiesWithFlag(&array, wxPG_PROP_COLLAPSED, true,
288 wxPG_ITERATE_ALL_PARENTS_RECURSIVELY|wxPG_ITERATE_HIDDEN);
289 return array;
290 }
291
292 /** Returns id of first child of given property.
293 @remarks
294 Does not return sub-properties!
295 */
296 wxPGProperty* GetFirstChild( wxPGPropArg id )
297 {
298 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
299
300 if ( !p->GetChildCount() || p->HasFlag(wxPG_PROP_AGGREGATE) )
301 return wxNullProperty;
302
303 return p->Item(0);
304 }
305
306 //@{
307 /** Returns iterator class instance.
308 @param flags
309 See @ref propgrid_iterator_flags. Value wxPG_ITERATE_DEFAULT causes
310 iteration over everything except private child properties.
311 @param firstProp
312 Property to start iteration from. If NULL, then first child of root
313 is used.
314 @param startPos
315 Either wxTOP or wxBOTTOM. wxTOP will indicate that iterations start
316 from the first property from the top, and wxBOTTOM means that the
317 iteration will instead begin from bottommost valid item.
318 */
319 wxPropertyGridIterator GetIterator( int flags = wxPG_ITERATE_DEFAULT,
320 wxPGProperty* firstProp = NULL )
321 {
322 return wxPropertyGridIterator( m_pState, flags, firstProp );
323 }
324
325 wxPropertyGridConstIterator
326 GetIterator( int flags = wxPG_ITERATE_DEFAULT,
327 wxPGProperty* firstProp = NULL ) const
328 {
329 return wxPropertyGridConstIterator( m_pState, flags, firstProp );
330 }
331
332 wxPropertyGridIterator GetIterator( int flags, int startPos )
333 {
334 return wxPropertyGridIterator( m_pState, flags, startPos );
335 }
336
337 wxPropertyGridConstIterator GetIterator( int flags, int startPos ) const
338 {
339 return wxPropertyGridConstIterator( m_pState, flags, startPos );
340 }
341 //@}
342
343 /** Returns id of first item, whether it is a category or property.
344 @param flags
345 @link iteratorflags List of iterator flags@endlink
346 */
347 wxPGProperty* GetFirst( int flags = wxPG_ITERATE_ALL )
348 {
349 wxPropertyGridIterator it( m_pState, flags, wxNullProperty, 1 );
350 return *it;
351 }
352
353 const wxPGProperty* GetFirst( int flags = wxPG_ITERATE_ALL ) const
354 {
355 return ((wxPropertyGridInterface*)this)->GetFirst(flags);
356 }
357
358 /**
359 Returns id of property with given name (case-sensitive).
360
361 If there is no property with such name, returned property id is invalid
362 ( i.e. it will return false with IsOk method).
363 @remarks
364 - Sub-properties (i.e. properties which have parent that is not
365 category or root) can not be accessed globally by their name.
366 Instead, use "<property>.<subproperty>" in place of "<subproperty>".
367 */
368 wxPGProperty* GetProperty( const wxString& name ) const
369 {
370 return GetPropertyByName(name);
371 }
372
373 /** Returns map-like storage of property's attributes.
374 @remarks
375 Note that if extra style wxPG_EX_WRITEONLY_BUILTIN_ATTRIBUTES is set,
376 then builtin-attributes are not included in the storage.
377 */
378 const wxPGAttributeStorage& GetPropertyAttributes( wxPGPropArg id ) const
379 {
380 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(*((const wxPGAttributeStorage*)NULL));
381 return p->GetAttributes();
382 }
383
384 /** Adds to 'targetArr' pointers to properties that have given
385 flags 'flags' set. However, if 'inverse' is set to true, then
386 only properties without given flags are stored.
387 @param flags
388 Property flags to use.
389 @param iterFlags
390 Iterator flags to use. Default is everything expect private children.
391 */
392 void GetPropertiesWithFlag( wxArrayPGProperty* targetArr,
393 wxPGProperty::FlagType flags,
394 bool inverse = false,
395 int iterFlags = wxPG_ITERATE_PROPERTIES |
396 wxPG_ITERATE_HIDDEN |
397 wxPG_ITERATE_CATEGORIES) const;
398
399 /** Returns value of given attribute. If none found, returns NULL-variant.
400 */
401 wxVariant GetPropertyAttribute( wxPGPropArg id,
402 const wxString& attrName ) const
403 {
404 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullVariant)
405 return p->GetAttribute(attrName);
406 }
407
408 /** Returns pointer of property's nearest parent category. If no category
409 found, returns NULL.
410 */
411 wxPropertyCategory* GetPropertyCategory( wxPGPropArg id ) const
412 {
413 wxPG_PROP_ID_CONST_CALL_PROLOG_RETVAL(NULL)
414 return m_pState->GetPropertyCategory(p);
415 }
416
417#ifndef SWIG
418 /** Returns client data (void*) of a property. */
419 void* GetPropertyClientData( wxPGPropArg id ) const
420 {
421 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
422 return p->GetClientData();
423 }
424#endif
425
426 /**
427 Returns first property which label matches given string.
428
429 NULL if none found. Note that this operation is extremely slow when
430 compared to GetPropertyByName().
431 */
432 wxPGProperty* GetPropertyByLabel( const wxString& label ) const;
433
434 /** Returns property with given name. NULL if none found.
435 */
436 wxPGProperty* GetPropertyByName( const wxString& name ) const;
437
438 /** Returns child property 'subname' of property 'name'. Same as
439 calling GetPropertyByName("name.subname"), albeit slightly faster.
440 */
441 wxPGProperty* GetPropertyByName( const wxString& name,
442 const wxString& subname ) const;
443
444 /** Returns writable reference to property's list of choices (and relevant
445 values). If property does not have any choices, will return reference
446 to an invalid set of choices that will return false on IsOk call.
447 */
448 wxPGChoices& GetPropertyChoices( wxPGPropArg id );
449
450 /** Returns property's editor. */
451 const wxPGEditor* GetPropertyEditor( wxPGPropArg id ) const
452 {
453 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
454 return p->GetEditorClass();
455 }
456
457 /** Returns help string associated with a property. */
458 wxString GetPropertyHelpString( wxPGPropArg id ) const
459 {
460 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(m_emptyString)
461 return p->GetHelpString();
462 }
463
464 /** Returns property's custom value image (NULL of none). */
465 wxBitmap* GetPropertyImage( wxPGPropArg id ) const
466 {
467 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
468 return p->GetValueImage();
469 }
470
471 /** Returns property's position under its parent. */
472 unsigned int GetPropertyIndex( wxPGPropArg id )
473 {
474 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(INT_MAX)
475 return p->GetIndexInParent();
476 }
477
478 /** Returns label of a property. */
479 const wxString& GetPropertyLabel( wxPGPropArg id )
480 {
481 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(m_emptyString)
482 return p->GetLabel();
483 }
484
485 /** Returns name of a property, by which it is globally accessible. */
486 wxString GetPropertyName( wxPGPropArg id )
487 {
488 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(m_emptyString)
489 return p->GetName();
490 }
491
492 /** Returns parent item of a property. */
493 wxPGProperty* GetPropertyParent( wxPGPropArg id )
494 {
495 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
496 return p->GetParent();
497 }
498
499#if wxUSE_VALIDATORS
500 /** Returns validator of a property as a reference, which you
501 can pass to any number of SetPropertyValidator.
502 */
503 wxValidator* GetPropertyValidator( wxPGPropArg id )
504 {
505 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
506 return p->GetValidator();
507 }
508#endif
509
510 /** Returns value as wxVariant. To get wxObject pointer from it,
511 you will have to use WX_PG_VARIANT_TO_WXOBJECT(VARIANT,CLASSNAME) macro.
512
513 If property value is unspecified, Null variant is returned.
514 */
515 wxVariant GetPropertyValue( wxPGPropArg id )
516 {
517 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxVariant())
518 return p->GetValue();
519 }
520
521 wxString GetPropertyValueAsString( wxPGPropArg id ) const;
522 long GetPropertyValueAsLong( wxPGPropArg id ) const;
523 unsigned long GetPropertyValueAsULong( wxPGPropArg id ) const
524 {
525 return (unsigned long) GetPropertyValueAsLong(id);
526 }
527#ifndef SWIG
528 int GetPropertyValueAsInt( wxPGPropArg id ) const
529 { return (int)GetPropertyValueAsLong(id); }
530#endif
531 bool GetPropertyValueAsBool( wxPGPropArg id ) const;
532 double GetPropertyValueAsDouble( wxPGPropArg id ) const;
533 wxObject* GetPropertyValueAsWxObjectPtr( wxPGPropArg id ) const;
534 void* GetPropertyValueAsVoidPtr( wxPGPropArg id ) const;
535
536#define wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(TYPENAME, DEFVAL) \
537 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(DEFVAL) \
538 if ( p->m_value.GetType() != TYPENAME ) \
539 { \
540 wxPGGetFailed(p, TYPENAME); \
541 return DEFVAL; \
542 }
543
544#define wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL_WFALLBACK(TYPENAME, DEFVAL) \
545 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(DEFVAL) \
546 if ( p->m_value.GetType() != TYPENAME ) \
547 return DEFVAL; \
548
549 wxArrayString GetPropertyValueAsArrayString( wxPGPropArg id ) const
550 {
551 wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(wxT("arrstring"),
552 wxArrayString())
553 return p->m_value.GetArrayString();
554 }
555
556 wxPoint GetPropertyValueAsPoint( wxPGPropArg id ) const
557 {
558 wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(wxT("wxPoint"), wxPoint())
559 return WX_PG_VARIANT_GETVALUEREF(p->GetValue(), wxPoint);
560 }
561
562 wxSize GetPropertyValueAsSize( wxPGPropArg id ) const
563 {
564 wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(wxT("wxSize"), wxSize())
565 return WX_PG_VARIANT_GETVALUEREF(p->GetValue(), wxSize);
566 }
567
568 wxLongLong_t GetPropertyValueAsLongLong( wxPGPropArg id ) const
569 {
570 wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL_WFALLBACK(wxT("wxLongLong"),
571 (long) GetPropertyValueAsLong(id))
572 return WX_PG_VARIANT_GETVALUEREF(p->GetValue(), wxLongLong).GetValue();
573 }
574
575 wxULongLong_t GetPropertyValueAsULongLong( wxPGPropArg id ) const
576 {
577 wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL_WFALLBACK(wxT("wxULongLong"),
578 (unsigned long) GetPropertyValueAsULong(id))
579 return WX_PG_VARIANT_GETVALUEREF(p->GetValue(), wxULongLong).GetValue();
580 }
581
582 wxArrayInt GetPropertyValueAsArrayInt( wxPGPropArg id ) const
583 {
584 wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(wxT("wxArrayInt"),
585 wxArrayInt())
586 wxArrayInt arr = WX_PG_VARIANT_GETVALUEREF(p->GetValue(), wxArrayInt);
587 return arr;
588 }
589
590#if wxUSE_DATETIME
591 wxDateTime GetPropertyValueAsDateTime( wxPGPropArg id ) const
592 {
593 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxDateTime())
594
595 if ( wxStrcmp(p->m_value.GetType(), wxT("datetime")) != 0 )
596 {
597 wxPGGetFailed(p, wxT("datetime"));
598 return wxDateTime();
599 }
600 return p->m_value.GetDateTime();
601 }
602#endif
603
604#ifndef SWIG
605 /** Returns a wxVariant list containing wxVariant versions of all
606 property values. Order is not guaranteed.
607 @param flags
608 Use wxPG_KEEP_STRUCTURE to retain category structure; each sub
609 category will be its own wxVariantList of wxVariant.
610 Use wxPG_INC_ATTRIBUTES to include property attributes as well.
611 Each attribute will be stored as list variant named
612 "@@<propname>@@attr."
613 @remarks
614 */
615 wxVariant GetPropertyValues( const wxString& listname = wxEmptyString,
616 wxPGProperty* baseparent = NULL, long flags = 0 ) const
617 {
618 return m_pState->DoGetPropertyValues(listname, baseparent, flags);
619 }
620#endif
621
622 wxString GetPropertyValueType( wxPGPropArg id )
623 {
624 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(m_emptyString)
625 return p->GetValueType();
626 }
627
628 /** Returns currently selected property. */
629 wxPGProperty* GetSelection() const
630 {
631 return m_pState->GetSelection();
632 }
633
634#ifndef SWIG
635 wxPropertyGridPageState* GetState() const { return m_pState; }
636#endif
637
638 /** Similar to GetIterator(), but instead returns wxPGVIterator instance,
639 which can be useful for forward-iterating through arbitrary property
640 containers.
641
642 @param flags
643 See @ref propgrid_iterator_flags.
644 */
645 virtual wxPGVIterator GetVIterator( int flags ) const;
646
647 /** Hides or reveals a property.
648 @param hide
649 If true, hides property, otherwise reveals it.
650 @param flags
651 By default changes are applied recursively. Set this paramter
652 wxPG_DONT_RECURSE to prevent this.
653 */
654 bool HideProperty( wxPGPropArg id,
655 bool hide = true,
656 int flags = wxPG_RECURSE );
657
658#if wxPG_INCLUDE_ADVPROPS
659 /** Initializes *all* property types. Causes references to most object
660 files in the library, so calling this may cause significant increase
661 in executable size when linking with static library.
662 */
663 static void InitAllTypeHandlers();
664#else
665 static void InitAllTypeHandlers() { }
666#endif
667
668 //@{
669 /** Inserts property to the property container.
670
671 @param priorThis
672 New property is inserted just prior to this. Available only
673 in the first variant. There are two versions of this function
674 to allow this parameter to be either an id or name to
675 a property.
676
677 @param newproperty
678 Pointer to the inserted property. wxPropertyGrid will take
679 ownership of this object.
680
681 @param parent
682 New property is inserted under this category. Available only
683 in the second variant. There are two versions of this function
684 to allow this parameter to be either an id or name to
685 a property.
686
687 @param index
688 Index under category. Available only in the second variant.
689 If index is < 0, property is appended in category.
690
691 @return
692 Returns id for the property,
693
694 @remarks
695
696 - wxPropertyGrid takes the ownership of the property pointer.
697
698 - While Append may be faster way to add items, make note that when
699 both types of data storage (categoric and
700 non-categoric) are active, Insert becomes even more slow. This is
701 especially true if current mode is non-categoric.
702
703 Example of use:
704
705 @code
706
707 // append category
708 wxPGProperty* my_cat_id = propertygrid->Append(
709 new wxPropertyCategory("My Category") );
710
711 ...
712
713 // insert into category - using second variant
714 wxPGProperty* my_item_id_1 = propertygrid->Insert(
715 my_cat_id, 0, new wxStringProperty("My String 1") );
716
717 // insert before to first item - using first variant
718 wxPGProperty* my_item_id_2 = propertygrid->Insert(
719 my_item_id, new wxStringProperty("My String 2") );
720
721 @endcode
722
723 */
724 wxPGProperty* Insert( wxPGPropArg priorThis, wxPGProperty* newproperty );
725 wxPGProperty* Insert( wxPGPropArg parent,
726 int index,
727 wxPGProperty* newproperty );
728 //@}
729
730 /** Returns true if property is a category. */
731 bool IsPropertyCategory( wxPGPropArg id ) const
732 {
733 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
734 return p->IsCategory();
735 }
736
737 /** Inserts choice to a property that can accept one.
738
739 See AddPropertyChoice for more details.
740 */
741 void InsertPropertyChoice( wxPGPropArg id,
742 const wxString& label,
743 int index,
744 int value = wxPG_INVALID_VALUE );
745
746 /** Returns true if property is enabled. */
747 bool IsPropertyEnabled( wxPGPropArg id ) const
748 {
749 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
750 return (!(p->GetFlags() & wxPG_PROP_DISABLED))?true:false;
751 }
752
753 /**
754 Returns true if given property is expanded.
755
756 Naturally, always returns false for properties that cannot be expanded.
757 */
758 bool IsPropertyExpanded( wxPGPropArg id ) const;
759
760 /**
761 Returns true if property has been modified after value set or modify
762 flag clear by software.
763 */
764 bool IsPropertyModified( wxPGPropArg id ) const
765 {
766 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
767 return ( (p->GetFlags() & wxPG_PROP_MODIFIED) ? true : false );
768 }
769
770 /**
771 Returns true if property is shown (ie hideproperty with true not
772 called for it).
773 */
774 bool IsPropertyShown( wxPGPropArg id ) const
775 {
776 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
777 return (!(p->GetFlags() & wxPG_PROP_HIDDEN))?true:false;
778 }
779
780 /** Returns true if property value is set to unspecified.
781 */
782 bool IsPropertyValueUnspecified( wxPGPropArg id ) const
783 {
784 wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
785 return p->IsValueUnspecified();
786 }
787
788 /**
789 Disables (limit = true) or enables (limit = false) wxTextCtrl editor of
790 a property, if it is not the sole mean to edit the value.
791 */
792 void LimitPropertyEditing( wxPGPropArg id, bool limit = true );
793
794 /** If state is shown in it's grid, refresh it now.
795 */
796 virtual void RefreshGrid( wxPropertyGridPageState* state = NULL );
797
798#if wxPG_INCLUDE_ADVPROPS
799 /**
800 Initializes additional property editors (SpinCtrl etc.). Causes
801 references to most object files in the library, so calling this may
802 cause significant increase in executable size when linking with static
803 library.
804 */
805 static void RegisterAdditionalEditors();
806#else
807 static void RegisterAdditionalEditors() { }
808#endif
809
810 /** Replaces property with id with newly created property. For example,
811 this code replaces existing property named "Flags" with one that
812 will have different set of items:
813 @code
814 pg->ReplaceProperty("Flags",
815 wxFlagsProperty("Flags", wxPG_LABEL, newItems))
816 @endcode
817 For more info, see wxPropertyGrid::Insert.
818 */
819 wxPGProperty* ReplaceProperty( wxPGPropArg id, wxPGProperty* property );
820
821 /** @anchor propgridinterface_editablestate_flags
822
823 Flags for wxPropertyGridInterface::SaveEditableState() and
824 wxPropertyGridInterface::RestoreEditableState().
825 */
826 enum EditableStateFlags
827 {
828 /** Include selected property. */
829 SelectionState = 0x01,
830 /** Include expanded/collapsed property information. */
831 ExpandedState = 0x02,
832 /** Include scrolled position. */
833 ScrollPosState = 0x04,
834 /** Include selected page information.
835 Only applies to wxPropertyGridManager. */
836 PageState = 0x08,
837 /** Include splitter position. Stored for each page. */
838 SplitterPosState = 0x10,
839
840 /**
841 Include all supported user editable state information.
842 This is usually the default value. */
843 AllStates = SelectionState |
844 ExpandedState |
845 ScrollPosState |
846 PageState |
847 SplitterPosState
848 };
849
850 /**
851 Restores user-editable state.
852
853 See also wxPropertyGridInterface::SaveEditableState().
854
855 @param src
856 String generated by SaveEditableState.
857
858 @param restoreStates
859 Which parts to restore from source string. See @ref
860 propgridinterface_editablestate_flags "list of editable state
861 flags".
862
863 @return
864 False if there was problem reading the string.
865
866 @remarks
867 If some parts of state (such as scrolled or splitter position) fail to
868 restore correctly, please make sure that you call this function after
869 wxPropertyGrid size has been set (this may sometimes be tricky when
870 sizers are used).
871 */
872 bool RestoreEditableState( const wxString& src,
873 int restoreStates = AllStates );
874
875 /**
876 Used to acquire user-editable state (selected property, expanded
877 properties, scrolled position, splitter positions).
878
879 @param includedStates
880 Which parts of state to include. See @ref
881 propgridinterface_editablestate_flags "list of editable state flags".
882 */
883 wxString SaveEditableState( int includedStates = AllStates ) const;
884
885 /**
886 Lets user to set the strings listed in the choice dropdown of a
887 wxBoolProperty. Defaults are "True" and "False", so changing them to,
888 say, "Yes" and "No" may be useful in some less technical applications.
889 */
890 static void SetBoolChoices( const wxString& trueChoice,
891 const wxString& falseChoice );
892
893 /** Sets or clears flag(s) of all properties in given array.
894 @param flags
895 Property flags to set or clear.
896 @param inverse
897 Set to true if you want to clear flag instead of setting them.
898 */
899 void SetPropertiesFlag( const wxArrayPGProperty& srcArr,
900 wxPGProperty::FlagType flags,
901 bool inverse = false );
902
903 /** Sets an attribute for this property.
904 @param name
905 Text identifier of attribute. See @ref propgrid_property_attributes.
906 @param value
907 Value of attribute.
908 @param argFlags
909 Optional. Use wxPG_RECURSE to set the attribute to child properties
910 recursively.
911 */
912 void SetPropertyAttribute( wxPGPropArg id,
913 const wxString& attrName,
914 wxVariant value,
915 long argFlags = 0 )
916 {
917 DoSetPropertyAttribute(id,attrName,value,argFlags);
918 }
919
920 /** Sets attributes from a wxPGAttributeStorage.
921 */
922 void SetPropertyAttributes( wxPGPropArg id,
923 const wxPGAttributeStorage& attributes )
924 {
925 wxPG_PROP_ARG_CALL_PROLOG()
926 p->SetAttributes(attributes);
927 }
928
929 /** Sets text, bitmap, and colours for given column's cell.
930
931 @remarks
932 - You can set label cell by setting column to 0.
933 - You can use wxPG_LABEL as text to use default text for column.
934 */
935 void SetPropertyCell( wxPGPropArg id,
936 int column,
937 const wxString& text = wxEmptyString,
938 const wxBitmap& bitmap = wxNullBitmap,
939 const wxColour& fgCol = wxNullColour,
940 const wxColour& bgCol = wxNullColour )
941 {
942 wxPG_PROP_ARG_CALL_PROLOG()
943 p->SetCell( column, new wxPGCell(text, bitmap, fgCol, bgCol) );
944 }
945
946 /** Set choices of a property to specified set of labels and values.
947
948 @remarks
949 This operation clears the property value.
950 */
951 void SetPropertyChoices( wxPGPropArg id, wxPGChoices& choices)
952 {
953 wxPG_PROP_ARG_CALL_PROLOG()
954 p->SetChoices(choices);
955 }
956
957
958 /**
959 If property's set of choices is shared, then calling this method
960 converts it to private.
961 */
962 void SetPropertyChoicesExclusive( wxPGPropArg id )
963 {
964 wxPG_PROP_ARG_CALL_PROLOG()
965 p->SetChoicesExclusive();
966 }
967
968#ifndef SWIG
969 /** Sets client data (void*) of a property.
970 @remarks
971 This untyped client data has to be deleted manually.
972 */
973 void SetPropertyClientData( wxPGPropArg id, void* clientData )
974 {
975 wxPG_PROP_ARG_CALL_PROLOG()
976 p->SetClientData(clientData);
977 }
978
979 /** Sets editor for a property.
980
981 @param editor
982 For builtin editors, use wxPGEditor_X, where X is builtin editor's
983 name (TextCtrl, Choice, etc. see wxPGEditor documentation for full
984 list).
985
986 For custom editors, use pointer you received from
987 wxPropertyGrid::RegisterEditorClass().
988 */
989 void SetPropertyEditor( wxPGPropArg id, const wxPGEditor* editor )
990 {
991 wxPG_PROP_ARG_CALL_PROLOG()
992 wxCHECK_RET( editor, wxT("unknown/NULL editor") );
993 p->SetEditor(editor);
994 RefreshProperty(p);
995 }
996#endif
997
998 /** Sets editor control of a property. As editor argument, use
999 editor name string, such as "TextCtrl" or "Choice".
1000 */
1001 void SetPropertyEditor( wxPGPropArg id, const wxString& editorName )
1002 {
1003 SetPropertyEditor(id,GetEditorByName(editorName));
1004 }
1005
1006 /** Sets label of a property.
1007 @remarks
1008 This is the only way to set property's name. There is not
1009 wxPGProperty::SetLabel() method.
1010 */
1011 void SetPropertyLabel( wxPGPropArg id, const wxString& newproplabel );
1012
1013 /** Set modified status of a property and all its children.
1014 */
1015 void SetPropertyModifiedStatus( wxPGPropArg id, bool modified )
1016 {
1017 wxPG_PROP_ARG_CALL_PROLOG()
1018 p->SetModifiedStatus(modified);
1019 }
1020
1021 /**
1022 Sets property (and, recursively, its children) to have read-only value.
1023 In other words, user cannot change the value in the editor, but they
1024 can still copy it.
1025 @remarks
1026 This is mainly for use with textctrl editor. Not all other editors fully
1027 support it.
1028 @param flags
1029 By default changes are applied recursively. Set this paramter
1030 wxPG_DONT_RECURSE to prevent this.
1031 */
1032 void SetPropertyReadOnly( wxPGPropArg id,
1033 bool set = true,
1034 int flags = wxPG_RECURSE )
1035 {
1036 wxPG_PROP_ARG_CALL_PROLOG()
1037 if ( flags & wxPG_RECURSE )
1038 p->SetFlagRecursively(wxPG_PROP_READONLY, set);
1039 else
1040 p->SetFlag(wxPG_PROP_READONLY);
1041 }
1042
1043 /** Sets property's value to unspecified.
1044 If it has children (it may be category), then the same thing is done to
1045 them.
1046 */
1047 void SetPropertyValueUnspecified( wxPGPropArg id );
1048
1049#ifndef SWIG
1050 /** Sets various property values from a list of wxVariants. If property with
1051 name is missing from the grid, new property is created under given
1052 default category (or root if omitted).
1053 */
1054 void SetPropertyValues( const wxVariantList& list,
1055 wxPGPropArg defaultCategory = wxNullProperty )
1056 {
1057 wxPGProperty *p;
1058 if ( defaultCategory.HasName() ) p = defaultCategory.GetPtr(this);
1059 else p = defaultCategory.GetPtr0();
1060 m_pState->DoSetPropertyValues(list, p);
1061 }
1062
1063 void SetPropertyValues( const wxVariant& list,
1064 wxPGPropArg defaultCategory = wxNullProperty )
1065 {
1066 SetPropertyValues(list.GetList(),defaultCategory);
1067 }
1068#endif
1069
1070 /** Associates the help string with property.
1071 @remarks
1072 By default, text is shown either in the manager's "description"
1073 text box or in the status bar. If extra window style
1074 wxPG_EX_HELP_AS_TOOLTIPS is used, then the text will appear as a
1075 tooltip.
1076 */
1077 void SetPropertyHelpString( wxPGPropArg id, const wxString& helpString )
1078 {
1079 wxPG_PROP_ARG_CALL_PROLOG()
1080 p->SetHelpString(helpString);
1081 }
1082
1083 /** Set wxBitmap in front of the value.
1084 @remarks
1085 - Bitmap will be scaled to a size returned by
1086 wxPropertyGrid::GetImageSize();
1087 */
1088 void SetPropertyImage( wxPGPropArg id, wxBitmap& bmp )
1089 {
1090 wxPG_PROP_ARG_CALL_PROLOG()
1091 p->SetValueImage(bmp);
1092 RefreshProperty(p);
1093 }
1094
1095 /** Sets max length of property's text.
1096 */
1097 bool SetPropertyMaxLength( wxPGPropArg id, int maxLen );
1098
1099#if wxUSE_VALIDATORS
1100 /** Sets validator of a property.
1101 */
1102 void SetPropertyValidator( wxPGPropArg id, const wxValidator& validator )
1103 {
1104 wxPG_PROP_ARG_CALL_PROLOG()
1105 p->SetValidator(validator);
1106 }
1107#endif
1108
1109#ifndef SWIG
1110 /** Sets value (long integer) of a property.
1111 */
1112 void SetPropertyValue( wxPGPropArg id, long value )
1113 {
1114 wxVariant v(value);
1115 SetPropVal( id, v );
1116 }
1117
1118 /** Sets value (integer) of a property.
1119 */
1120 void SetPropertyValue( wxPGPropArg id, int value )
1121 {
1122 wxVariant v((long)value);
1123 SetPropVal( id, v );
1124 }
1125 /** Sets value (floating point) of a property.
1126 */
1127 void SetPropertyValue( wxPGPropArg id, double value )
1128 {
1129 wxVariant v(value);
1130 SetPropVal( id, v );
1131 }
1132 /** Sets value (bool) of a property.
1133 */
1134 void SetPropertyValue( wxPGPropArg id, bool value )
1135 {
1136 wxVariant v(value);
1137 SetPropVal( id, v );
1138 }
1139 void SetPropertyValue( wxPGPropArg id, const wxChar* value )
1140 {
1141 SetPropertyValueString( id, wxString(value) );
1142 }
1143 void SetPropertyValue( wxPGPropArg id, const wxString& value )
1144 {
1145 SetPropertyValueString( id, value );
1146 }
1147
1148 /** Sets value (wxArrayString) of a property.
1149 */
1150 void SetPropertyValue( wxPGPropArg id, const wxArrayString& value )
1151 {
1152 wxVariant v(value);
1153 SetPropVal( id, v );
1154 }
1155
1156#if wxUSE_DATETIME
1157 void SetPropertyValue( wxPGPropArg id, const wxDateTime& value )
1158 {
1159 wxVariant v(value);
1160 SetPropVal( id, v );
1161 }
1162#endif
1163
1164 /** Sets value (wxObject*) of a property.
1165 */
1166 void SetPropertyValue( wxPGPropArg id, wxObject* value )
1167 {
1168 wxVariant v(value);
1169 SetPropVal( id, v );
1170 }
1171
1172 void SetPropertyValue( wxPGPropArg id, wxObject& value )
1173 {
1174 wxVariant v(&value);
1175 SetPropVal( id, v );
1176 }
1177
1178 /** Sets value (wxPoint&) of a property.
1179 */
1180 void SetPropertyValue( wxPGPropArg id, const wxPoint& value )
1181 {
1182 wxVariant v = WXVARIANT(value);
1183 SetPropVal( id, v );
1184 }
1185 /** Sets value (wxSize&) of a property.
1186 */
1187 void SetPropertyValue( wxPGPropArg id, const wxSize& value )
1188 {
1189 wxVariant v = WXVARIANT(value);
1190 SetPropVal( id, v );
1191 }
1192 /** Sets value (wxLongLong&) of a property.
1193 */
1194 void SetPropertyValue( wxPGPropArg id, wxLongLong_t value )
1195 {
1196 wxVariant v = WXVARIANT(wxLongLong(value));
1197 SetPropVal( id, v );
1198 }
1199 /** Sets value (wxULongLong&) of a property.
1200 */
1201 void SetPropertyValue( wxPGPropArg id, wxULongLong_t value )
1202 {
1203 wxVariant v = WXVARIANT(wxULongLong(value));
1204 SetPropVal( id, v );
1205 }
1206 /** Sets value (wxArrayInt&) of a property.
1207 */
1208 void SetPropertyValue( wxPGPropArg id, const wxArrayInt& value )
1209 {
1210 wxVariant v = WXVARIANT(value);
1211 SetPropVal( id, v );
1212 }
1213#endif // !SWIG
1214
1215 /** Sets value (wxString) of a property.
1216
1217 @remarks
1218 This method uses wxPGProperty::SetValueFromString, which all properties
1219 should implement. This means that there should not be a type error,
1220 and instead the string is converted to property's actual value type.
1221 */
1222 void SetPropertyValueString( wxPGPropArg id, const wxString& value );
1223
1224 /** Sets value (wxVariant&) of a property.
1225
1226 @remarks
1227 Use wxPropertyGrid::ChangePropertyValue() instead if you need to run
1228 through validation process and send property change event.
1229 */
1230 void SetPropertyValue( wxPGPropArg id, wxVariant value )
1231 {
1232 SetPropVal( id, value );
1233 }
1234
1235#ifndef SWIG
1236 /** Sets value (wxVariant&) of a property. Same as SetPropertyValue, but
1237 accepts reference. */
1238 void SetPropVal( wxPGPropArg id, wxVariant& value );
1239#endif
1240
1241 /** Adjusts how wxPropertyGrid behaves when invalid value is entered
1242 in a property.
1243 @param vfbFlags
1244 See @link vfbflags list of valid flags values@endlink
1245 */
1246 void SetValidationFailureBehavior( int vfbFlags );
1247
1248#ifdef SWIG
1249 %pythoncode {
1250 def MapType(class_,factory):
1251 "Registers Python type/class to property mapping.\n\nfactory: Property builder function/class."
1252 global _type2property
1253 try:
1254 mappings = _type2property
1255 except NameError:
1256 raise AssertionError("call only after a propertygrid or manager instance constructed")
1257
1258 mappings[class_] = factory
1259
1260
1261 def DoDefaultTypeMappings(self):
1262 "Map built-in properties."
1263 global _type2property
1264 try:
1265 mappings = _type2property
1266
1267 return
1268 except NameError:
1269 mappings = {}
1270 _type2property = mappings
1271
1272 mappings[str] = StringProperty
1273 mappings[unicode] = StringProperty
1274 mappings[int] = IntProperty
1275 mappings[float] = FloatProperty
1276 mappings[bool] = BoolProperty
1277 mappings[list] = ArrayStringProperty
1278 mappings[tuple] = ArrayStringProperty
1279 mappings[wx.Font] = FontProperty
1280 mappings[wx.Colour] = ColourProperty
1281 "mappings[wx.Size] = SizeProperty"
1282 "mappings[wx.Point] = PointProperty"
1283 "mappings[wx.FontData] = FontDataProperty"
1284
1285 def DoDefaultValueTypeMappings(self):
1286 "Map pg value type ids to getter methods."
1287 global _vt2getter
1288 try:
1289 vt2getter = _vt2getter
1290
1291 return
1292 except NameError:
1293 vt2getter = {}
1294 _vt2getter = vt2getter
1295
1296 def GetPropertyValues(self,dict_=None, as_strings=False, inc_attributes=False):
1297 "Returns values in the grid."
1298 ""
1299 "dict_: if not given, then a new one is created. dict_ can be"
1300 " object as well, in which case it's __dict__ is used."
1301 "as_strings: if True, then string representations of values"
1302 " are fetched instead of native types. Useful for config and such."
1303 "inc_attributes: if True, then property attributes are added"
1304 " as @<propname>@<attr>."
1305 ""
1306 "Return value: dictionary with values. It is always a dictionary,"
1307 "so if dict_ was object with __dict__ attribute, then that attribute"
1308 "is returned."
1309
1310 if dict_ is None:
1311 dict_ = {}
1312 elif hasattr(dict_,'__dict__'):
1313 dict_ = dict_.__dict__
1314
1315 if not as_strings:
1316 getter = self.GetPropertyValue
1317 else:
1318 getter = self.GetPropertyValueAsString
1319
1320 it = self.GetVIterator(PG_ITERATE_PROPERTIES)
1321 while not it.AtEnd():
1322 p = it.GetProperty()
1323 name = p.GetName()
1324
1325 dict_[name] = getter(p)
1326
1327 if inc_attributes:
1328 attrs = p.GetAttributes()
1329 if attrs and len(attrs):
1330 dict_['@%s@attr'%name] = attrs
1331
1332 it.Next()
1333
1334 return dict_
1335
1336 GetValues = GetPropertyValues
1337
1338
1339 def SetPropertyValues(self,dict_):
1340 "Sets property values from dict_, which can be either\ndictionary or an object with __dict__ attribute."
1341 ""
1342 "autofill: If true, keys with not relevant properties"
1343 " are auto-created. For more info, see AutoFill."
1344 ""
1345 "Notes:"
1346 " * Keys starting with underscore are ignored."
1347 " * Attributes can be set with entries named @<propname>@<attr>."
1348 ""
1349
1350 autofill = False
1351
1352 if dict_ is None:
1353 dict_ = {}
1354 elif hasattr(dict_,'__dict__'):
1355 dict_ = dict_.__dict__
1356
1357 attr_dicts = []
1358
1359 def set_sub_obj(k0,dict_):
1360 for k,v in dict_.iteritems():
1361 if k[0] != '_':
1362 if k.endswith('@attr'):
1363 attr_dicts.append((k[1:-5],v))
1364 else:
1365 try:
1366 self.SetPropertyValue(k,v)
1367 except:
1368 try:
1369 if autofill:
1370 self._AutoFillOne(k0,k,v)
1371 continue
1372 except:
1373 if isinstance(v,dict):
1374 set_sub_obj(k,v)
1375 elif hasattr(v,'__dict__'):
1376 set_sub_obj(k,v.__dict__)
1377
1378
1379 for k,v in attr_dicts:
1380 p = GetPropertyByName(k)
1381 if not p:
1382 raise AssertionError("No such property: '%s'"%k)
1383 for an,av in v.iteritems():
1384 p.SetAttribute(an, av)
1385
1386
1387 cur_page = False
1388 is_manager = isinstance(self,PropertyGridManager)
1389
1390 try:
1391 set_sub_obj(self.GetGrid().GetRoot(),dict_)
1392 except:
1393 import traceback
1394 traceback.print_exc()
1395
1396 self.Refresh()
1397
1398 SetValues = SetPropertyValues
1399
1400 def _AutoFillMany(self,cat,dict_):
1401 for k,v in dict_.iteritems():
1402 self._AutoFillOne(cat,k,v)
1403
1404
1405 def _AutoFillOne(self,cat,k,v):
1406 global _type2property
1407
1408 factory = _type2property.get(v.__class__,None)
1409
1410 if factory:
1411 self.AppendIn( cat, factory(k,k,v) )
1412 elif hasattr(v,'__dict__'):
1413 cat2 = self.AppendIn( cat, PropertyCategory(k) )
1414 self._AutoFillMany(cat2,v.__dict__)
1415 elif isinstance(v,dict):
1416 cat2 = self.AppendIn( cat, PropertyCategory(k) )
1417 self._AutoFillMany(cat2,v)
1418 elif not k.startswith('_'):
1419 raise AssertionError("member '%s' is of unregisted type/class '%s'"%(k,v.__class__))
1420
1421
1422 def AutoFill(self,obj,parent=None):
1423 "Clears properties and re-fills to match members and\nvalues of given object or dictionary obj."
1424
1425 self.edited_objects[parent] = obj
1426
1427 cur_page = False
1428 is_manager = isinstance(self,PropertyGridManager)
1429
1430 if not parent:
1431 if is_manager:
1432 page = self.GetCurrentPage()
1433 page.Clear()
1434 parent = page.GetRoot()
1435 else:
1436 self.Clear()
1437 parent = self.GetGrid().GetRoot()
1438 else:
1439 it = self.GetIterator(PG_ITERATE_PROPERTIES, parent)
1440 it.Next() # Skip the parent
1441 while not it.AtEnd():
1442 p = it.GetProperty()
1443 if not p.IsSomeParent(parent):
1444 break
1445
1446 self.DeleteProperty(p)
1447
1448 name = p.GetName()
1449 it.Next()
1450
1451 if not is_manager or page == self.GetCurrentPage():
1452 self.Freeze()
1453 cur_page = True
1454
1455 try:
1456 self._AutoFillMany(parent,obj.__dict__)
1457 except:
1458 import traceback
1459 traceback.print_exc()
1460
1461 if cur_page:
1462 self.Thaw()
1463
1464 def RegisterEditor(self, editor, editorName=None):
1465 "Transform class into instance, if necessary."
1466 if not isinstance(editor, PGEditor):
1467 editor = editor()
1468 if not editorName:
1469 editorName = editor.__class__.__name__
1470 try:
1471 self._editor_instances.append(editor)
1472 except:
1473 self._editor_instances = [editor]
1474 RegisterEditor(editor, editorName)
1475
1476 def GetPropertyClientData(self, p):
1477 if isinstance(p, basestring):
1478 p = self.GetPropertyByName(p)
1479 return p.GetClientData()
1480
1481 def SetPropertyClientData(self, p, data):
1482 if isinstance(p, basestring):
1483 p = self.GetPropertyByName(p)
1484 return p.SetClientData(data)
1485 }
1486#endif
1487
1488 // GetPropertyByName With nice assertion error message.
1489 wxPGProperty* GetPropertyByNameA( const wxString& name ) const;
1490
1491 static wxPGEditor* GetEditorByName( const wxString& editorName );
1492
1493 virtual void RefreshProperty( wxPGProperty* p ) = 0;
1494
1495protected:
1496
1497 // Returns page state data for given (sub) page (-1 means current page).
1498 virtual wxPropertyGridPageState* GetPageState( int pageIndex ) const
1499 {
1500 if ( pageIndex <= 0 )
1501 return m_pState;
1502 return NULL;
1503 }
1504
1505 virtual bool DoSelectPage( int WXUNUSED(index) ) { return true; }
1506
1507 // Default call's m_pState's BaseGetPropertyByName
1508 virtual wxPGProperty* DoGetPropertyByName( const wxString& name ) const;
1509
1510#ifndef SWIG
1511
1512 // Deriving classes must set this (it must be only or current page).
1513 wxPropertyGridPageState* m_pState;
1514
1515 // Intermediate version needed due to wxVariant copying inefficiency
1516 void DoSetPropertyAttribute( wxPGPropArg id,
1517 const wxString& name,
1518 wxVariant& value, long argFlags );
1519
1520 // Empty string object to return from member functions returning const
1521 // wxString&.
1522 wxString m_emptyString;
1523
1524private:
1525 // Cannot be GetGrid() due to ambiguity issues.
1526 wxPropertyGrid* GetPropertyGrid()
1527 {
1528 return m_pState->GetGrid();
1529 }
1530
1531 // Cannot be GetGrid() due to ambiguity issues.
1532 const wxPropertyGrid* GetPropertyGrid() const
1533 {
1534 return (const wxPropertyGrid*) m_pState->GetGrid();
1535 }
1536#endif // #ifndef SWIG
1537
1538 friend class wxPropertyGrid;
1539 friend class wxPropertyGridManager;
1540};
1541
1542#endif // __WX_PROPGRID_PROPGRIDIFACE_H__