// Author: Jaakko Salli
// Modified by:
// Created: 2008-08-31
-// RCS-ID: $Id:
+// RCS-ID: $Id$
// Copyright: (c) Jaakko Salli
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PROPGRID_PROPGRIDDEFS_H_
#define _WX_PROPGRID_PROPGRIDDEFS_H_
+#if wxUSE_PROPGRID
+
#include "wx/dynarray.h"
+#include "wx/vector.h"
#include "wx/hashmap.h"
#include "wx/variant.h"
#include "wx/longlong.h"
// comment to use bitmap buttons
#define wxPG_ICON_WIDTH 9
// 1 if wxRendererNative should be employed
- #define wxPG_USE_RENDERER_NATIVE 0
+ #define wxPG_USE_RENDERER_NATIVE 1
// 1 to use double-buffer that guarantees flicker-free painting
#define wxPG_DOUBLE_BUFFER 1
#define wxPG_XBEFOREWIDGET 1
// x position adjustment for wxTextCtrl (and like)
- #define wxPG_TEXTCTRLXADJUST 3
+ #define wxPG_TEXTCTRLXADJUST 0
// comment to use bitmap buttons
#define wxPG_ICON_WIDTH 11
// (for tree buttons)
//#undef wxPG_ICON_WIDTH
+#if WXWIN_COMPATIBILITY_2_6 || WXWIN_COMPATIBILITY_2_8
+ #define wxPG_COMPATIBILITY_1_4 1
+#else
+ #define wxPG_COMPATIBILITY_1_4 0
+#endif
+
// Need to force disable tooltips?
#if !wxUSE_TOOLTIPS
#undef wxPG_SUPPORT_TOOLTIPS
// -----------------------------------------------------------------------
-// wxPG_CHECK_FOO_DBG - debug check with message that does not
-// interrupt program flow.
-#define wxPG_CHECK_RET_DBG(A,B) \
- if ( !(A) ) { wxLogWarning(B); return; }
-#define wxPG_CHECK_MSG_DBG(A,B,C) \
- if ( !(A) ) { wxLogWarning(C); return B; }
-
-
class wxPGEditor;
class wxPGProperty;
class wxPropertyCategory;
class wxPropertyGridEvent;
class wxPropertyGridManager;
class wxPGOwnerDrawnComboBox;
-class wxPGCustomComboControl;
class wxPGEditorDialogAdapter;
-struct wxPGValidationInfo;
+class wxPGValidationInfo;
// -----------------------------------------------------------------------
#define wxPG_DEFAULT_IMAGE_SIZE wxSize(-1, -1)
+/** This callback function is used for sorting properties.
+
+ Call wxPropertyGrid::SetSortFunction() to set it.
+
+ Sort function should return a value greater than 0 if position of p1 is
+ after p2. So, for instance, when comparing property names, you can use
+ following implementation:
+
+ @code
+ int MyPropertySortFunction(wxPropertyGrid* propGrid,
+ wxPGProperty* p1,
+ wxPGProperty* p2)
+ {
+ return p1->GetBaseName().compare( p2->GetBaseName() );
+ }
+ @endcode
+*/
+typedef int (*wxPGSortCallback)(wxPropertyGrid* propGrid,
+ wxPGProperty* p1,
+ wxPGProperty* p2);
+
+
+
typedef wxString wxPGCachedString;
/** @}
wxPGHashMapS2P,
class WXDLLIMPEXP_PROPGRID);
-
+WX_DECLARE_STRING_HASH_MAP_WITH_DECL(wxString,
+ wxPGHashMapS2S,
+ class WXDLLIMPEXP_PROPGRID);
+
WX_DECLARE_VOIDPTR_HASH_MAP_WITH_DECL(void*,
wxPGHashMapP2P,
class WXDLLIMPEXP_PROPGRID);
wxPG_RECURSE_STARTS = 0x00000080,
/** Force value change. */
-wxPG_FORCE = 0x00000100
+wxPG_FORCE = 0x00000100,
+
+/** Only sort categories and their immediate children.
+ Sorting done by wxPG_AUTO_SORT option uses this.
+*/
+wxPG_SORT_TOP_LEVEL_ONLY = 0x00000200
};
// Means property for which final string value is for can not really be
// edited.
- wxPG_UNEDITABLE_COMPOSITE_FRAGMENT = 0x00000020
+ wxPG_UNEDITABLE_COMPOSITE_FRAGMENT = 0x00000020,
+
+ // ValueToString() called from GetValueAsString()
+ // (guarantees that input wxVariant value is current own value)
+ wxPG_VALUE_IS_CURRENT = 0x00000040,
+
+ // Value is being set programmatically (ie. not by user)
+ wxPG_PROGRAMMATIC_VALUE = 0x00000080
};
// -----------------------------------------------------------------------
#ifndef SWIG
-// Editor accessor.
+// Editor accessor (for backwards compatiblity use only).
#define wxPG_EDITOR(T) wxPGEditor_##T
// Declare editor class, with optional part.
#ifndef SWIG
-/** @class wxPGVariantData
- @ingroup classes
- wxVariantData with additional functionality.
-
- It is usually enough to use supplied to macros to automatically generate
- variant data class. Like so:
-
- @code
-
- // In header
- WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataMyClass, // Name of the class
- MyClass, // Name of the data type
- wxEMPTY_PARAMETER_VALUE) // Declaration
-
- // In source
- WX_PG_IMPLEMENT_VARIANT_DATA(wxPGVariantDataMyClass, MyClass)
-
- @endcode
-
- If your class is derived from wxObject, it is recommended that you use
- wxObject-versions of the macros (WX_PG_DECLARE_WXOBJECT_VARIANT_DATA and
- WX_PG_IMPLEMENT_WXOBJECT_VARIANT_DATA).
-
-*/
-class WXDLLIMPEXP_PROPGRID wxPGVariantData : public wxVariantData
-{
-public:
- virtual void* GetValuePtr() = 0;
- virtual wxVariant GetDefaultValue() const = 0;
-protected:
-};
-
-
-//
-// With wxWidgets 2.9 and later we demand native C++ RTTI support
-#ifdef wxNO_RTTI
- #error "You need to enable compiler RTTI support for wxPropertyGrid"
-#endif
-#define WX_PG_DECLARE_DYNAMIC_CLASS_VARIANTDATA(A)
-#define WX_PG_IMPLEMENT_DYNAMIC_CLASS_VARIANTDATA(A, B)
-typedef const std::type_info* wxPGVariantDataClassInfo;
-#define wxPGVariantDataGetClassInfo(A) (&typeid(*A))
-#define wxPG_VARIANT_EQ(A, B) \
- ( ((A).GetData() && \
- (B).GetData() && typeid(*(A).GetData()) == typeid(*(B).GetData()) && \
- (A == B)) || !((A).GetData() && (B).GetData()) )
-
-#ifndef wxDynamicCastVariantData
- #define wxDynamicCastVariantData wxDynamicCast
-#endif
-
-
-inline void wxPGDoesNothing() {}
-
-
-#define _WX_PG_IMPLEMENT_VARIANT_DATA_CLASS(CLASSNAME, \
- DATATYPE, \
- AS_ARG, \
- AS_ARG_CONST, \
- CTOR_CODE, \
- DEFAULT_VALUE, \
- SET_CODE) \
- WX_PG_DECLARE_DYNAMIC_CLASS_VARIANTDATA(CLASSNAME) \
-protected: \
- DATATYPE m_value; \
-public: \
- CLASSNAME() { CTOR_CODE; } \
- CLASSNAME(AS_ARG_CONST value) { CTOR_CODE; SET_CODE; m_value = value; } \
- DATATYPE GetValue() const { return m_value; } \
- AS_ARG_CONST GetValueRef() const { return m_value; } \
- AS_ARG GetValueRef() { return m_value; } \
- void SetValue(AS_ARG_CONST value) { SET_CODE; m_value = value; } \
- virtual bool Eq(wxVariantData&) const { return false; } \
- virtual wxString GetType() const { return wxS(#DATATYPE); } \
- virtual wxVariantData* Clone() { return new CLASSNAME; } \
- virtual bool Read(wxString &) { return false; } \
- virtual bool Write(wxString &) const { return true; } \
- virtual wxVariant GetDefaultValue() const { return DEFAULT_VALUE; }
-
//
// Macro WXVARIANT allows creation of wxVariant from any type supported by
// wxWidgets internally, and of all types created using
// WX_PG_DECLARE_VARIANT_DATA.
template<class T>
-wxVariant WXVARIANT( const T& value )
+wxVariant WXVARIANT( const T& WXUNUSED(value) )
{
- return wxVariant((void*)&value);
+ wxFAIL_MSG("Code should always call specializations of this template");
+ return wxVariant();
}
template<> inline wxVariant WXVARIANT( const int& value )
{ return wxVariant(value); }
#endif
-#define _WX_PG_VARIANT_DATA_CLASSINFO_CONTAINER_DECL(CLASSNAME) \
- extern int CLASSNAME##_d_;
-#define _WX_PG_VARIANT_DATA_CLASSINFO_CONTAINER(CLASSNAME) \
- int CLASSNAME##_d_;
-
-#define _WX_PG_IMPLEMENT_VARIANT_DATA(CLASSNAME, \
- DATATYPE, \
- AS_ARG, \
- AS_CONST_ARG, \
- NULLVAL, \
- BASECLASS) \
-_WX_PG_VARIANT_DATA_CLASSINFO_CONTAINER(CLASSNAME) \
-WX_PG_IMPLEMENT_DYNAMIC_CLASS_VARIANTDATA(CLASSNAME, BASECLASS) \
-AS_ARG operator <<( AS_ARG value, const wxVariant &variant ) \
+
+//
+// These are modified versions of DECLARE/WX_PG_IMPLEMENT_VARIANT_DATA
+// macros found in variant.h. Difference are as follows:
+// * These support non-wxObject data
+// * These implement classname##RefFromVariant function which returns
+// reference to data within.
+// * const char* classname##_VariantType which equals classname.
+// * WXVARIANT
+//
+#define WX_PG_DECLARE_VARIANT_DATA(classname) \
+ WX_PG_DECLARE_VARIANT_DATA_EXPORTED(classname, wxEMPTY_PARAMETER_VALUE)
+
+#define WX_PG_DECLARE_VARIANT_DATA_EXPORTED(classname,expdecl) \
+expdecl classname& operator << ( classname &object, const wxVariant &variant ); \
+expdecl wxVariant& operator << ( wxVariant &variant, const classname &object ); \
+expdecl const classname& classname##RefFromVariant( const wxVariant& variant ); \
+expdecl classname& classname##RefFromVariant( wxVariant& variant ); \
+template<> inline wxVariant WXVARIANT( const classname& value ) \
{ \
- CLASSNAME *data = wxDynamicCastVariantData( variant.GetData(), CLASSNAME ); \
- wxASSERT( data ); \
- value = data->GetValue(); \
- return value; \
+ wxVariant variant; \
+ variant << value; \
+ return variant; \
} \
-wxVariant& operator <<( wxVariant &variant, AS_CONST_ARG value ) \
+extern expdecl const char* classname##_VariantType;
+
+
+#define WX_PG_IMPLEMENT_VARIANT_DATA(classname) \
+ WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED(classname, wxEMPTY_PARAMETER_VALUE)
+
+// Add getter (ie. classname << variant) separately to allow
+// custom implementations.
+#define WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED_NO_EQ_NO_GETTER(classname,expdecl) \
+const char* classname##_VariantType = #classname; \
+class classname##VariantData: public wxVariantData \
{ \
- CLASSNAME *data = new CLASSNAME( value ); \
- variant.SetData( data ); \
- return variant; \
+public:\
+ classname##VariantData() {} \
+ classname##VariantData( const classname &value ) { m_value = value; } \
+\
+ classname &GetValue() { return m_value; } \
+\
+ const classname &GetValue() const { return m_value; } \
+\
+ virtual bool Eq(wxVariantData& data) const; \
+\
+ virtual wxString GetType() const; \
+\
+ virtual wxVariantData* Clone() const { return new classname##VariantData(m_value); } \
+\
+protected:\
+ classname m_value; \
+};\
+\
+wxString classname##VariantData::GetType() const\
+{\
+ return wxS(#classname);\
+}\
+\
+expdecl wxVariant& operator << ( wxVariant &variant, const classname &value )\
+{\
+ classname##VariantData *data = new classname##VariantData( value );\
+ variant.SetData( data );\
+ return variant;\
} \
-AS_ARG DATATYPE##FromVariant( const wxVariant& v ) \
+expdecl classname& classname##RefFromVariant( wxVariant& variant ) \
{ \
- CLASSNAME *data = wxDynamicCastVariantData( v.GetData(), CLASSNAME ); \
- if ( !data ) \
- return NULLVAL; \
- return data->GetValueRef(); \
+ wxASSERT( variant.GetType() == #classname );\
+ classname##VariantData *data = (classname##VariantData*) variant.GetData();\
+ return data->GetValue();\
} \
-wxVariant DATATYPE##ToVariant( AS_CONST_ARG value ) \
+expdecl const classname& classname##RefFromVariant( const wxVariant& variant ) \
{ \
- wxVariant variant( new CLASSNAME( value ) ); \
- return variant; \
+ wxASSERT( variant.GetType() == #classname );\
+ classname##VariantData *data = (classname##VariantData*) variant.GetData();\
+ return data->GetValue();\
+}
+
+#define WX_PG_IMPLEMENT_VARIANT_DATA_GETTER(classname, expdecl) \
+expdecl classname& operator << ( classname &value, const wxVariant &variant )\
+{\
+ wxASSERT( variant.GetType() == #classname );\
+ \
+ classname##VariantData *data = (classname##VariantData*) variant.GetData();\
+ value = data->GetValue();\
+ return value;\
+}
+
+#define WX_PG_IMPLEMENT_VARIANT_DATA_EQ(classname, expdecl) \
+bool classname##VariantData::Eq(wxVariantData& data) const \
+{\
+ wxASSERT( GetType() == data.GetType() );\
+\
+ classname##VariantData & otherData = (classname##VariantData &) data;\
+\
+ return otherData.m_value == m_value;\
+}
+
+// implements a wxVariantData-derived class using for the Eq() method the
+// operator== which must have been provided by "classname"
+#define WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED(classname,expdecl) \
+WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED_NO_EQ_NO_GETTER(classname,wxEMPTY_PARAMETER_VALUE expdecl) \
+WX_PG_IMPLEMENT_VARIANT_DATA_GETTER(classname,wxEMPTY_PARAMETER_VALUE expdecl) \
+WX_PG_IMPLEMENT_VARIANT_DATA_EQ(classname,wxEMPTY_PARAMETER_VALUE expdecl)
+
+#define WX_PG_IMPLEMENT_VARIANT_DATA(classname) \
+WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED(classname, wxEMPTY_PARAMETER_VALUE)
+
+// with Eq() implementation that always returns false
+#define WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED_DUMMY_EQ(classname,expdecl) \
+WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED_NO_EQ_NO_GETTER(classname,wxEMPTY_PARAMETER_VALUE expdecl) \
+WX_PG_IMPLEMENT_VARIANT_DATA_GETTER(classname,wxEMPTY_PARAMETER_VALUE expdecl) \
+\
+bool classname##VariantData::Eq(wxVariantData& WXUNUSED(data)) const \
+{\
+ return false; \
+}
+
+#define WX_PG_IMPLEMENT_VARIANT_DATA_DUMMY_EQ(classname) \
+WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED_DUMMY_EQ(classname, wxEMPTY_PARAMETER_VALUE)
+
+WX_PG_DECLARE_VARIANT_DATA_EXPORTED(wxPoint, WXDLLIMPEXP_PROPGRID)
+WX_PG_DECLARE_VARIANT_DATA_EXPORTED(wxSize, WXDLLIMPEXP_PROPGRID)
+WX_PG_DECLARE_VARIANT_DATA_EXPORTED(wxArrayInt, WXDLLIMPEXP_PROPGRID)
+WX_PG_DECLARE_VARIANT_DATA_EXPORTED(wxLongLong, WXDLLIMPEXP_PROPGRID)
+WX_PG_DECLARE_VARIANT_DATA_EXPORTED(wxULongLong, WXDLLIMPEXP_PROPGRID)
+DECLARE_VARIANT_OBJECT_EXPORTED(wxFont, WXDLLIMPEXP_PROPGRID)
+template<> inline wxVariant WXVARIANT( const wxFont& value )
+{
+ wxVariant variant;
+ variant << value;
+ return variant;
}
-#define WX_PG_IMPLEMENT_VARIANT_DATA(CLASSNAME, DATATYPE) \
-class CLASSNAME : public wxPGVariantData \
-{ \
-_WX_PG_IMPLEMENT_VARIANT_DATA_CLASS(CLASSNAME, DATATYPE, DATATYPE&, \
- const DATATYPE&, wxPGDoesNothing(), \
- wxVariant(new CLASSNAME(DATATYPE())), \
- wxPGDoesNothing()) \
-public: \
- virtual void* GetValuePtr() { return (void*)&m_value; } \
-}; \
-_WX_PG_IMPLEMENT_VARIANT_DATA(CLASSNAME, \
- DATATYPE, \
- DATATYPE&, \
- const DATATYPE&, \
- (DATATYPE&)*((DATATYPE*)NULL), \
- wxPGVariantData)
-
-#define WX_PG_IMPLEMENT_WXOBJECT_VARIANT_DATA(CLASSNAME, DATATYPE) \
-class CLASSNAME : public wxPGVariantData \
-{ \
-_WX_PG_IMPLEMENT_VARIANT_DATA_CLASS(CLASSNAME, DATATYPE, DATATYPE&, \
- const DATATYPE&, wxPGDoesNothing(), \
- wxVariant(new CLASSNAME(DATATYPE())), \
- wxPGDoesNothing()) \
-public: \
- virtual void* GetValuePtr() { return (void*)&m_value; } \
- virtual wxClassInfo* GetValueClassInfo() \
- { return m_value.GetClassInfo(); } \
-}; \
-_WX_PG_IMPLEMENT_VARIANT_DATA(CLASSNAME, DATATYPE, DATATYPE&, \
- const DATATYPE&, \
- (DATATYPE&)*((DATATYPE*)NULL), \
- wxPGVariantData)
-
-
-#define WX_PG_DECLARE_VARIANT_DATA(CLASSNAME, DATATYPE, DECL) \
-DECL DATATYPE& operator <<( DATATYPE& value, const wxVariant &variant ); \
-DECL wxVariant& operator <<( wxVariant &variant, const DATATYPE& value ); \
-DECL DATATYPE& DATATYPE##FromVariant( const wxVariant& variant ); \
-DECL wxVariant DATATYPE##ToVariant( const DATATYPE& value ); \
-template<> inline wxVariant WXVARIANT( const DATATYPE& value ) \
- { return DATATYPE##ToVariant(value); } \
-DECL _WX_PG_VARIANT_DATA_CLASSINFO_CONTAINER_DECL(CLASSNAME);
-
-#define WX_PG_DECLARE_WXOBJECT_VARIANT_DATA WX_PG_DECLARE_VARIANT_DATA
-
-#define WX_PG_DECLARE_PTR_VARIANT_DATA(CLASSNAME, DATATYPE, DECL) \
-DECL DATATYPE* operator <<( DATATYPE* value, const wxVariant &variant ); \
-DECL wxVariant& operator <<( wxVariant &variant, DATATYPE* value ); \
-DECL DATATYPE* DATATYPE##FromVariant( const wxVariant& variant ); \
-DECL wxVariant DATATYPE##ToVariant( DATATYPE* value ); \
-DECL _WX_PG_VARIANT_DATA_CLASSINFO_CONTAINER_DECL(CLASSNAME);
-
-
-#define WX_PG_IMPLEMENT_PTR_VARIANT_DATA(CLASSNAME, DATATYPE, DEFAULT) \
-class CLASSNAME : public wxPGVariantData \
-{ \
-_WX_PG_IMPLEMENT_VARIANT_DATA_CLASS(CLASSNAME, DATATYPE*, DATATYPE*, \
- DATATYPE*, m_value = NULL, \
- DEFAULT, \
- if (m_value) Py_DECREF(m_value); \
- if (!value) value = Py_None; \
- Py_INCREF(value) ) \
- ~CLASSNAME() { if (m_value) Py_DECREF(m_value); } \
-public: \
- virtual void* GetValuePtr() { return (void*)m_value; } \
-}; \
-_WX_PG_IMPLEMENT_VARIANT_DATA(CLASSNAME, DATATYPE, DATATYPE*, DATATYPE*, \
- NULL, wxPGVariantData)
-
-
-WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataPoint, wxPoint, WXDLLIMPEXP_PROPGRID)
-WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataSize, wxSize, WXDLLIMPEXP_PROPGRID)
-WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataArrayInt,
- wxArrayInt, WXDLLIMPEXP_PROPGRID)
-WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataLongLong,
- wxLongLong, WXDLLIMPEXP_PROPGRID)
-WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataULongLong,
- wxULongLong, WXDLLIMPEXP_PROPGRID)
-
-WX_PG_DECLARE_WXOBJECT_VARIANT_DATA(wxPGVariantDataFont,
- wxFont, WXDLLIMPEXP_PROPGRID)
template<> inline wxVariant WXVARIANT( const wxColour& value )
{
wxVariant variant;
return variant;
}
-#define WX_PG_VARIANT_GETVALUEREF(P, T) \
- (*((T*)((wxPGVariantData*)(P.GetData()))->GetValuePtr()))
+#if wxUSE_LONGLONG_NATIVE
+
+template<> inline wxVariant WXVARIANT( const wxLongLong_t& value )
+{
+ wxVariant variant;
+ variant << wxLongLong(value);
+ return variant;
+}
+
+template<> inline wxVariant WXVARIANT( const wxULongLong_t& value )
+{
+ wxVariant variant;
+ variant << wxULongLong(value);
+ return variant;
+}
+
+WXDLLIMPEXP_PROPGRID wxLongLong_t& operator << ( wxLongLong_t &value, const wxVariant &variant );
+WXDLLIMPEXP_PROPGRID wxULongLong_t& operator << ( wxULongLong_t &value, const wxVariant &variant );
+
+#endif // wxUSE_LONGLONG_NATIVE
+
+// Define constants for common wxVariant type strings
+
+#define wxPG_VARIANT_TYPE_STRING wxPGGlobalVars->m_strstring
+#define wxPG_VARIANT_TYPE_LONG wxPGGlobalVars->m_strlong
+#define wxPG_VARIANT_TYPE_BOOL wxPGGlobalVars->m_strbool
+#define wxPG_VARIANT_TYPE_LIST wxPGGlobalVars->m_strlist
+#define wxPG_VARIANT_TYPE_DOUBLE wxS("double")
+#define wxPG_VARIANT_TYPE_ARRSTRING wxS("arrstring")
+#define wxPG_VARIANT_TYPE_DATETIME wxS("datetime")
// Safely converts a wxVariant to (long) int. Supports converting from string
// and boolean as well.
#ifndef SWIG
-WXDLLIMPEXP_PROPGRID
-wxObject*
-wxPG_VariantToWxObject( const wxVariant& variant, wxClassInfo* classInfo );
-
-//
-// Redefine wxGetVariantCast to also take propertygrid variantdata
-// classes into account.
-//
-#undef wxGetVariantCast
-#define wxGetVariantCast(var,classname) \
- (classname*)wxPG_VariantToWxObject(var,&classname::ms_classInfo)
-
-// TODO: After a while, remove this.
-#define WX_PG_VARIANT_TO_WXOBJECT(VARIANT,CLASSNAME) \
- (CLASSNAME*)wxPG_VariantToWxObject(VARIANT,&CLASSNAME::ms_classInfo)
-
-#endif // !SWIG
-
-// -----------------------------------------------------------------------
-
-#ifndef SWIG
-
//
// Tokenizer macros.
// NOTE: I have made two versions - worse ones (performance and consistency
// -----------------------------------------------------------------------
+#endif // wxUSE_PROPGRID
+
#endif // _WX_PROPGRID_PROPGRIDDEFS_H_
projects / wxWidgets.git / blobdiff