mirror of
https://github.com/ZDoom/zdoom-macos-deps.git
synced 2024-11-26 13:50:50 +00:00
1171 lines
43 KiB
C
1171 lines
43 KiB
C
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
|
// Name: wx/propgrid/propgridiface.h
|
||
|
|
// Purpose: wxPropertyGridInterface class
|
||
|
|
// Author: Jaakko Salli
|
||
|
|
// Modified by:
|
||
|
|
// Created: 2008-08-24
|
||
|
|
// Copyright: (c) Jaakko Salli
|
||
|
|
// Licence: wxWindows licence
|
||
|
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
#ifndef __WX_PROPGRID_PROPGRIDIFACE_H__
|
||
|
|
#define __WX_PROPGRID_PROPGRIDIFACE_H__
|
||
|
|
|
||
|
|
#include "wx/defs.h"
|
||
|
|
|
||
|
|
#if wxUSE_PROPGRID
|
||
|
|
|
||
|
|
#include "wx/propgrid/property.h"
|
||
|
|
#include "wx/propgrid/propgridpagestate.h"
|
||
|
|
|
||
|
|
// -----------------------------------------------------------------------
|
||
|
|
|
||
|
|
// Most property grid functions have this type as their argument, as it can
|
||
|
|
// convey a property by either a pointer or name.
|
||
|
|
class WXDLLIMPEXP_PROPGRID wxPGPropArgCls
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
wxPGPropArgCls( const wxPGProperty* property )
|
||
|
|
{
|
||
|
|
m_ptr.property = const_cast<wxPGProperty*>(property);
|
||
|
|
m_flags = IsProperty;
|
||
|
|
}
|
||
|
|
wxPGPropArgCls( const wxString& str )
|
||
|
|
{
|
||
|
|
m_ptr.stringName = &str;
|
||
|
|
m_flags = IsWxString;
|
||
|
|
}
|
||
|
|
wxPGPropArgCls( const wxPGPropArgCls& id )
|
||
|
|
{
|
||
|
|
m_ptr = id.m_ptr;
|
||
|
|
m_flags = id.m_flags;
|
||
|
|
}
|
||
|
|
// This is only needed for wxPython bindings.
|
||
|
|
wxPGPropArgCls( wxString* str, bool WXUNUSED(deallocPtr) )
|
||
|
|
{
|
||
|
|
m_ptr.stringName = str;
|
||
|
|
m_flags = IsWxString | OwnsWxString;
|
||
|
|
}
|
||
|
|
~wxPGPropArgCls()
|
||
|
|
{
|
||
|
|
if ( m_flags & OwnsWxString )
|
||
|
|
delete m_ptr.stringName;
|
||
|
|
}
|
||
|
|
wxPGProperty* GetPtr() const
|
||
|
|
{
|
||
|
|
wxCHECK( m_flags == IsProperty, NULL );
|
||
|
|
return m_ptr.property;
|
||
|
|
}
|
||
|
|
wxPGPropArgCls( const char* str )
|
||
|
|
{
|
||
|
|
m_ptr.charName = str;
|
||
|
|
m_flags = IsCharPtr;
|
||
|
|
}
|
||
|
|
wxPGPropArgCls( const wchar_t* str )
|
||
|
|
{
|
||
|
|
m_ptr.wcharName = str;
|
||
|
|
m_flags = IsWCharPtr;
|
||
|
|
}
|
||
|
|
// This constructor is required for NULL.
|
||
|
|
wxPGPropArgCls( int )
|
||
|
|
{
|
||
|
|
m_ptr.property = NULL;
|
||
|
|
m_flags = IsProperty;
|
||
|
|
}
|
||
|
|
wxPGProperty* GetPtr( wxPropertyGridInterface* iface ) const;
|
||
|
|
wxPGProperty* GetPtr( const wxPropertyGridInterface* iface ) const
|
||
|
|
{
|
||
|
|
return GetPtr(const_cast<wxPropertyGridInterface*>(iface));
|
||
|
|
}
|
||
|
|
wxPGProperty* GetPtr0() const { return m_ptr.property; }
|
||
|
|
bool HasName() const { return (m_flags != IsProperty); }
|
||
|
|
const wxString& GetName() const { return *m_ptr.stringName; }
|
||
|
|
private:
|
||
|
|
|
||
|
|
enum
|
||
|
|
{
|
||
|
|
IsProperty = 0x00,
|
||
|
|
IsWxString = 0x01,
|
||
|
|
IsCharPtr = 0x02,
|
||
|
|
IsWCharPtr = 0x04,
|
||
|
|
OwnsWxString = 0x10
|
||
|
|
};
|
||
|
|
|
||
|
|
union
|
||
|
|
{
|
||
|
|
wxPGProperty* property;
|
||
|
|
const char* charName;
|
||
|
|
const wchar_t* wcharName;
|
||
|
|
const wxString* stringName;
|
||
|
|
} m_ptr;
|
||
|
|
unsigned char m_flags;
|
||
|
|
};
|
||
|
|
|
||
|
|
typedef const wxPGPropArgCls& wxPGPropArg;
|
||
|
|
|
||
|
|
// -----------------------------------------------------------------------
|
||
|
|
|
||
|
|
WXDLLIMPEXP_PROPGRID
|
||
|
|
void wxPGTypeOperationFailed( const wxPGProperty* p,
|
||
|
|
const wxString& typestr,
|
||
|
|
const wxString& op );
|
||
|
|
WXDLLIMPEXP_PROPGRID
|
||
|
|
void wxPGGetFailed( const wxPGProperty* p, const wxString& typestr );
|
||
|
|
|
||
|
|
// -----------------------------------------------------------------------
|
||
|
|
|
||
|
|
// Helper macro that does necessary preparations when calling
|
||
|
|
// some wxPGProperty's member function.
|
||
|
|
#define wxPG_PROP_ARG_CALL_PROLOG_0(PROPERTY) \
|
||
|
|
PROPERTY *p = (PROPERTY*)id.GetPtr(this); \
|
||
|
|
if ( !p ) return;
|
||
|
|
|
||
|
|
#define wxPG_PROP_ARG_CALL_PROLOG_RETVAL_0(PROPERTY, RETVAL) \
|
||
|
|
PROPERTY *p = (PROPERTY*)id.GetPtr(this); \
|
||
|
|
if ( !p ) return RETVAL;
|
||
|
|
|
||
|
|
#define wxPG_PROP_ARG_CALL_PROLOG() \
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_0(wxPGProperty)
|
||
|
|
|
||
|
|
#define wxPG_PROP_ARG_CALL_PROLOG_RETVAL(RVAL) \
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL_0(wxPGProperty, RVAL)
|
||
|
|
|
||
|
|
#define wxPG_PROP_ID_CONST_CALL_PROLOG() \
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_0(const wxPGProperty)
|
||
|
|
|
||
|
|
#define wxPG_PROP_ID_CONST_CALL_PROLOG_RETVAL(RVAL) \
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL_0(const wxPGProperty, RVAL)
|
||
|
|
|
||
|
|
// -----------------------------------------------------------------------
|
||
|
|
|
||
|
|
|
||
|
|
// Most of the shared property manipulation interface shared by wxPropertyGrid,
|
||
|
|
// wxPropertyGridPage, and wxPropertyGridManager is defined in this class.
|
||
|
|
// In separate wxPropertyGrid component this class was known as
|
||
|
|
// wxPropertyContainerMethods.
|
||
|
|
// wxPropertyGridInterface's property operation member functions all accept
|
||
|
|
// a special wxPGPropArg id argument, using which you can refer to properties
|
||
|
|
// either by their pointer (for performance) or by their name (for conveniency).
|
||
|
|
class WXDLLIMPEXP_PROPGRID wxPropertyGridInterface
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
|
||
|
|
// Destructor.
|
||
|
|
virtual ~wxPropertyGridInterface() { }
|
||
|
|
|
||
|
|
// Appends property to the list.
|
||
|
|
// wxPropertyGrid assumes ownership of the object.
|
||
|
|
// Becomes child of most recently added category.
|
||
|
|
// wxPropertyGrid takes the ownership of the property pointer.
|
||
|
|
// If appending a category with name identical to a category already in
|
||
|
|
// the wxPropertyGrid, then newly created category is deleted, and most
|
||
|
|
// recently added category (under which properties are appended) is set
|
||
|
|
// to the one with same name. This allows easier adding of items to same
|
||
|
|
// categories in multiple passes.
|
||
|
|
// Does not automatically redraw the control, so you may need to call
|
||
|
|
// Refresh when calling this function after control has been shown for
|
||
|
|
// the first time.
|
||
|
|
// This functions deselects selected property, if any. Validation
|
||
|
|
// failure option wxPG_VFB_STAY_IN_PROPERTY is not respected, ie.
|
||
|
|
// selection is cleared even if editor had invalid value.
|
||
|
|
wxPGProperty* Append( wxPGProperty* property );
|
||
|
|
|
||
|
|
// Same as Append(), but appends under given parent property.
|
||
|
|
wxPGProperty* AppendIn( wxPGPropArg id, wxPGProperty* newproperty );
|
||
|
|
|
||
|
|
// In order to add new items into a property with fixed children (for
|
||
|
|
// instance, wxFlagsProperty), you need to call this method. After
|
||
|
|
// populating has been finished, you need to call EndAddChildren.
|
||
|
|
void BeginAddChildren( wxPGPropArg id );
|
||
|
|
|
||
|
|
// Deletes all properties.
|
||
|
|
virtual void Clear() = 0;
|
||
|
|
|
||
|
|
// Clears current selection, if any.
|
||
|
|
// validation - If set to false, deselecting the property will always work,
|
||
|
|
// even if its editor had invalid value in it.
|
||
|
|
// Returns true if successful or if there was no selection. May
|
||
|
|
// fail if validation was enabled and active editor had invalid
|
||
|
|
// value.
|
||
|
|
bool ClearSelection( bool validation = false );
|
||
|
|
|
||
|
|
// Resets modified status of all properties.
|
||
|
|
void ClearModifiedStatus();
|
||
|
|
|
||
|
|
// Collapses given category or property with children.
|
||
|
|
// Returns true if actually collapses.
|
||
|
|
bool Collapse( wxPGPropArg id );
|
||
|
|
|
||
|
|
// Collapses all items that can be collapsed.
|
||
|
|
// Return false if failed (may fail if editor value cannot be validated).
|
||
|
|
bool CollapseAll() { return ExpandAll(false); }
|
||
|
|
|
||
|
|
// Changes value of a property, as if from an editor.
|
||
|
|
// Use this instead of SetPropertyValue() if you need the value to run
|
||
|
|
// through validation process, and also send the property change event.
|
||
|
|
// Returns true if value was successfully changed.
|
||
|
|
bool ChangePropertyValue( wxPGPropArg id, wxVariant newValue );
|
||
|
|
|
||
|
|
// Removes and deletes a property and any children.
|
||
|
|
// id - Pointer or name of a property.
|
||
|
|
// If you delete a property in a wxPropertyGrid event
|
||
|
|
// handler, the actual deletion is postponed until the next
|
||
|
|
// idle event.
|
||
|
|
// This functions deselects selected property, if any.
|
||
|
|
// Validation failure option wxPG_VFB_STAY_IN_PROPERTY is not
|
||
|
|
// respected, ie. selection is cleared even if editor had
|
||
|
|
// invalid value.
|
||
|
|
void DeleteProperty( wxPGPropArg id );
|
||
|
|
|
||
|
|
// Removes a property. Does not delete the property object, but
|
||
|
|
// instead returns it.
|
||
|
|
// id - Pointer or name of a property.
|
||
|
|
// Removed property cannot have any children.
|
||
|
|
// Also, if you remove property in a wxPropertyGrid event
|
||
|
|
// handler, the actual removal is postponed until the next
|
||
|
|
// idle event.
|
||
|
|
wxPGProperty* RemoveProperty( wxPGPropArg id );
|
||
|
|
|
||
|
|
// Disables a property.
|
||
|
|
bool DisableProperty( wxPGPropArg id ) { return EnableProperty(id,false); }
|
||
|
|
|
||
|
|
// Returns true if all property grid data changes have been committed.
|
||
|
|
// Usually only returns false if value in active editor has been
|
||
|
|
// invalidated by a wxValidator.
|
||
|
|
bool EditorValidate();
|
||
|
|
|
||
|
|
// Enables or disables property, depending on whether enable is true or
|
||
|
|
// false. Disabled property usually appears as having grey text.
|
||
|
|
// id - Name or pointer to a property.
|
||
|
|
// enable - If false, property is disabled instead.
|
||
|
|
bool EnableProperty( wxPGPropArg id, bool enable = true );
|
||
|
|
|
||
|
|
// Called after population of property with fixed children has finished.
|
||
|
|
void EndAddChildren( wxPGPropArg id );
|
||
|
|
|
||
|
|
// Expands given category or property with children.
|
||
|
|
// Returns true if actually expands.
|
||
|
|
bool Expand( wxPGPropArg id );
|
||
|
|
|
||
|
|
// Expands all items that can be expanded.
|
||
|
|
bool ExpandAll( bool expand = true );
|
||
|
|
|
||
|
|
// Returns id of first child of given property.
|
||
|
|
// Does not return sub-properties!
|
||
|
|
wxPGProperty* GetFirstChild( wxPGPropArg id )
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
|
||
|
|
|
||
|
|
if ( !p->GetChildCount() || p->HasFlag(wxPG_PROP_AGGREGATE) )
|
||
|
|
return wxNullProperty;
|
||
|
|
|
||
|
|
return p->Item(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns iterator class instance.
|
||
|
|
// flags - See wxPG_ITERATOR_FLAGS. Value wxPG_ITERATE_DEFAULT causes
|
||
|
|
// iteration over everything except private child properties.
|
||
|
|
// firstProp - Property to start iteration from. If NULL, then first
|
||
|
|
// child of root is used.
|
||
|
|
wxPropertyGridIterator GetIterator( int flags = wxPG_ITERATE_DEFAULT,
|
||
|
|
wxPGProperty* firstProp = NULL )
|
||
|
|
{
|
||
|
|
return wxPropertyGridIterator( m_pState, flags, firstProp );
|
||
|
|
}
|
||
|
|
|
||
|
|
wxPropertyGridConstIterator
|
||
|
|
GetIterator( int flags = wxPG_ITERATE_DEFAULT,
|
||
|
|
wxPGProperty* firstProp = NULL ) const
|
||
|
|
{
|
||
|
|
return wxPropertyGridConstIterator( m_pState, flags, firstProp );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns iterator class instance.
|
||
|
|
// flags - See wxPG_ITERATOR_FLAGS. Value wxPG_ITERATE_DEFAULT causes
|
||
|
|
// iteration over everything except private child properties.
|
||
|
|
// startPos - Either wxTOP or wxBOTTOM. wxTOP will indicate that iterations start
|
||
|
|
// from the first property from the top, and wxBOTTOM means that the
|
||
|
|
// iteration will instead begin from bottommost valid item.
|
||
|
|
wxPropertyGridIterator GetIterator( int flags, int startPos )
|
||
|
|
{
|
||
|
|
return wxPropertyGridIterator( m_pState, flags, startPos );
|
||
|
|
}
|
||
|
|
|
||
|
|
wxPropertyGridConstIterator GetIterator( int flags, int startPos ) const
|
||
|
|
{
|
||
|
|
return wxPropertyGridConstIterator( m_pState, flags, startPos );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns id of first item that matches given criteria.
|
||
|
|
wxPGProperty* GetFirst( int flags = wxPG_ITERATE_ALL )
|
||
|
|
{
|
||
|
|
wxPropertyGridIterator it( m_pState, flags, wxNullProperty, 1 );
|
||
|
|
return *it;
|
||
|
|
}
|
||
|
|
|
||
|
|
const wxPGProperty* GetFirst( int flags = wxPG_ITERATE_ALL ) const
|
||
|
|
{
|
||
|
|
return const_cast<wxPropertyGridInterface*>(this)->GetFirst(flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns pointer to a property with given name (case-sensitive).
|
||
|
|
// If there is no property with such name, NULL pointer is returned.
|
||
|
|
// Properties which have non-category, non-root parent
|
||
|
|
// cannot be accessed globally by their name. Instead, use
|
||
|
|
// "<property>.<subproperty>" instead of "<subproperty>".
|
||
|
|
wxPGProperty* GetProperty( const wxString& name ) const
|
||
|
|
{
|
||
|
|
return GetPropertyByName(name);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns map-like storage of property's attributes.
|
||
|
|
// Note that if extra style wxPG_EX_WRITEONLY_BUILTIN_ATTRIBUTES is set,
|
||
|
|
// then builtin-attributes are not included in the storage.
|
||
|
|
const wxPGAttributeStorage& GetPropertyAttributes( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
// If 'id' refers to invalid property, then we will return dummy
|
||
|
|
// attributes (i.e. root property's attributes, which contents should
|
||
|
|
// should always be empty and of no consequence).
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(m_pState->DoGetRoot()->GetAttributes())
|
||
|
|
return p->GetAttributes();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Adds to 'targetArr' pointers to properties that have given
|
||
|
|
// flags 'flags' set. However, if 'inverse' is set to true, then
|
||
|
|
// only properties without given flags are stored.
|
||
|
|
// flags - Property flags to use.
|
||
|
|
// iterFlags - Iterator flags to use. Default is everything expect private children.
|
||
|
|
void GetPropertiesWithFlag( wxArrayPGProperty* targetArr,
|
||
|
|
wxPGProperty::FlagType flags,
|
||
|
|
bool inverse = false,
|
||
|
|
int iterFlags = wxPG_ITERATE_PROPERTIES |
|
||
|
|
wxPG_ITERATE_HIDDEN |
|
||
|
|
wxPG_ITERATE_CATEGORIES) const;
|
||
|
|
|
||
|
|
// Returns value of given attribute. If none found, returns wxNullVariant.
|
||
|
|
wxVariant GetPropertyAttribute( wxPGPropArg id,
|
||
|
|
const wxString& attrName ) const
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullVariant)
|
||
|
|
return p->GetAttribute(attrName);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns pointer of property's nearest parent category. If no category
|
||
|
|
// found, returns NULL.
|
||
|
|
wxPropertyCategory* GetPropertyCategory( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
wxPG_PROP_ID_CONST_CALL_PROLOG_RETVAL(NULL)
|
||
|
|
return m_pState->GetPropertyCategory(p);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns client data (void*) of a property.
|
||
|
|
void* GetPropertyClientData( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
|
||
|
|
return p->GetClientData();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns first property which label matches given string.
|
||
|
|
// NULL if none found. Note that this operation is extremely slow when
|
||
|
|
// compared to GetPropertyByName().
|
||
|
|
wxPGProperty* GetPropertyByLabel( const wxString& label ) const;
|
||
|
|
|
||
|
|
// Returns pointer to a property with given name (case-sensitive).
|
||
|
|
// If there is no property with such name, @NULL pointer is returned.
|
||
|
|
wxPGProperty* GetPropertyByName( const wxString& name ) const;
|
||
|
|
|
||
|
|
// Returns child property 'subname' of property 'name'. Same as
|
||
|
|
// calling GetPropertyByName("name.subname"), albeit slightly faster.
|
||
|
|
wxPGProperty* GetPropertyByName( const wxString& name,
|
||
|
|
const wxString& subname ) const;
|
||
|
|
|
||
|
|
// Returns property's editor.
|
||
|
|
const wxPGEditor* GetPropertyEditor( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
|
||
|
|
return p->GetEditorClass();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns help string associated with a property.
|
||
|
|
wxString GetPropertyHelpString( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxEmptyString)
|
||
|
|
return p->GetHelpString();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns property's custom value image (NULL of none).
|
||
|
|
wxBitmap* GetPropertyImage( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
|
||
|
|
return p->GetValueImage();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns label of a property.
|
||
|
|
const wxString& GetPropertyLabel( wxPGPropArg id )
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(m_emptyString)
|
||
|
|
return p->GetLabel();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns name of a property, by which it is globally accessible.
|
||
|
|
wxString GetPropertyName( wxPGProperty* property )
|
||
|
|
{
|
||
|
|
return property->GetName();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns parent item of a property.
|
||
|
|
wxPGProperty* GetPropertyParent( wxPGPropArg id )
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
|
||
|
|
return p->GetParent();
|
||
|
|
}
|
||
|
|
|
||
|
|
#if wxUSE_VALIDATORS
|
||
|
|
// Returns validator of a property as a reference, which you
|
||
|
|
// can pass to any number of SetPropertyValidator.
|
||
|
|
wxValidator* GetPropertyValidator( wxPGPropArg id )
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
|
||
|
|
return p->GetValidator();
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// Returns value as wxVariant. To get wxObject pointer from it,
|
||
|
|
// you will have to use WX_PG_VARIANT_TO_WXOBJECT(VARIANT,CLASSNAME) macro.
|
||
|
|
// If property value is unspecified, wxNullVariant is returned.
|
||
|
|
wxVariant GetPropertyValue( wxPGPropArg id )
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxVariant())
|
||
|
|
return p->GetValue();
|
||
|
|
}
|
||
|
|
|
||
|
|
wxString GetPropertyValueAsString( wxPGPropArg id ) const;
|
||
|
|
long GetPropertyValueAsLong( wxPGPropArg id ) const;
|
||
|
|
unsigned long GetPropertyValueAsULong( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
return (unsigned long) GetPropertyValueAsLong(id);
|
||
|
|
}
|
||
|
|
int GetPropertyValueAsInt( wxPGPropArg id ) const
|
||
|
|
{ return (int)GetPropertyValueAsLong(id); }
|
||
|
|
bool GetPropertyValueAsBool( wxPGPropArg id ) const;
|
||
|
|
double GetPropertyValueAsDouble( wxPGPropArg id ) const;
|
||
|
|
|
||
|
|
#define wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(PGTypeName, DEFVAL) \
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(DEFVAL) \
|
||
|
|
wxVariant value = p->GetValue(); \
|
||
|
|
if ( !value.IsType(PGTypeName) ) \
|
||
|
|
{ \
|
||
|
|
wxPGGetFailed(p, PGTypeName); \
|
||
|
|
return DEFVAL; \
|
||
|
|
}
|
||
|
|
|
||
|
|
#define wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL_WFALLBACK(PGTypeName, DEFVAL) \
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(DEFVAL) \
|
||
|
|
wxVariant value = p->GetValue(); \
|
||
|
|
if ( !value.IsType(PGTypeName) ) \
|
||
|
|
return DEFVAL; \
|
||
|
|
|
||
|
|
wxArrayString GetPropertyValueAsArrayString( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(wxPG_VARIANT_TYPE_ARRSTRING,
|
||
|
|
wxArrayString())
|
||
|
|
return value.GetArrayString();
|
||
|
|
}
|
||
|
|
|
||
|
|
#if defined(wxLongLong_t) && wxUSE_LONGLONG
|
||
|
|
wxLongLong_t GetPropertyValueAsLongLong( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(0)
|
||
|
|
return p->GetValue().GetLongLong().GetValue();
|
||
|
|
}
|
||
|
|
|
||
|
|
wxULongLong_t GetPropertyValueAsULongLong( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(0)
|
||
|
|
return p->GetValue().GetULongLong().GetValue();
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
wxArrayInt GetPropertyValueAsArrayInt( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(wxArrayInt_VariantType,
|
||
|
|
wxArrayInt())
|
||
|
|
wxArrayInt arr;
|
||
|
|
arr << value;
|
||
|
|
return arr;
|
||
|
|
}
|
||
|
|
|
||
|
|
#if wxUSE_DATETIME
|
||
|
|
wxDateTime GetPropertyValueAsDateTime( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(wxPG_VARIANT_TYPE_DATETIME,
|
||
|
|
wxDateTime())
|
||
|
|
return value.GetDateTime();
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// Returns a wxVariant list containing wxVariant versions of all
|
||
|
|
// property values. Order is not guaranteed.
|
||
|
|
// flags - Use wxPG_KEEP_STRUCTURE to retain category structure; each sub
|
||
|
|
// category will be its own wxVariantList of wxVariant.
|
||
|
|
// Use wxPG_INC_ATTRIBUTES to include property attributes as well.
|
||
|
|
// Each attribute will be stored as list variant named
|
||
|
|
// "@<propname>@attr."
|
||
|
|
wxVariant GetPropertyValues( const wxString& listname = wxEmptyString,
|
||
|
|
wxPGProperty* baseparent = NULL, long flags = 0 ) const
|
||
|
|
{
|
||
|
|
return m_pState->DoGetPropertyValues(listname, baseparent, flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns currently selected property. NULL if none.
|
||
|
|
// When wxPG_EX_MULTIPLE_SELECTION extra style is used, this
|
||
|
|
// member function returns the focused property, that is the
|
||
|
|
// one which can have active editor.
|
||
|
|
wxPGProperty* GetSelection() const;
|
||
|
|
|
||
|
|
// Returns list of currently selected properties.
|
||
|
|
// wxArrayPGProperty should be compatible with std::vector API.
|
||
|
|
const wxArrayPGProperty& GetSelectedProperties() const
|
||
|
|
{
|
||
|
|
return m_pState->m_selection;
|
||
|
|
}
|
||
|
|
|
||
|
|
wxPropertyGridPageState* GetState() const { return m_pState; }
|
||
|
|
|
||
|
|
// Similar to GetIterator(), but instead returns wxPGVIterator instance,
|
||
|
|
// which can be useful for forward-iterating through arbitrary property
|
||
|
|
// containers.
|
||
|
|
// flags - See wxPG_ITERATOR_FLAGS.
|
||
|
|
virtual wxPGVIterator GetVIterator( int flags ) const;
|
||
|
|
|
||
|
|
// Hides or reveals a property.
|
||
|
|
// hide - If true, hides property, otherwise reveals it.
|
||
|
|
// flags - By default changes are applied recursively. Set this parameter
|
||
|
|
// wxPG_DONT_RECURSE to prevent this.
|
||
|
|
bool HideProperty( wxPGPropArg id,
|
||
|
|
bool hide = true,
|
||
|
|
int flags = wxPG_RECURSE );
|
||
|
|
|
||
|
|
#if wxPG_INCLUDE_ADVPROPS
|
||
|
|
// Initializes *all* property types. Causes references to most object
|
||
|
|
// files in the library, so calling this may cause significant increase
|
||
|
|
// in executable size when linking with static library.
|
||
|
|
static void InitAllTypeHandlers();
|
||
|
|
#else
|
||
|
|
static void InitAllTypeHandlers() { }
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// Inserts property to the property container.
|
||
|
|
// priorThis - New property is inserted just prior to this. Available only
|
||
|
|
// in the first variant. There are two versions of this function
|
||
|
|
// to allow this parameter to be either an id or name to
|
||
|
|
// a property.
|
||
|
|
// newproperty - Pointer to the inserted property. wxPropertyGrid will take
|
||
|
|
// ownership of this object.
|
||
|
|
// Returns id for the property,
|
||
|
|
// wxPropertyGrid takes the ownership of the property pointer.
|
||
|
|
// While Append may be faster way to add items, make note that when
|
||
|
|
// both types of data storage (categoric and
|
||
|
|
// non-categoric) are active, Insert becomes even more slow. This is
|
||
|
|
// especially true if current mode is non-categoric.
|
||
|
|
// Example of use:
|
||
|
|
// // append category
|
||
|
|
// wxPGProperty* my_cat_id = propertygrid->Append(
|
||
|
|
// new wxPropertyCategory("My Category") );
|
||
|
|
// ...
|
||
|
|
// // insert into category - using second variant
|
||
|
|
// wxPGProperty* my_item_id_1 = propertygrid->Insert(
|
||
|
|
// my_cat_id, 0, new wxStringProperty("My String 1") );
|
||
|
|
// // insert before to first item - using first variant
|
||
|
|
// wxPGProperty* my_item_id_2 = propertygrid->Insert(
|
||
|
|
// my_item_id, new wxStringProperty("My String 2") );
|
||
|
|
wxPGProperty* Insert( wxPGPropArg priorThis, wxPGProperty* newproperty );
|
||
|
|
|
||
|
|
// Inserts property to the property container.
|
||
|
|
//See the other overload for more details.
|
||
|
|
// parent - New property is inserted under this category. Available only
|
||
|
|
// in the second variant. There are two versions of this function
|
||
|
|
// to allow this parameter to be either an id or name to
|
||
|
|
// a property.
|
||
|
|
// index - Index under category. Available only in the second variant.
|
||
|
|
// If index is < 0, property is appended in category.
|
||
|
|
// newproperty - Pointer to the inserted property. wxPropertyGrid will take
|
||
|
|
// ownership of this object.
|
||
|
|
// Returns id for the property.
|
||
|
|
wxPGProperty* Insert( wxPGPropArg parent,
|
||
|
|
int index,
|
||
|
|
wxPGProperty* newproperty );
|
||
|
|
|
||
|
|
// Returns true if property is a category.
|
||
|
|
bool IsPropertyCategory( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
|
||
|
|
return p->IsCategory();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns true if property is enabled.
|
||
|
|
bool IsPropertyEnabled( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
|
||
|
|
return !p->HasFlag(wxPG_PROP_DISABLED);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns true if given property is expanded.
|
||
|
|
// Naturally, always returns false for properties that cannot be expanded.
|
||
|
|
bool IsPropertyExpanded( wxPGPropArg id ) const;
|
||
|
|
|
||
|
|
// Returns true if property has been modified after value set or modify
|
||
|
|
// flag clear by software.
|
||
|
|
bool IsPropertyModified( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
|
||
|
|
#if WXWIN_COMPATIBILITY_3_0
|
||
|
|
return p->HasFlag(wxPG_PROP_MODIFIED)?true:false;
|
||
|
|
#else
|
||
|
|
return p->HasFlag(wxPG_PROP_MODIFIED);
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns true if property is selected.
|
||
|
|
bool IsPropertySelected( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
|
||
|
|
return m_pState->DoIsPropertySelected(p);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns true if property is shown (i.e. HideProperty with true not
|
||
|
|
// called for it).
|
||
|
|
bool IsPropertyShown( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
|
||
|
|
return !p->HasFlag(wxPG_PROP_HIDDEN);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns true if property value is set to unspecified.
|
||
|
|
bool IsPropertyValueUnspecified( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
|
||
|
|
return p->IsValueUnspecified();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Disables (limit = true) or enables (limit = false) wxTextCtrl editor
|
||
|
|
// of a property, if it is not the sole mean to edit the value.
|
||
|
|
void LimitPropertyEditing( wxPGPropArg id, bool limit = true );
|
||
|
|
|
||
|
|
// If state is shown in it's grid, refresh it now.
|
||
|
|
virtual void RefreshGrid( wxPropertyGridPageState* state = NULL );
|
||
|
|
|
||
|
|
#if wxPG_INCLUDE_ADVPROPS
|
||
|
|
// Initializes additional property editors (SpinCtrl etc.). Causes
|
||
|
|
// references to most object files in the library, so calling this may
|
||
|
|
// cause significant increase in executable size when linking with static
|
||
|
|
// library.
|
||
|
|
static void RegisterAdditionalEditors();
|
||
|
|
#else
|
||
|
|
static void RegisterAdditionalEditors() { }
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// Replaces property with id with newly created property. For example,
|
||
|
|
// this code replaces existing property named "Flags" with one that
|
||
|
|
// will have different set of items:
|
||
|
|
// pg->ReplaceProperty("Flags",
|
||
|
|
// wxFlagsProperty("Flags", wxPG_LABEL, newItems))
|
||
|
|
// For more info, see wxPropertyGrid::Insert.
|
||
|
|
wxPGProperty* ReplaceProperty( wxPGPropArg id, wxPGProperty* property );
|
||
|
|
|
||
|
|
// Flags for wxPropertyGridInterface::SaveEditableState()
|
||
|
|
// and wxPropertyGridInterface::RestoreEditableState().
|
||
|
|
enum EditableStateFlags
|
||
|
|
{
|
||
|
|
// Include selected property.
|
||
|
|
SelectionState = 0x01,
|
||
|
|
// Include expanded/collapsed property information.
|
||
|
|
ExpandedState = 0x02,
|
||
|
|
// Include scrolled position.
|
||
|
|
ScrollPosState = 0x04,
|
||
|
|
// Include selected page information.
|
||
|
|
// Only applies to wxPropertyGridManager.
|
||
|
|
PageState = 0x08,
|
||
|
|
// Include splitter position. Stored for each page.
|
||
|
|
SplitterPosState = 0x10,
|
||
|
|
// Include description box size.
|
||
|
|
// Only applies to wxPropertyGridManager.
|
||
|
|
DescBoxState = 0x20,
|
||
|
|
|
||
|
|
// Include all supported user editable state information.
|
||
|
|
// This is usually the default value.
|
||
|
|
AllStates = SelectionState |
|
||
|
|
ExpandedState |
|
||
|
|
ScrollPosState |
|
||
|
|
PageState |
|
||
|
|
SplitterPosState |
|
||
|
|
DescBoxState
|
||
|
|
};
|
||
|
|
|
||
|
|
// Restores user-editable state.
|
||
|
|
// See also wxPropertyGridInterface::SaveEditableState().
|
||
|
|
// src - String generated by SaveEditableState.
|
||
|
|
// restoreStates - Which parts to restore from source string. See @ref
|
||
|
|
// propgridinterface_editablestate_flags "list of editable state
|
||
|
|
// flags".
|
||
|
|
// Returns false if there was problem reading the string.
|
||
|
|
// If some parts of state (such as scrolled or splitter position) fail to
|
||
|
|
// restore correctly, please make sure that you call this function after
|
||
|
|
// wxPropertyGrid size has been set (this may sometimes be tricky when
|
||
|
|
// sizers are used).
|
||
|
|
bool RestoreEditableState( const wxString& src,
|
||
|
|
int restoreStates = AllStates );
|
||
|
|
|
||
|
|
// Used to acquire user-editable state (selected property, expanded
|
||
|
|
// properties, scrolled position, splitter positions).
|
||
|
|
// includedStates - Which parts of state to include. See EditableStateFlags.
|
||
|
|
wxString SaveEditableState( int includedStates = AllStates ) const;
|
||
|
|
|
||
|
|
// Lets user set the strings listed in the choice dropdown of a
|
||
|
|
// wxBoolProperty. Defaults are "True" and "False", so changing them to,
|
||
|
|
// say, "Yes" and "No" may be useful in some less technical applications.
|
||
|
|
static void SetBoolChoices( const wxString& trueChoice,
|
||
|
|
const wxString& falseChoice );
|
||
|
|
|
||
|
|
// Set proportion of a auto-stretchable column. wxPG_SPLITTER_AUTO_CENTER
|
||
|
|
// window style needs to be used to indicate that columns are auto-
|
||
|
|
// resizable.
|
||
|
|
// Returns false on failure.
|
||
|
|
// You should call this for individual pages of wxPropertyGridManager
|
||
|
|
// (if used).
|
||
|
|
bool SetColumnProportion( unsigned int column, int proportion );
|
||
|
|
|
||
|
|
// Returns auto-resize proportion of the given column.
|
||
|
|
int GetColumnProportion( unsigned int column ) const
|
||
|
|
{
|
||
|
|
return m_pState->DoGetColumnProportion(column);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets an attribute for this property.
|
||
|
|
// name - Text identifier of attribute. See @ref propgrid_property_attributes.
|
||
|
|
// value - Value of attribute.
|
||
|
|
// argFlags - Optional. Use wxPG_RECURSE to set the attribute to child
|
||
|
|
// properties recursively.
|
||
|
|
// Setting attribute's value to wxNullVariant will simply remove it
|
||
|
|
// from property's set of attributes.
|
||
|
|
void SetPropertyAttribute( wxPGPropArg id,
|
||
|
|
const wxString& attrName,
|
||
|
|
wxVariant value,
|
||
|
|
long argFlags = 0 )
|
||
|
|
{
|
||
|
|
DoSetPropertyAttribute(id,attrName,value,argFlags);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets property attribute for all applicable properties.
|
||
|
|
// Be sure to use this method only after all properties have been
|
||
|
|
// added to the grid.
|
||
|
|
void SetPropertyAttributeAll( const wxString& attrName, wxVariant value );
|
||
|
|
|
||
|
|
// Sets background colour of a property.
|
||
|
|
// id - Property name or pointer.
|
||
|
|
// colour - New background colour.
|
||
|
|
// flags - Default is wxPG_RECURSE which causes colour to be set recursively.
|
||
|
|
// Omit this flag to only set colour for the property in question
|
||
|
|
// and not any of its children.
|
||
|
|
void SetPropertyBackgroundColour( wxPGPropArg id,
|
||
|
|
const wxColour& colour,
|
||
|
|
int flags = wxPG_RECURSE );
|
||
|
|
|
||
|
|
// Resets text and background colours of given property.
|
||
|
|
// id - Property name or pointer.
|
||
|
|
// flags - Default is wxPG_DONT_RECURSE which causes colour to be reset
|
||
|
|
// only for the property in question (for backward compatibility).
|
||
|
|
#if WXWIN_COMPATIBILITY_3_0
|
||
|
|
void SetPropertyColoursToDefault(wxPGPropArg id);
|
||
|
|
void SetPropertyColoursToDefault(wxPGPropArg id, int flags);
|
||
|
|
#else
|
||
|
|
void SetPropertyColoursToDefault(wxPGPropArg id, int flags = wxPG_DONT_RECURSE);
|
||
|
|
#endif // WXWIN_COMPATIBILITY_3_0
|
||
|
|
|
||
|
|
// Sets text colour of a property.
|
||
|
|
// id - Property name or pointer.
|
||
|
|
// colour - New background colour.
|
||
|
|
// flags - Default is wxPG_RECURSE which causes colour to be set recursively.
|
||
|
|
// Omit this flag to only set colour for the property in question
|
||
|
|
// and not any of its children.
|
||
|
|
void SetPropertyTextColour( wxPGPropArg id,
|
||
|
|
const wxColour& col,
|
||
|
|
int flags = wxPG_RECURSE );
|
||
|
|
|
||
|
|
// Returns background colour of first cell of a property.
|
||
|
|
wxColour GetPropertyBackgroundColour( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxColour())
|
||
|
|
return p->GetCell(0).GetBgCol();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns text colour of first cell of a property.
|
||
|
|
wxColour GetPropertyTextColour( wxPGPropArg id ) const
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxColour())
|
||
|
|
return p->GetCell(0).GetFgCol();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets text, bitmap, and colours for given column's cell.
|
||
|
|
// You can set label cell by setting column to 0.
|
||
|
|
// You can use wxPG_LABEL as text to use default text for column.
|
||
|
|
void SetPropertyCell( wxPGPropArg id,
|
||
|
|
int column,
|
||
|
|
const wxString& text = wxEmptyString,
|
||
|
|
const wxBitmap& bitmap = wxNullBitmap,
|
||
|
|
const wxColour& fgCol = wxNullColour,
|
||
|
|
const wxColour& bgCol = wxNullColour );
|
||
|
|
|
||
|
|
// Sets client data (void*) of a property.
|
||
|
|
// This untyped client data has to be deleted manually.
|
||
|
|
void SetPropertyClientData( wxPGPropArg id, void* clientData )
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG()
|
||
|
|
p->SetClientData(clientData);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets editor for a property.
|
||
|
|
// editor - For builtin editors, use wxPGEditor_X, where X is builtin editor's
|
||
|
|
// name (TextCtrl, Choice, etc. see wxPGEditor documentation for full
|
||
|
|
// list).
|
||
|
|
// For custom editors, use pointer you received from
|
||
|
|
// wxPropertyGrid::RegisterEditorClass().
|
||
|
|
void SetPropertyEditor( wxPGPropArg id, const wxPGEditor* editor )
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG()
|
||
|
|
wxCHECK_RET( editor, wxS("unknown/NULL editor") );
|
||
|
|
p->SetEditor(editor);
|
||
|
|
RefreshProperty(p);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets editor control of a property. As editor argument, use
|
||
|
|
// editor name string, such as "TextCtrl" or "Choice".
|
||
|
|
void SetPropertyEditor( wxPGPropArg id, const wxString& editorName )
|
||
|
|
{
|
||
|
|
SetPropertyEditor(id,GetEditorByName(editorName));
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets label of a property.
|
||
|
|
// Properties under same parent may have same labels. However,
|
||
|
|
// property names must still remain unique.
|
||
|
|
void SetPropertyLabel( wxPGPropArg id, const wxString& newproplabel );
|
||
|
|
|
||
|
|
// Sets name of a property.
|
||
|
|
// id - Name or pointer of property which name to change.
|
||
|
|
// newName - New name for property.
|
||
|
|
void SetPropertyName( wxPGPropArg id, const wxString& newName )
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG()
|
||
|
|
m_pState->DoSetPropertyName( p, newName );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets property (and, recursively, its children) to have read-only value.
|
||
|
|
// In other words, user cannot change the value in the editor, but they
|
||
|
|
// can still copy it.
|
||
|
|
// This is mainly for use with textctrl editor. Not all other editors fully
|
||
|
|
// support it.
|
||
|
|
// By default changes are applied recursively. Set parameter "flags"
|
||
|
|
// to wxPG_DONT_RECURSE to prevent this.
|
||
|
|
void SetPropertyReadOnly( wxPGPropArg id,
|
||
|
|
bool set = true,
|
||
|
|
int flags = wxPG_RECURSE );
|
||
|
|
|
||
|
|
// Sets property's value to unspecified.
|
||
|
|
// If it has children (it may be category), then the same thing is done to
|
||
|
|
// them.
|
||
|
|
void SetPropertyValueUnspecified( wxPGPropArg id )
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG()
|
||
|
|
p->SetValueToUnspecified();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets property values from a list of wxVariants.
|
||
|
|
void SetPropertyValues( const wxVariantList& list,
|
||
|
|
wxPGPropArg defaultCategory = wxNullProperty )
|
||
|
|
{
|
||
|
|
wxPGProperty *p;
|
||
|
|
if ( defaultCategory.HasName() ) p = defaultCategory.GetPtr(this);
|
||
|
|
else p = defaultCategory.GetPtr0();
|
||
|
|
m_pState->DoSetPropertyValues(list, p);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets property values from a list of wxVariants.
|
||
|
|
void SetPropertyValues( const wxVariant& list,
|
||
|
|
wxPGPropArg defaultCategory = wxNullProperty )
|
||
|
|
{
|
||
|
|
SetPropertyValues(list.GetList(),defaultCategory);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Associates the help string with property.
|
||
|
|
// By default, text is shown either in the manager's "description"
|
||
|
|
// text box or in the status bar. If extra window style
|
||
|
|
// wxPG_EX_HELP_AS_TOOLTIPS is used, then the text will appear as a
|
||
|
|
// tooltip.
|
||
|
|
void SetPropertyHelpString( wxPGPropArg id, const wxString& helpString )
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG()
|
||
|
|
p->SetHelpString(helpString);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Set wxBitmap in front of the value.
|
||
|
|
// Bitmap will be scaled to a size returned by
|
||
|
|
// wxPropertyGrid::GetImageSize();
|
||
|
|
void SetPropertyImage( wxPGPropArg id, wxBitmap& bmp )
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG()
|
||
|
|
p->SetValueImage(bmp);
|
||
|
|
RefreshProperty(p);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets max length of property's text.
|
||
|
|
bool SetPropertyMaxLength( wxPGPropArg id, int maxLen );
|
||
|
|
|
||
|
|
#if wxUSE_VALIDATORS
|
||
|
|
// Sets validator of a property.
|
||
|
|
void SetPropertyValidator( wxPGPropArg id, const wxValidator& validator )
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG()
|
||
|
|
p->SetValidator(validator);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// Sets value (long integer) of a property.
|
||
|
|
void SetPropertyValue( wxPGPropArg id, long value )
|
||
|
|
{
|
||
|
|
wxVariant v(value);
|
||
|
|
SetPropVal( id, v );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets value (integer) of a property.
|
||
|
|
void SetPropertyValue( wxPGPropArg id, int value )
|
||
|
|
{
|
||
|
|
wxVariant v((long)value);
|
||
|
|
SetPropVal( id, v );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets value (floating point) of a property.
|
||
|
|
void SetPropertyValue( wxPGPropArg id, double value )
|
||
|
|
{
|
||
|
|
wxVariant v(value);
|
||
|
|
SetPropVal( id, v );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets value (bool) of a property.
|
||
|
|
void SetPropertyValue( wxPGPropArg id, bool value )
|
||
|
|
{
|
||
|
|
wxVariant v(value);
|
||
|
|
SetPropVal( id, v );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets value (wchar_t*) of a property.
|
||
|
|
void SetPropertyValue( wxPGPropArg id, const wchar_t* value )
|
||
|
|
{
|
||
|
|
SetPropertyValueString( id, wxString(value) );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets value (char*) of a property.
|
||
|
|
void SetPropertyValue( wxPGPropArg id, const char* value )
|
||
|
|
{
|
||
|
|
SetPropertyValueString( id, wxString(value) );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets value (string) of a property.
|
||
|
|
void SetPropertyValue( wxPGPropArg id, const wxString& value )
|
||
|
|
{
|
||
|
|
SetPropertyValueString( id, value );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets value (wxArrayString) of a property.
|
||
|
|
void SetPropertyValue( wxPGPropArg id, const wxArrayString& value )
|
||
|
|
{
|
||
|
|
wxVariant v(value);
|
||
|
|
SetPropVal( id, v );
|
||
|
|
}
|
||
|
|
|
||
|
|
#if wxUSE_DATETIME
|
||
|
|
// Sets value (wxDateTime) of a property.
|
||
|
|
void SetPropertyValue( wxPGPropArg id, const wxDateTime& value )
|
||
|
|
{
|
||
|
|
wxVariant v(value);
|
||
|
|
SetPropVal( id, v );
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// Sets value (wxObject*) of a property.
|
||
|
|
void SetPropertyValue( wxPGPropArg id, wxObject* value )
|
||
|
|
{
|
||
|
|
wxVariant v(value);
|
||
|
|
SetPropVal( id, v );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets value (wxObject&) of a property.
|
||
|
|
void SetPropertyValue( wxPGPropArg id, wxObject& value )
|
||
|
|
{
|
||
|
|
wxVariant v(&value);
|
||
|
|
SetPropVal( id, v );
|
||
|
|
}
|
||
|
|
|
||
|
|
#if wxUSE_LONGLONG
|
||
|
|
#ifdef wxLongLong_t
|
||
|
|
// Sets value (native 64-bit int) of a property.
|
||
|
|
void SetPropertyValue(wxPGPropArg id, wxLongLong_t value)
|
||
|
|
{
|
||
|
|
wxVariant v = wxLongLong(value);
|
||
|
|
SetPropVal(id, v);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
// Sets value (wxLongLong) of a property.
|
||
|
|
void SetPropertyValue( wxPGPropArg id, wxLongLong value )
|
||
|
|
{
|
||
|
|
wxVariant v(value);
|
||
|
|
SetPropVal( id, v );
|
||
|
|
}
|
||
|
|
#ifdef wxULongLong_t
|
||
|
|
// Sets value (native 64-bit unsigned int) of a property.
|
||
|
|
void SetPropertyValue(wxPGPropArg id, wxULongLong_t value)
|
||
|
|
{
|
||
|
|
wxVariant v = wxULongLong(value);
|
||
|
|
SetPropVal(id, v);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
// Sets value (wxULongLong) of a property.
|
||
|
|
void SetPropertyValue( wxPGPropArg id, wxULongLong value )
|
||
|
|
{
|
||
|
|
wxVariant v(value);
|
||
|
|
SetPropVal( id, v );
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// Sets value (wxArrayInt&) of a property.
|
||
|
|
void SetPropertyValue( wxPGPropArg id, const wxArrayInt& value )
|
||
|
|
{
|
||
|
|
wxVariant v = WXVARIANT(value);
|
||
|
|
SetPropVal( id, v );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets value (wxString) of a property.
|
||
|
|
// This method uses wxPGProperty::SetValueFromString, which all properties
|
||
|
|
// should implement. This means that there should not be a type error,
|
||
|
|
// and instead the string is converted to property's actual value type.
|
||
|
|
void SetPropertyValueString( wxPGPropArg id, const wxString& value );
|
||
|
|
|
||
|
|
// Sets value (wxVariant) of a property.
|
||
|
|
// Use wxPropertyGrid::ChangePropertyValue() instead if you need to run
|
||
|
|
// through validation process and send property change event.
|
||
|
|
void SetPropertyValue( wxPGPropArg id, wxVariant value )
|
||
|
|
{
|
||
|
|
SetPropVal( id, value );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sets value (wxVariant&) of a property. Same as SetPropertyValue,
|
||
|
|
// but accepts reference.
|
||
|
|
void SetPropVal( wxPGPropArg id, wxVariant& value );
|
||
|
|
|
||
|
|
// Adjusts how wxPropertyGrid behaves when invalid value is entered
|
||
|
|
// in a property.
|
||
|
|
// vfbFlags - See wxPG_VALIDATION_FAILURE_BEHAVIOR_FLAGS for possible values.
|
||
|
|
void SetValidationFailureBehavior( int vfbFlags );
|
||
|
|
|
||
|
|
// Sorts all properties recursively.
|
||
|
|
// flags - This can contain any of the following options:
|
||
|
|
// wxPG_SORT_TOP_LEVEL_ONLY: Only sort categories and their
|
||
|
|
// immediate children. Sorting done by wxPG_AUTO_SORT option
|
||
|
|
// uses this.
|
||
|
|
// See SortChildren, wxPropertyGrid::SetSortFunction
|
||
|
|
void Sort( int flags = 0 );
|
||
|
|
|
||
|
|
// Sorts children of a property.
|
||
|
|
// id - Name or pointer to a property.
|
||
|
|
// flags - This can contain any of the following options:
|
||
|
|
// wxPG_RECURSE: Sorts recursively.
|
||
|
|
// See Sort, wxPropertyGrid::SetSortFunction
|
||
|
|
void SortChildren( wxPGPropArg id, int flags = 0 )
|
||
|
|
{
|
||
|
|
wxPG_PROP_ARG_CALL_PROLOG()
|
||
|
|
m_pState->DoSortChildren(p, flags);
|
||
|
|
}
|
||
|
|
|
||
|
|
// GetPropertyByName() with nice assertion error message.
|
||
|
|
wxPGProperty* GetPropertyByNameA( const wxString& name ) const;
|
||
|
|
|
||
|
|
// Returns editor pointer of editor with given name.
|
||
|
|
static wxPGEditor* GetEditorByName( const wxString& editorName );
|
||
|
|
|
||
|
|
// NOTE: This function reselects the property and may cause
|
||
|
|
// excess flicker, so to just call Refresh() on a rect
|
||
|
|
// of single property, call DrawItem() instead.
|
||
|
|
virtual void RefreshProperty( wxPGProperty* p ) = 0;
|
||
|
|
|
||
|
|
protected:
|
||
|
|
|
||
|
|
bool DoClearSelection( bool validation = false,
|
||
|
|
int selFlags = 0 );
|
||
|
|
|
||
|
|
// In derived class, implement to set editable state component with
|
||
|
|
// given name to given value.
|
||
|
|
virtual bool SetEditableStateItem( const wxString& name, wxVariant value )
|
||
|
|
{
|
||
|
|
wxUnusedVar(name);
|
||
|
|
wxUnusedVar(value);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// In derived class, implement to return editable state component with
|
||
|
|
// given name.
|
||
|
|
virtual wxVariant GetEditableStateItem( const wxString& name ) const
|
||
|
|
{
|
||
|
|
wxUnusedVar(name);
|
||
|
|
return wxNullVariant;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns page state data for given (sub) page (-1 means current page).
|
||
|
|
virtual wxPropertyGridPageState* GetPageState( int pageIndex ) const
|
||
|
|
{
|
||
|
|
if ( pageIndex <= 0 )
|
||
|
|
return m_pState;
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual bool DoSelectPage( int WXUNUSED(index) ) { return true; }
|
||
|
|
|
||
|
|
// Default call's m_pState's BaseGetPropertyByName
|
||
|
|
virtual wxPGProperty* DoGetPropertyByName( const wxString& name ) const;
|
||
|
|
|
||
|
|
// Deriving classes must set this (it must be only or current page).
|
||
|
|
wxPropertyGridPageState* m_pState;
|
||
|
|
|
||
|
|
// Intermediate version needed due to wxVariant copying inefficiency
|
||
|
|
void DoSetPropertyAttribute( wxPGPropArg id,
|
||
|
|
const wxString& name,
|
||
|
|
wxVariant& value, long argFlags );
|
||
|
|
|
||
|
|
// Empty string object to return from member functions returning const
|
||
|
|
// wxString&.
|
||
|
|
wxString m_emptyString;
|
||
|
|
|
||
|
|
private:
|
||
|
|
// Cannot be GetGrid() due to ambiguity issues.
|
||
|
|
wxPropertyGrid* GetPropertyGrid()
|
||
|
|
{
|
||
|
|
if ( !m_pState )
|
||
|
|
return NULL;
|
||
|
|
return m_pState->GetGrid();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Cannot be GetGrid() due to ambiguity issues.
|
||
|
|
const wxPropertyGrid* GetPropertyGrid() const
|
||
|
|
{
|
||
|
|
if ( !m_pState )
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
return m_pState->GetGrid();
|
||
|
|
}
|
||
|
|
|
||
|
|
friend class wxPropertyGrid;
|
||
|
|
friend class wxPropertyGridManager;
|
||
|
|
};
|
||
|
|
|
||
|
|
#endif // wxUSE_PROPGRID
|
||
|
|
|
||
|
|
#endif // __WX_PROPGRID_PROPGRIDIFACE_H__
|