propgrid.h

Go to the documentation of this file.

// Name:        propgrid.h
// Purpose:     wxPropertyGrid
// Author:      Jaakko Salli
// Modified by:
// Created:     Sep-25-2004
// RCS-ID:      $Id:
// Copyright:   (c) Jaakko Salli
// Licence:     wxWindows license

#ifndef __WX_PROPGRID_PROPGRID_H__
#define __WX_PROPGRID_PROPGRID_H__

#include <wx/dynarray.h>
#include <wx/hashmap.h>
#include <wx/variant.h>
#include <wx/longlong.h>
#include <wx/dcclient.h>
#include <wx/scrolwin.h>
#include <wx/tooltip.h>
#include <wx/datetime.h>

// NB: Do *NOT * remove this.
#if defined(SWIG) || defined(SWIG_TYPE_TABLE)
    #if !defined(__WXPYTHON__) && !defined(__NOTWXPYTHON__)
        #define __WXPYTHON__
    #endif
#endif

//
// In case DOXYGEN was not specified (should be, but just in case)
#if !defined(DOXYGEN) && !defined(_WX_WINDOW_H_BASE_) && !defined(SWIG)
    #define DOXYGEN
#endif

#if defined(SWIG) || defined(DOXYGEN)
    #define wxDEPRECATED(A) A
#endif


// Doxygen special includes
#ifdef DOXYGEN
    #include "pg_dox_mainpage.h"
    #include "propdev.h"
#endif


//
// Need to define some things for DOXYGEN
#ifdef DOXYGEN
    #define wxUSE_VALIDATORS        1
    #define wxUSE_DATETIME          1
    #define wxUSE_TOOLTIPS          1
    #define wxUSE_SPINBTN           1
    #define wxUSE_DATEPICKCTRL      1
    #define wxPG_COMPATIBILITY_1_2_0    1
#endif


//
// Check that some wxUSE_FOOs exist
// (we don't care if they are 1 or 0, just that they exist)
#ifndef wxUSE_VALIDATORS
    #error "wxUSE_VALIDATORS not defined"
#endif

#ifndef wxUSE_DATETIME
    #error "wxUSE_DATETIME not defined"
#endif

#ifndef wxUSE_DATEPICKCTRL
    #error "wxUSE_DATEPICKCTRL not defined"
#endif


#if defined(__WXPYTHON__)
    #include <Python.h>
#endif

// Defines for component version.
// The following symbols should be updated for each new component release
// since some kind of tests, like those of AM_WXCODE_CHECKFOR_COMPONENT_VERSION()
// for "configure" scripts under unix, use them.
#define wxPROPGRID_MAJOR          1
#define wxPROPGRID_MINOR          4
#define wxPROPGRID_RELEASE        7

// For non-Unix systems (i.e. when building without a configure script),
// users of this component can use the following macro to check if the
// current version is at least major.minor.release
#define wxCHECK_PROPGRID_VERSION(major,minor,release) \
    (wxPROPGRID_MAJOR > (major) || \
    (wxPROPGRID_MAJOR == (major) && wxPROPGRID_MINOR > (minor)) || \
    (wxPROPGRID_MAJOR == (major) && wxPROPGRID_MINOR == (minor) && wxPROPGRID_RELEASE >= (release)))


// -----------------------------------------------------------------------


//
// Here are some platform dependent defines
// NOTE: More in propertygrid.cpp
//

#ifndef SWIG

#if defined(__WXMSW__)
    // tested

    #define wxPG_XBEFORETEXT            4 // space between vertical line and value text
    #define wxPG_XBEFOREWIDGET          1 // space between vertical line and value editor control

    #define wxPG_TEXTCTRLXADJUST        3 // x position adjustment for wxTextCtrl (and like)

    #define wxPG_ICON_WIDTH             9 // comment to use bitmap buttons
    #define wxPG_USE_RENDERER_NATIVE    0 // 1 if wxRendererNative should be employed

    #define wxPG_DOUBLE_BUFFER          1 // 1 to use double-buffer that guarantees flicker-free painting

    #define wxPG_SUPPORT_TOOLTIPS       1  // Enable tooltips

#elif defined(__WXGTK__)
    // tested

    #define wxPG_XBEFORETEXT            5 // space between vertical line and value text
    #define wxPG_XBEFOREWIDGET          1 // space between vertical line and value editor control

    #define wxPG_TEXTCTRLXADJUST        3 // x position adjustment for wxTextCtrl (and like)

    #define wxPG_ICON_WIDTH             9 // comment to use bitmap buttons
    #define wxPG_USE_RENDERER_NATIVE    0 // 1 if wxRendererNative should be employed

    #define wxPG_DOUBLE_BUFFER          1 // 1 to use double-buffer that guarantees flicker-free painting

    #define wxPG_SUPPORT_TOOLTIPS       1  // Enable tooltips

#elif defined(__WXMAC__)
    // *not* tested

    #define wxPG_XBEFORETEXT            4 // space between vertical line and value text
    #define wxPG_XBEFOREWIDGET          1 // space between vertical line and value editor widget

    #define wxPG_TEXTCTRLXADJUST        3 // x position adjustment for wxTextCtrl (and like)

    #define wxPG_ICON_WIDTH             11  // comment to use bitmap buttons
    #define wxPG_USE_RENDERER_NATIVE    1 // 1 if wxRendererNative should be employed

    #define wxPG_DOUBLE_BUFFER          0 // 1 to use double-buffer that guarantees flicker-free painting

    #define wxPG_SUPPORT_TOOLTIPS       1  // Enable tooltips

#else
    // defaults
    // tested on: none.

    #define wxPG_XBEFORETEXT            5 // space between vertical line and value text
    #define wxPG_XBEFOREWIDGET          1 // space between vertical line and value editor widget

    #define wxPG_TEXTCTRLXADJUST        3 // x position adjustment for wxTextCtrl (and like)

    #define wxPG_ICON_WIDTH             9 // comment to use bitmap buttons
    #define wxPG_USE_RENDERER_NATIVE    0 // 1 if wxRendererNative should be employed

    #define wxPG_DOUBLE_BUFFER          0 // 1 to use double-buffer that guarantees flicker-free painting

    #define wxPG_SUPPORT_TOOLTIPS       0  // Enable tooltips

#endif // #if defined(__WXMSW__)


#define wxPG_CONTROL_MARGIN             0 // space between splitter and control

#define wxCC_CUSTOM_IMAGE_MARGIN1            4  // before image
#define wxCC_CUSTOM_IMAGE_MARGIN2            5  // after image

// Use this macro to generate standard custom image height from
#define wxPG_STD_CUST_IMAGE_HEIGHT(LINEHEIGHT)  (LINEHEIGHT-3)


#if defined(__WXWINCE__)
    #define wxPG_SMALL_SCREEN       1
    #undef wxPG_DOUBLE_BUFFER
    #define wxPG_DOUBLE_BUFFER      0
#else
    #define wxPG_SMALL_SCREEN       0
#endif

#endif // #ifndef SWIG

// Undefine wxPG_ICON_WIDTH to use supplied xpm bitmaps instead
// (for tree buttons)
//#undef wxPG_ICON_WIDTH

// Need to force disable tooltips?
#if !wxUSE_TOOLTIPS
    #undef wxPG_SUPPORT_TOOLTIPS
    #define wxPG_SUPPORT_TOOLTIPS       0
#endif

// Set 1 to include advanced properties (wxFontProperty, wxColourProperty, etc.)
#ifndef wxPG_INCLUDE_ADVPROPS
    #define wxPG_INCLUDE_ADVPROPS           1
#endif

// Set 1 include wxPropertyGridManager
#ifndef wxPG_INCLUDE_MANAGER
    #define wxPG_INCLUDE_MANAGER            1
#endif

// Set 1 to include checkbox editor class
#define wxPG_INCLUDE_CHECKBOX           1

// Set to 1 to use native STL constructs as much as possible
#ifndef wxPG_USE_STL
    #define wxPG_USE_STL    wxUSE_STL
#endif

#ifndef wxPG_USING_WXOWNERDRAWNCOMBOBOX
    #if wxCHECK_VERSION(2,8,0)
        #define wxPG_USING_WXOWNERDRAWNCOMBOBOX 1
    #else
        #define wxPG_USING_WXOWNERDRAWNCOMBOBOX 0
    #endif
#endif

#if wxPG_USING_WXOWNERDRAWNCOMBOBOX
    #define wxPGOwnerDrawnComboBox          wxOwnerDrawnComboBox
    #define wxPGCC_DCLICK_CYCLES            wxCC_SPECIAL_DCLICK
    #define wxPGCC_PAINTING_CONTROL         wxODCB_PAINTING_CONTROL
    #define wxPGCC_PAINTING_SELECTED        wxODCB_PAINTING_SELECTED
    #define wxPGCC_PROCESS_ENTER            wxTE_PROCESS_ENTER
    #define wxPGCC_ALT_KEYS                 0
#endif

// wxRect: Inside(<=2.7.0) or Contains(>2.7.0)?
#if !wxCHECK_VERSION(2,7,1)
    #define wxPGRectContains    Inside
#else
    #define wxPGRectContains    Contains
#endif

#if wxCHECK_VERSION(2,7,0)
    #define wxPGIndex           unsigned int
#else
    #define wxPGIndex           int
#endif

#ifdef __WXMSW__
  #if wxCHECK_VERSION(2,9,0)
    #define wxPG_GetHDCOf(DC) ((HDC)((const wxMSWDCImpl *)DC.GetImpl())->GetHDC())
  #else
    #define wxPG_GetHDCOf(DC) ((HDC)DC.GetHDC())
  #endif
#endif

// Define wxBORDER_THEME if it is missing
#if !wxCHECK_VERSION(2,8,0)
  #ifndef wxBORDER_THEME
    #define wxBORDER_THEME  wxSIMPLE_BORDER
  #endif
#endif

// -----------------------------------------------------------------------

#ifndef wxPG_COMPATIBILITY_1_2_0
    #define wxPG_COMPATIBILITY_1_2_0    1
#endif


#if wxPG_COMPATIBILITY_1_2_0

    // Legacy wxPropertyGrid version macro
    #define wxPG_VERSION            ((wxPROPGRID_MAJOR*1000)+(wxPROPGRID_MINOR*100)+(wxPROPGRID_RELEASE*10))

#endif


#ifdef wxPG_COMPATIBILITY_1_0_0

    #define wxRECURSE               wxPG_RECURSE
    #define wxKEEP_STRUCTURE        wxPG_KEEP_STRUCTURE
    #define wxPGConstants           wxPGChoices
    #define wxPG_EX_CLASSIC_SPACING 0

    #define wxPGCtrlClass           wxWindow
    #define wxCCustomTextCtrl       wxTextCtrl
    #define wxCCustomComboBox       wxPGOwnerDrawnComboBox
    #define wxCCustomButton         wxButton

#endif // #ifdef wxPG_COMPATIBILITY_1_0_0

#ifdef __WXPYTHON__
    #define wxPG_VALUETYPE_IS_STRING    0  // 1
#else
    #define wxPG_VALUETYPE_IS_STRING    0
#endif

#ifndef SWIG
    #if !wxCHECK_VERSION(2,9,0)
        #if !defined(wxUniChar)
            #define wxUniChar   wxChar
        #endif
        //#define wxPGGetIterChar(str, i)  str[i]
        #define wxPGGetIterChar(str, i)  *i
    #else
        #define wxPGGetIterChar(str, i)  *i
    #endif
#endif

#if wxPG_COMPATIBILITY_1_2_0
    #define wxPGRegisterPropertyClass(A)
#endif

// -----------------------------------------------------------------------

//
// wxPython special considerations
//
// TODO: Using const yields some ugly function
//   names, so might as well make those GetPropertyValueAsXXX non-static
//   for regular C++ build as well.s
//

#ifndef __WXPYTHON__

// Some Strings are returned as const wxChar* in C++, and as wxString in wxPython
// (using just wxString for everything would've been better, but the current scheme
// is necessary for better backwards compatibility).
#define wxPG_CONST_WXCHAR_PTR       const wxChar*
#define wxPG_CONST_WXCHAR_DEFVAL    ((const wxChar*)NULL)
#define wxPG_TO_WXCHAR_PTR(A)       A

// In C++ we can stick with overloaded methods
#define SetPropertyValueLong        SetPropertyValue
#define SetPropertyValueDouble      SetPropertyValue
#define SetPropertyValueBool        SetPropertyValue
#define SetPropertyValueString      SetPropertyValue
#define SetPropertyValueWxObjectPtr SetPropertyValue
#define SetPropertyValuePoint       SetPropertyValue
#define SetPropertyValueSize        SetPropertyValue
#define SetPropertyValueArrint2     SetPropertyValue
#define SetPropertyValueArrstr2     SetPropertyValue
#define SetPropertyValueDatetime    SetPropertyValue
#define SetPropertyValueLongLong    SetPropertyValue
#define SetPropertyValueULongLong   SetPropertyValue

#define WX_PG_NOT_PURE_IN_WXPYTHON  =0

#else

// Some Strings are returned as const wxChar* in C++, and as wxString in wxPython
// (using just wxString for everything would've been better, but the current scheme
// is necessary for better backwards compatibility).
#define wxPG_CONST_WXCHAR_PTR       wxString
#define wxPG_CONST_WXCHAR_DEFVAL    wxEmptyString
#define wxPG_TO_WXCHAR_PTR(A)       A  //(A.c_str())

// Because SWIG has problems combining overloaded functions and
// Python object-to-wxXXX conversion, we need to use Python proxy
// functions for these value setters.
#define SetPropertyValueArrstr2     _SetPropertyValueArrstr
#define SetPropertyValueArrint2     _SetPropertyValueArrint

//
// wxPGVariantAndBool
//      
// Helper class that wraps wxVariant and bool. Need to use this class
// instead of writeback arguments in some virtual methods of custom
// property classes.
//
// WXDLLIMPEXP_PG
class wxPGVariantAndBool
{
public:

    wxPGVariantAndBool()
    {
        m_valueValid = false;
        m_result = false;
    }

    wxPGVariantAndBool( bool result, const wxVariant& variant )
    {
        m_valueValid = true;
        m_result = result;
        m_value = variant;
    }

    wxPGVariantAndBool( const wxVariant& variant )
    {
        m_valueValid = true;
        m_result = true;
        m_value = variant;
    }

    wxPGVariantAndBool( bool result )
    {
        Init(result);
    }

    ~wxPGVariantAndBool() { }

    void Init( bool result = false )
    {
        m_valueValid = false;
        m_result = result;
    }

    const wxVariant& GetValue() const
    {
        wxASSERT(m_valueValid);
        return m_value;
    }

public:
    wxVariant m_value;
    bool      m_valueValid;
    bool      m_result;
};

#define WX_PG_NOT_PURE_IN_WXPYTHON

#endif


#define wxPG_NO_DECL

#ifndef wxEMPTY_PARAMETER_VALUE
    #define wxEMPTY_PARAMETER_VALUE
#endif

// -----------------------------------------------------------------------

#ifdef WXMAKINGLIB_PROPGRID
    #define WXDLLIMPEXP_PG
#elif defined(WXMAKINGDLL_PROPGRID)
    #define WXDLLIMPEXP_PG WXEXPORT
#elif defined(WXUSINGDLL)
    #define WXDLLIMPEXP_PG WXIMPORT
#else // not making nor using DLL
    #define WXDLLIMPEXP_PG wxEMPTY_PARAMETER_VALUE
#endif

// -----------------------------------------------------------------------

#ifndef SWIG
class WXDLLIMPEXP_PG wxPGEditor;
class WXDLLIMPEXP_PG wxPGProperty;
class WXDLLIMPEXP_PG wxPropertyCategory;
class WXDLLIMPEXP_PG wxPGChoices;
class WXDLLIMPEXP_PG wxPropertyGridState;
class WXDLLIMPEXP_PG wxPGCell;
class WXDLLIMPEXP_PG wxPGChoiceEntry;
class WXDLLIMPEXP_PG wxPropertyGridInterface;
class WXDLLIMPEXP_PG wxPropertyGrid;
class WXDLLIMPEXP_PG wxPropertyGridEvent;
class WXDLLIMPEXP_PG wxPropertyGridManager;
class WXDLLIMPEXP_PG wxPGOwnerDrawnComboBox;
class WXDLLIMPEXP_PG wxPGCustomComboControl;
class WXDLLIMPEXP_PG wxPGEditorDialogAdapter;

extern WXDLLIMPEXP_PG const wxChar *wxPropertyGridNameStr;

struct wxPGValidationInfo;

#endif // #ifndef SWIG


#ifdef __WXPYTHON__
    class wxPGPyEditor;
#endif // #ifndef __WXPYTHON__


struct wxPGPaintData
{
    const wxPropertyGrid*   m_parent;

    int                     m_choiceItem;

    int                     m_drawnWidth;

    int                     m_drawnHeight;   
};


#ifndef SWIG

class WXDLLIMPEXP_PG wxPGCellRenderer
{
public:

    wxPGCellRenderer( unsigned int refCount = 1 )
        : m_refCount(refCount) { }
    virtual ~wxPGCellRenderer() { }

    // Render flags
    enum
    {
        Selected        = 0x00010000,
        Control         = 0x00020000
    };

    virtual void Render( wxDC& dc,
                         const wxRect& rect,
                         const wxPropertyGrid* propertyGrid,
                         wxPGProperty* property,
                         int column,
                         int item,
                         int flags ) const = 0;

    virtual wxSize GetImageSize( const wxPGProperty* property,
                                 int column,
                                 int item ) const;

    virtual void DrawCaptionSelectionRect( wxDC& dc, int x, int y, int w, int h ) const;

    void DrawText( wxDC& dc,
                   const wxRect& rect,
                   int imageWidth,
                   const wxString& text ) const;

    void DrawEditorValue( wxDC& dc, const wxRect& rect,
                          int xOffset, const wxString& text,
                          wxPGProperty* property,
                          const wxPGEditor* editor ) const;

    int PreDrawCell( wxDC& dc, const wxRect& rect, const wxPGCell& cell, int flags ) const;

    void IncRef()
    {
        m_refCount++;
    }

    void DecRef() 
    {
        m_refCount--;
        if ( !m_refCount )
            delete this;
    }
protected:

private:
    unsigned int    m_refCount;
};


class WXDLLIMPEXP_PG wxPGCell
{
public:
    wxPGCell();
    wxPGCell( const wxString& text,
              const wxBitmap& bitmap = wxNullBitmap,
              const wxColour& fgCol = wxNullColour,
              const wxColour& bgCol = wxNullColour,
              const wxFont& font = wxNullFont );

    virtual ~wxPGCell() { }

    void SetText( const wxString& text ) { m_text = text; }
    void SetBitmap( const wxBitmap& bitmap ) { m_bitmap = bitmap; }
    void SetFgCol( const wxColour& col ) { m_fgCol = col; }
    void SetBgCol( const wxColour& col ) { m_bgCol = col; }
    void SetFont( const wxFont& font ) { m_font = font; }

    const wxString& GetText() const { return m_text; }
    const wxBitmap& GetBitmap() const { return m_bitmap; }
    const wxColour& GetFgCol() const { return m_fgCol; }
    const wxColour& GetBgCol() const { return m_bgCol; }
    const wxFont& GetFont() const { return m_font; }

protected:
    wxString    m_text;
    wxBitmap    m_bitmap;
    wxColour    m_fgCol;
    wxColour    m_bgCol;
    wxFont      m_font;
};


class WXDLLIMPEXP_PG wxPGDefaultRenderer : public wxPGCellRenderer
{
public:
    virtual void Render( wxDC& dc,
                         const wxRect& rect,
                         const wxPropertyGrid* propertyGrid,
                         wxPGProperty* property,
                         int column,
                         int item,
                         int flags ) const;

    virtual wxSize GetImageSize( const wxPGProperty* property,
                                 int column,
                                 int item ) const;

protected:
};

#endif  // !SWIG

#define wxPG_EMPTY_ARRAYINT     wxArrayInt()
#define wxPG_EMPTY_ARRAYSTRING  wxArrayString()

#if !defined(SWIG)
    #define wxPG_LABEL              (*((wxString*)NULL))  // Used to tell wxPGProperty to use label as name as well.
    #define wxPG_NULL_BITMAP        wxNullBitmap
    #define wxPG_COLOUR_BLACK       (*wxBLACK)
#else
    #define wxPG_LABEL              wxString_wxPG_LABEL
    #define wxPG_NULL_BITMAP        wxBitmap_NULL
    #define wxPG_COLOUR_BLACK       wxColour_BLACK
#endif // #ifndef SWIG


// Used to indicate wxPGChoices::Add etc that the value is actually not given
// by the caller.
#define wxPG_INVALID_VALUE      INT_MAX


#define wxPG_COLOUR(R,G,B) ((wxUint32)(R+(G<<8)+(B<<16)))


#define wxPG_DEFAULT_IMAGE_SIZE             wxSize(-1, -1)


typedef bool (*wxPropertyGridCallback)(wxPropertyGrid* propGrid,
                                       wxPGProperty* property,
                                       wxWindow* ctrl,
                                       int data);

typedef void (*wxPGPaintCallback)(wxPGProperty* property,
                                  wxDC& dc,
                                  const wxRect& rect,
                                  wxPGPaintData& paintdata);

typedef int (*wxPGSortCallback)(wxPropertyGrid* propGrid,
                                wxPGProperty* p1,
                                wxPGProperty* p2);


#define WX_PG_CLASSINFO(NAME) (&NAME::ms_classInfo)


typedef wxString wxPGCachedString;

// -----------------------------------------------------------------------

enum wxPG_WINDOW_STYLES
{

wxPG_AUTO_SORT                      = 0x00000010,

wxPG_HIDE_CATEGORIES                = 0x00000020,

/* This style combines non-categoric mode and automatic sorting.
*/
wxPG_ALPHABETIC_MODE                = (wxPG_HIDE_CATEGORIES|wxPG_AUTO_SORT),

wxPG_BOLD_MODIFIED                  = 0x00000040,

wxPG_SPLITTER_AUTO_CENTER           = 0x00000080,

wxPG_TOOLTIPS                       = 0x00000100,

wxPG_HIDE_MARGIN                    = 0x00000200,

wxPG_STATIC_SPLITTER                = 0x00000400,

wxPG_STATIC_LAYOUT                  = (wxPG_HIDE_MARGIN|wxPG_STATIC_SPLITTER),

wxPG_LIMITED_EDITING                = 0x00000800,

#ifdef DOXYGEN

wxTAB_TRAVERSAL                     = 0x00080000,

#endif

wxPG_TOOLBAR                        = 0x00001000,

wxPG_DESCRIPTION                    = 0x00002000,

wxPG_THEME_BORDER                   = 0x00004000,

wxPG_NO_INTERNAL_BORDER             = 0x00008000

};

enum wxPG_EX_WINDOW_STYLES
{

wxPG_EX_INIT_NOCAT                  = 0x00001000,

wxPG_EX_NO_FLAT_TOOLBAR             = 0x00002000,

wxPG_EX_MODE_BUTTONS                = 0x00008000,

wxPG_EX_HELP_AS_TOOLTIPS            = 0x00010000,

//wxPG_EX_NO_TAB_TO_BUTTON            = 0x00020000,

#if wxPG_COMPATIBILITY_1_2_0
/* No longer used, defined for compatibility.
*/
wxPG_EX_GREY_LABEL_WHEN_DISABLED        = 0x00000000,
#endif

wxPG_EX_NATIVE_DOUBLE_BUFFERING         = 0x00080000,

#if wxPG_COMPATIBILITY_1_2_0

wxPG_EX_PROCESS_EVENTS_IMMEDIATELY      = 0x00000000,
#endif

wxPG_EX_AUTO_UNSPECIFIED_VALUES         = 0x00200000,

wxPG_EX_WRITEONLY_BUILTIN_ATTRIBUTES    = 0x00400000,

#if wxPG_COMPATIBILITY_1_2_0

wxPG_EX_TRADITIONAL_VALIDATORS          = 0x00000000,
#endif

wxPG_EX_LEGACY_VALIDATORS               = 0x00800000,

wxPG_EX_HIDE_PAGE_BUTTONS               = 0x01000000,

wxPG_EX_UNFOCUS_ON_ENTER                = 0x02000000,

wxPG_EX_MULTIPLE_SELECTION              = 0x04000000,

wxPG_EX_DISABLE_TLP_TRACKING            = 0x08000000,

wxPG_EX_NO_TOOLBAR_DIVIDER              = 0x10000000,

wxPG_EX_TOOLBAR_SEPARATOR               = 0x20000000

};

#define wxPG_EX_ENABLE_TLP_TRACKING     0x00000000


#define wxPG_DEFAULT_STYLE              (0)

#define wxPGMAN_DEFAULT_STYLE       (0)

enum wxPG_GETPROPERTYVALUES_FLAGS
{

wxPG_KEEP_STRUCTURE               = 0x00000010,

wxPG_RECURSE                      = 0x00000020,

wxPG_INC_ATTRIBUTES               = 0x00000040,

wxPG_RECURSE_STARTS               = 0x00000080,

wxPG_FORCE                        = 0x00000100

};

#define wxPG_DONT_RECURSE         0x00000000

// -----------------------------------------------------------------------

// Misc argument flags.
enum wxPG_MISC_ARG_FLAGS
{

wxPG_FULL_VALUE                     = 0x00000001,  // Get/Store full value instead of displayed value.

wxPG_REPORT_ERROR                   = 0x00000002,

wxPG_PROPERTY_SPECIFIC              = 0x00000004,

wxPG_EDITABLE_VALUE                 = 0x00000008,  // Get/Store editable value instead of displayed one
                                              // (should only be different in the case of common values)

wxPG_COMPOSITE_FRAGMENT             = 0x00000010,  // Used when dealing with fragments of composite string value

wxPG_UNEDITABLE_COMPOSITE_FRAGMENT  = 0x00000020,  // Means property for which final string value is for can not
                                                   // really be edited.

wxPG_PROGRAMMATIC_VALUE             = 0x00000040   // Value is being set programmatically (ie. not by user)
};


// -----------------------------------------------------------------------

// wxPGProperty::SetValue() flags
enum wxPG_SETVALUE_FLAGS
{
wxPG_SETVAL_REFRESH_EDITOR      = 0x0001,
wxPG_SETVAL_AGGREGATED          = 0x0002,
wxPG_SETVAL_FROM_PARENT         = 0x0004,
wxPG_SETVAL_BY_USER             = 0x0008  // Set if value changed by user
};

// -----------------------------------------------------------------------


#define wxNullProperty  ((wxPGProperty*)NULL)

#if wxPG_COMPATIBILITY_1_2_0
inline bool wxPGIdIsOk(wxPGProperty* id)
{
    return (id != NULL) ? true : false;
}
#endif

typedef wxPGProperty* wxPGId;

#ifndef SWIG

class WXDLLIMPEXP_PG wxPGPropArgCls
{
public:
    wxPGPropArgCls() { }
    wxPGPropArgCls( const wxPGProperty* property )
    {
        m_ptr.property = (wxPGProperty*) property;
        m_isName = false;
    }
    wxPGPropArgCls( const wxString& str )
    {
        m_ptr.name = &str;
        m_isName = 1;
    }
    wxPGPropArgCls( const wxPGPropArgCls& id )
    {
        m_ptr = id.m_ptr;
        m_isName = id.m_isName;
    }
#ifdef __WXPYTHON__
    wxPGPropArgCls( wxString* str, bool WXUNUSED(deallocPtr) )
    {
        m_ptr.name = str;
        m_isName = 3;
    }
    ~wxPGPropArgCls()
    {
        if ( m_isName == 3 )
            delete m_ptr.name;
    }
#endif
    wxPGProperty* GetPtr() const { wxCHECK( !m_isName, NULL ); return m_ptr.property; }
    wxPGPropArgCls( const wxChar* str )
    {
        m_ptr.rawname = str;
        m_isName = 2;
    }
    wxPGPropArgCls( int )
    {
        m_ptr.property = (wxPGProperty*) NULL;
        m_isName = false;
    }
    wxPGProperty* GetPtr( wxPropertyGridInterface* methods ) const;
    wxPGProperty* GetPtr( const wxPropertyGridInterface* methods ) const
    {
        return GetPtr((wxPropertyGridInterface*)methods);
    }
    wxPGProperty* GetPtr0() const { return m_ptr.property; }
    unsigned char HasName() const { return m_isName; }
    const wxString& GetName() const { return *m_ptr.name; }
private:
    union
    {
        wxPGProperty* property;
        const wxChar* rawname;
        const wxString* name;
    } m_ptr;
    unsigned char m_isName;
};

#else

class WXDLLIMPEXP_PG wxPGPropArgCls;

#endif

typedef const wxPGPropArgCls& wxPGPropArg;

// -----------------------------------------------------------------------

WXDLLIMPEXP_PG void wxPGTypeOperationFailed( const wxPGProperty* p, const wxChar* typestr, const wxChar* op );
WXDLLIMPEXP_PG void wxPGGetFailed( const wxPGProperty* p, const wxChar* typestr );

// -----------------------------------------------------------------------

enum wxPG_PROPERTY_FLAGS
{

wxPG_PROP_MODIFIED                  = 0x0001,

wxPG_PROP_DISABLED                  = 0x0002,

wxPG_PROP_HIDDEN                    = 0x0004,

wxPG_PROP_CUSTOMIMAGE               = 0x0008,

wxPG_PROP_NOEDITOR                  = 0x0010,

wxPG_PROP_COLLAPSED                 = 0x0020,

wxPG_PROP_INVALID_VALUE             = 0x0040,

// 0x0080,

wxPG_PROP_WAS_MODIFIED              = 0x0200,

wxPG_PROP_AGGREGATE                 = 0x0400,

wxPG_PROP_CHILDREN_ARE_COPIES       = 0x0800,

wxPG_PROP_PROPERTY                  = 0x1000,

wxPG_PROP_CATEGORY                  = 0x2000,

wxPG_PROP_MISC_PARENT               = 0x4000,

wxPG_PROP_READONLY                  = 0x8000,

//
// NB: FLAGS ABOVE 0x8000 CANNOT BE USED WITH PROPERTY ITERATORS
//

wxPG_PROP_COMPOSED_VALUE            = 0x00010000,

wxPG_PROP_USES_COMMON_VALUE         = 0x00020000,

wxPG_PROP_AUTO_UNSPECIFIED          = 0x00040000,

wxPG_PROP_CLASS_SPECIFIC_1          = 0x00080000,

wxPG_PROP_CLASS_SPECIFIC_2          = 0x00100000,

wxPG_PROP_BEING_DELETED             = 0x00200000

};

#define wxPG_PROP_MAX               wxPG_PROP_AUTO_UNSPECIFIED

#define wxPG_PROP_PARENTAL_FLAGS        (wxPG_PROP_AGGREGATE|wxPG_PROP_CATEGORY|wxPG_PROP_MISC_PARENT)

// Amalgam of flags that should be inherited by sub-properties
#define wxPG_INHERITED_PROPFLAGS        (wxPG_PROP_HIDDEN|wxPG_PROP_NOEDITOR)

// Combination of flags that can be stored by GetFlagsAsString
#define wxPG_STRING_STORED_FLAGS        (wxPG_PROP_DISABLED|wxPG_PROP_HIDDEN|wxPG_PROP_NOEDITOR|wxPG_PROP_COLLAPSED)

// -----------------------------------------------------------------------

#ifndef SWIG

#define wxPG_ATTR_MIN                     wxT("Min")

#define wxPG_ATTR_MAX                     wxT("Max")

#define wxPG_ATTR_UNITS                     wxT("Units")

#define wxPG_ATTR_INLINE_HELP               wxT("InlineHelp")

#define wxPG_BOOL_USE_CHECKBOX              wxT("UseCheckbox")

#define wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING  wxT("UseDClickCycling")

#define wxPG_FLOAT_PRECISION                wxT("Precision")

#define wxPG_STRING_PASSWORD                wxT("Password")

#define wxPG_UINT_BASE                      wxT("Base")

#define wxPG_UINT_PREFIX                    wxT("Prefix")

#define wxPG_FILE_WILDCARD                  wxT("Wildcard")

#define wxPG_FILE_SHOW_FULL_PATH            wxT("ShowFullPath")

#define wxPG_FILE_SHOW_RELATIVE_PATH        wxT("ShowRelativePath")

#define wxPG_FILE_INITIAL_PATH              wxT("InitialPath")

#define wxPG_FILE_DIALOG_TITLE              wxT("DialogTitle")

#define wxPG_DIR_DIALOG_MESSAGE             wxT("DialogMessage")

#define wxPG_DATE_FORMAT                    wxT("DateFormat")

#define wxPG_DATE_PICKER_STYLE              wxT("PickerStyle")

#define wxPG_ATTR_SPINCTRL_STEP             wxT("Step")

#define wxPG_ATTR_SPINCTRL_WRAP             wxT("Wrap")

#define wxPG_ATTR_SPINCTRL_MOTIONSPIN       wxT("MotionSpin")

#define wxPG_ATTR_MULTICHOICE_USERSTRINGMODE    wxT("UserStringMode")

#ifdef wxPG_COMPATIBILITY_1_0_0

#define wxPG_CUSTOM_EDITOR                  wxT("128")

#define wxPG_CUSTOM_IMAGE                   wxT("129")

#define wxPG_CUSTOM_CALLBACK                wxT("130")

#endif // wxPG_COMPATIBILITY_1_0_0

#define wxPG_CUSTOM_PAINT_CALLBACK          wxT("PaintCallback")


#define wxPG_CUSTOM_PRIVATE_CHILDREN        wxT("PrivateChildren")


#define wxPG_COLOUR_ALLOW_CUSTOM            wxT("AllowCustom")


//#define wxPG_USER_ATTRIBUTE                 192

#ifndef DOXYGEN

// Redefine attribute macros to use cached strings
#undef wxPG_ATTR_DEFAULT_VALUE
#define wxPG_ATTR_DEFAULT_VALUE           wxPGGlobalVars->m_strDefaultValue
#undef wxPG_ATTR_MIN
#define wxPG_ATTR_MIN                     wxPGGlobalVars->m_strMin
#undef wxPG_ATTR_MAX
#define wxPG_ATTR_MAX                     wxPGGlobalVars->m_strMax
#undef wxPG_ATTR_UNITS
#define wxPG_ATTR_UNITS                   wxPGGlobalVars->m_strUnits
#undef wxPG_ATTR_INLINE_HELP
#define wxPG_ATTR_INLINE_HELP             wxPGGlobalVars->m_strInlineHelp

#endif  // !DOXYGEN

#endif  // !SWIG


//
// Valid constants for wxPG_UINT_BASE attribute
// (long because of wxVariant constructor)
#define wxPG_BASE_OCT                       (long)8
#define wxPG_BASE_DEC                       (long)10
#define wxPG_BASE_HEX                       (long)16
#define wxPG_BASE_HEXL                      (long)32

//
// Valid constants for wxPG_UINT_PREFIX attribute
#define wxPG_PREFIX_NONE                    (long)0
#define wxPG_PREFIX_0x                      (long)1
#define wxPG_PREFIX_DOLLAR_SIGN             (long)2


// -----------------------------------------------------------------------
// Editor class.

// Editor accessor.
#define wxPG_EDITOR(T)          wxPGEditor_##T

// Declare editor class, with optional part.
#define WX_PG_DECLARE_EDITOR_WITH_DECL(EDITOR,DECL) \
extern DECL wxPGEditor* wxPGEditor_##EDITOR; \
extern DECL wxPGEditor* wxPGConstruct##EDITOR##EditorClass();

// Declare editor class.
#define WX_PG_DECLARE_EDITOR(EDITOR) \
extern wxPGEditor* wxPGEditor_##EDITOR; \
extern wxPGEditor* wxPGConstruct##EDITOR##EditorClass();

// Declare builtin editor classes.
WX_PG_DECLARE_EDITOR_WITH_DECL(TextCtrl,WXDLLIMPEXP_PG)
WX_PG_DECLARE_EDITOR_WITH_DECL(Choice,WXDLLIMPEXP_PG)
WX_PG_DECLARE_EDITOR_WITH_DECL(ComboBox,WXDLLIMPEXP_PG)
WX_PG_DECLARE_EDITOR_WITH_DECL(TextCtrlAndButton,WXDLLIMPEXP_PG)
#if wxPG_INCLUDE_CHECKBOX
WX_PG_DECLARE_EDITOR_WITH_DECL(CheckBox,WXDLLIMPEXP_PG)
#endif
WX_PG_DECLARE_EDITOR_WITH_DECL(ChoiceAndButton,WXDLLIMPEXP_PG)

// -----------------------------------------------------------------------


#ifdef SWIG
    #define wxVARIANT_REFCOUNTED 1
#endif

//
// For compability with wxWidgets 2.6 patched with refcounted wxVariant
#ifndef wxVARIANT_REFCOUNTED
  #if wxCHECK_VERSION(2,8,0)
    #define wxVARIANT_REFCOUNTED 1
  #else
    #define wxVARIANT_REFCOUNTED 0
    #error "Only supports wxWidgets 2.6 that has been patched with refcounted wxVariant"
  #endif
#endif


#if !defined(SWIG)

class WXDLLIMPEXP_PG wxPGVariantData : public wxVariantData
{
#if !wxCHECK_VERSION(2,9,0)
    DECLARE_ABSTRACT_CLASS(wxPGVariantData)
#endif
public:
    virtual void* GetValuePtr() = 0;
    virtual wxVariant GetDefaultValue() const = 0;
protected:
};


//
// With wxWidgets 2.9 and later we demand native C++ RTTI support
#if wxCHECK_VERSION(2,9,0)
    #ifdef wxNO_RTTI
        #error "You need to enable compiler RTTI support when using wxWidgets 2.9.0 or later"
    #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()) )
#else
    #define WX_PG_DECLARE_DYNAMIC_CLASS_VARIANTDATA DECLARE_DYNAMIC_CLASS
    #define WX_PG_IMPLEMENT_DYNAMIC_CLASS_VARIANTDATA IMPLEMENT_DYNAMIC_CLASS
    typedef wxList wxVariantList;
    typedef wxClassInfo* wxPGVariantDataClassInfo;
    #define wxPGVariantDataGetClassInfo(A) (A->GetClassInfo())
    #define wxPG_VARIANT_EQ(A, B) ( ((A).GetData() && (B).GetData() && (A).GetData()->GetClassInfo() == (B).GetData()->GetClassInfo() && (A == B)) || (!(A).GetData() && !(B).GetData()) )
#endif

#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 wxString GetType() const { return wxT(#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; }


#define _WX_PG_IMPLEMENT_VARIANT_DATA_SHALLOW_EQ(CLASSNAME, DATATYPE) \
    virtual bool Eq(wxVariantData& other) const \
        { return (this == (const wxVariantData*) &other); }

#define _WX_PG_IMPLEMENT_VARIANT_DATA_PROPER_EQ(CLASSNAME, DATATYPE) \
    virtual bool Eq(wxVariantData& other) const \
    { \
        if ( other.GetType() != wxT(#DATATYPE) ) \
            return false; \
        CLASSNAME* pOther = wxStaticCast(&other, CLASSNAME); \
        return (m_value == pOther->GetValueRef()); \
    }

//
// 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 )
{
    return wxVariant((void*)&value);
}

template<> inline wxVariant WXVARIANT( const int& value ) { return wxVariant((long)value); }
template<> inline wxVariant WXVARIANT( const long& value ) { return wxVariant(value); }
template<> inline wxVariant WXVARIANT( const bool& value ) { return wxVariant(value); }
template<> inline wxVariant WXVARIANT( const double& value ) { return wxVariant(value); }
//template<> inline wxVariant WXVARIANT( const wxChar* value ) { return wxVariant(wxString(value)); }
//#if wxCHECK_VERSION(2,9,0)
//    template<> inline wxVariant WXVARIANT( const char* value ) { return wxVariant(wxString(value)); }
//#endif
template<> inline wxVariant WXVARIANT( const wxArrayString& value ) { return wxVariant(value); }
template<> inline wxVariant WXVARIANT( const wxString& value ) { return wxVariant(value); }
#if wxUSE_DATETIME
    template<> inline wxVariant WXVARIANT( const wxDateTime& value ) { return wxVariant(value); }
#endif

#if wxCHECK_VERSION(2,9,0)
    #define _WX_PG_VARIANT_DATA_CLASSINFO_CONTAINER_DECL(CLASSNAME) \
        extern int CLASSNAME##_d_;
    #define _WX_PG_VARIANT_DATA_CLASSINFO_CONTAINER(CLASSNAME) \
        int CLASSNAME##_d_;
#else
    #define _WX_PG_VARIANT_DATA_CLASSINFO_CONTAINER_DECL(CLASSNAME) \
        extern wxPGVariantDataClassInfo CLASSNAME##_ClassInfo
    #define _WX_PG_VARIANT_DATA_CLASSINFO_CONTAINER(CLASSNAME) \
        wxPGVariantDataClassInfo CLASSNAME##_ClassInfo = &CLASSNAME::ms_classInfo;
#endif

#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 ) \
{ \
        CLASSNAME *data = wxDynamicCastVariantData( variant.GetData(), CLASSNAME ); \
    wxASSERT( data ); \
    value = data->GetValue(); \
    return value; \
} \
wxVariant& operator <<( wxVariant &variant, AS_CONST_ARG value ) \
{ \
    CLASSNAME *data = new CLASSNAME( value ); \
    variant.SetData( data ); \
    return variant; \
} \
AS_ARG DATATYPE##FromVariant( const wxVariant& v ) \
{ \
        CLASSNAME *data = wxDynamicCastVariantData( v.GetData(), CLASSNAME ); \
    if ( !data ) \
        return NULLVAL; \
    return data->GetValueRef(); \
} \
wxVariant DATATYPE##ToVariant( AS_CONST_ARG value ) \
{ \
    wxVariant variant( new CLASSNAME( 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()) \
_WX_PG_IMPLEMENT_VARIANT_DATA_SHALLOW_EQ(CLASSNAME, DATATYPE) \
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()) \
_WX_PG_IMPLEMENT_VARIANT_DATA_SHALLOW_EQ(CLASSNAME, DATATYPE) \
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_IMPLEMENT_WXOBJECT_VARIANT_DATA_WITH_PROPER_EQ(CLASSNAME, DATATYPE) \
class CLASSNAME : public wxPGVariantData \
{ \
_WX_PG_IMPLEMENT_VARIANT_DATA_CLASS(CLASSNAME, DATATYPE, DATATYPE&, \
                                    const DATATYPE&, wxPGDoesNothing(), \
                                    wxVariant(new CLASSNAME(DATATYPE())), wxPGDoesNothing()) \
_WX_PG_IMPLEMENT_VARIANT_DATA_PROPER_EQ(CLASSNAME, DATATYPE) \
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) ) \
_WX_PG_IMPLEMENT_VARIANT_DATA_SHALLOW_EQ(CLASSNAME, DATATYPE) \
    ~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_PG)
WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataSize, wxSize, WXDLLIMPEXP_PG)
WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataArrayInt, wxArrayInt, WXDLLIMPEXP_PG)
WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataLongLong, wxLongLong, WXDLLIMPEXP_PG)
WX_PG_DECLARE_VARIANT_DATA(wxPGVariantDataULongLong, wxULongLong, WXDLLIMPEXP_PG)
#ifdef __WXPYTHON__
    WX_PG_DECLARE_PTR_VARIANT_DATA(wxPGVariantDataPyObject, PyObject, WXDLLIMPEXP_PG)
#endif

WX_PG_DECLARE_WXOBJECT_VARIANT_DATA(wxPGVariantDataFont, wxFont, WXDLLIMPEXP_PG)
#if !wxCHECK_VERSION(2,8,0)
    WX_PG_DECLARE_WXOBJECT_VARIANT_DATA(wxPGVariantDataColour, wxColour, WXDLLIMPEXP_PG)
#else
    template<> inline wxVariant WXVARIANT( const wxColour& value )
    {
        wxVariant variant;
        variant << value;
        return variant;
    }
#endif

#endif // !SWIG

#define WX_PG_VARIANT_GETVALUEREF(P, T)   (*((T*)((wxPGVariantData*)(P.GetData()))->GetValuePtr()))

// Safely converts a wxVariant to (long) int. Supports converting from string and boolean as well.
WXDLLIMPEXP_PG long wxPGVariantToInt( const wxVariant& variant, long defVal = 1 );

// Safely converts a wxVariant to wxLongLong_t. Returns true on success.
WXDLLIMPEXP_PG bool wxPGVariantToLongLong( const wxVariant& variant, wxLongLong_t* pResult );

// Safely converts a wxVariant to wxULongLong_t. Returns true on success.
WXDLLIMPEXP_PG bool wxPGVariantToULongLong( const wxVariant& variant, wxULongLong_t* pResult );

// Safely converts a wxVariant to double. Supports converting from string and wxLongLong as well.
WXDLLIMPEXP_PG bool wxPGVariantToDouble( const wxVariant& variant, double* pResult );


// -----------------------------------------------------------------------

// When wxPG is loaded dynamically after the application is already running
// then the built-in module system won't pick this one up.  Add it manually.
WXDLLIMPEXP_PG void wxPGInitResourceModule();

// -----------------------------------------------------------------------


#if !defined(SWIG)

#if wxPG_USE_STL
typedef std::vector<wxPGProperty*>  wxArrayPGProperty;
#else
WX_DEFINE_TYPEARRAY_WITH_DECL_PTR(wxPGProperty*, wxArrayPGProperty,
                                  wxBaseArrayPtrVoid, class WXDLLIMPEXP_PG);
#endif

// Always use wxString based hashmap with unicode, stl, swig and GCC 4.0+
WX_DECLARE_STRING_HASH_MAP_WITH_DECL(void*,
                                     wxPGHashMapS2P,
                                     class WXDLLIMPEXP_PG);

#else

class WXDLLIMPEXP_PG wxArrayPGProperty;
class WXDLLIMPEXP_PG wxPGHashMapS2P;

#endif


// -----------------------------------------------------------------------

//
// Property class declaration helper macros
// (wxPGRootPropertyClass and wxPropertyCategory require this).
//

// We don't want to create SWIG interface for DoGetEditorClass (we'll use GetEditor instead)
#ifndef SWIG
    #define WX_PG_DECLARE_DOGETEDITORCLASS  virtual const wxPGEditor* DoGetEditorClass() const;
#else
    #define WX_PG_DECLARE_DOGETEDITORCLASS
#endif

#ifndef SWIG
    #define WX_PG_DECLARE_PROPERTY_CLASS(CLASSNAME) \
        public: \
            DECLARE_DYNAMIC_CLASS(CLASSNAME) \
            WX_PG_DECLARE_DOGETEDITORCLASS \
        private:
#else
    #define WX_PG_DECLARE_PROPERTY_CLASS(CLASSNAME)
#endif

// Implements sans constructor function. Also, first arg is class name, not property name.
#define WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(PROPNAME,T,EDITOR) \
const wxPGEditor* PROPNAME::DoGetEditorClass() const \
{ \
    return wxPGEditor_##EDITOR; \
}


// -----------------------------------------------------------------------

//
// Ids for sub-controls
// NB: It should not matter what these are.
#define wxPG_SUBID1                     2
#define wxPG_SUBID2                     3
#define wxPG_SUBID_TEMP1                4


#ifndef SWIG

// -----------------------------------------------------------------------

// Structure for relaying choice/list info.
struct wxPGChoiceInfo
{
    wxPGChoices*    m_choices;
};

// -----------------------------------------------------------------------

class WXDLLIMPEXP_PG wxPGAttributeStorage
{
public:
    wxPGAttributeStorage();
    ~wxPGAttributeStorage();

    void Set( const wxString& name, const wxVariant& value );
    unsigned int GetCount() const
    {
        return (unsigned int) m_map.size();
    }
    wxVariant FindValue( const wxString& name ) const
    {
        wxPGHashMapS2P::const_iterator it = m_map.find(name);
        if ( it != m_map.end() )
        {
            wxVariantData* data = (wxVariantData*) it->second;
            data->IncRef();
            return wxVariant(data, it->first);
        }
        return wxVariant();
    }

    typedef wxPGHashMapS2P::const_iterator const_iterator;
    const_iterator StartIteration() const
    {
        return m_map.begin();
    }
    bool GetNext( const_iterator& it, wxVariant& variant ) const
    {
        if ( it == m_map.end() )
            return false;

        wxVariantData* data = (wxVariantData*) it->second;
        data->IncRef();
        variant.SetData(data);
        variant.SetName(it->first);
        it++;
        return true;
    }

protected:
    wxPGHashMapS2P  m_map;
};

#endif  // !SWIG

// -----------------------------------------------------------------------

class WXDLLIMPEXP_PG wxPGProperty : public wxObject
{
#ifndef SWIG
    friend class wxPropertyGrid;
    friend class wxPropertyGridInterface;
    friend class wxPropertyGridState;
    friend class wxPropertyGridPopulator;
    friend class wxStringProperty;  // Proper "<composed>" support requires this
    DECLARE_ABSTRACT_CLASS(wxPGProperty)
#endif
public:
    typedef wxUint32 FlagType;
#ifndef __WXPYTHON__
    typedef void* ClientDataType;
#else
    typedef PyObject* ClientDataType;
#endif

// PYSWIG is a special symbol used by my custom scripts. Code to remove it
// automatically should be added in future.
#ifndef PYSWIG

    wxPGProperty();
#endif

    wxPGProperty( const wxString& label, const wxString& name );

    virtual ~wxPGProperty();

    virtual void OnSetValue();

    virtual wxVariant DoGetValue() const { return m_value; }

#ifndef DOXYGEN
private:
#else
public:
#endif
    // These methods are private. Use ActualXXX versions in code.
    //

    virtual bool ValidateValue( wxVariant& value, wxPGValidationInfo& validationInfo ) const;

    virtual bool StringToValue( wxVariant& variant, const wxString& text, int argFlags = 0 ) const;

    virtual bool IntToValue( wxVariant& value, int number, int argFlags = 0 ) const;
public:

    virtual wxString GetValueAsString( int argFlags = 0 ) const;

#if wxPG_COMPATIBILITY_1_2_0
    virtual
#endif
    bool SetValueFromString( const wxString& text, int flags = wxPG_PROGRAMMATIC_VALUE );

#if wxPG_COMPATIBILITY_1_2_0
    virtual
#endif
    bool SetValueFromInt( long value, int flags = 0 );

#if wxPG_COMPATIBILITY_1_2_0

    virtual wxSize GetImageSize() const;
#endif

    virtual wxSize OnMeasureImage( int item = -1 ) const;

    virtual bool OnEvent( wxPropertyGrid* propgrid, wxWindow* wnd_primary, wxEvent& event );

    virtual void ChildChanged( wxVariant& thisValue, int childIndex, wxVariant& childValue ) const;

#ifdef __WXPYTHON__
    // Because SWIG doesn't generate code well for writeback variables,
    // we need to declare custom versions of some functions.
    virtual wxPGVariantAndBool PyValidateValue( const wxVariant& value, wxPGValidationInfo& validationInfo ) const;
    virtual wxPGVariantAndBool PyStringToValue( const wxString& text, int argFlags = 0 ) const;
    virtual wxPGVariantAndBool PyIntToValue( int number, int argFlags = 0 ) const;
#endif

    bool ActualValidateValue( wxVariant& value, wxPGValidationInfo& validationInfo ) const
    {
#ifdef __WXPYTHON__
        if ( m_scriptObject )
        {
            wxPGVariantAndBool vab = PyValidateValue(value, validationInfo);
            if ( vab.m_valueValid )
                value = vab.m_value;
            return vab.m_result;
        }
#endif

        return ValidateValue(value, validationInfo);
    }

    bool ActualStringToValue( wxVariant& variant, const wxString& text, int argFlags = 0 ) const
    {
#ifdef __WXPYTHON__
        if ( m_scriptObject )
        {
            wxPGVariantAndBool vab = PyStringToValue(text, argFlags);
            if ( vab.m_valueValid )
                variant = vab.m_value;
            return vab.m_result;
        }
#endif

        return StringToValue(variant, text, argFlags);
    }

    bool ActualIntToValue( wxVariant& variant, int number, int argFlags = 0 ) const
    {
#ifdef __WXPYTHON__
        if ( m_scriptObject )
        {
            wxPGVariantAndBool vab = PyIntToValue(number, argFlags);
            if ( vab.m_valueValid )
                variant = vab.m_value;
            return vab.m_result;
        }
#endif

        return IntToValue(variant, number, argFlags);
    }

    wxString GetValueType() const
    {
        return m_value.GetType();
    }

#ifndef SWIG

    virtual const wxPGEditor* DoGetEditorClass() const;
#endif

#ifdef __WXPYTHON__

    virtual wxString GetEditor() const;
#endif

    virtual wxValidator* DoGetValidator () const;

    virtual int GetChoiceInfo( wxPGChoiceInfo* choiceinfo );

    virtual void OnCustomPaint( wxDC& dc, const wxRect& rect, wxPGPaintData& paintdata );

    virtual wxPGCellRenderer* GetCellRenderer( int column ) const;

    virtual void RefreshChildren();

    virtual bool DoSetAttribute( const wxString& name, wxVariant& value );

    virtual wxVariant DoGetAttribute( const wxString& name ) const;

    virtual wxPGEditorDialogAdapter* GetEditorDialog() const;

    virtual void OnValidationFailure( wxVariant& pendingValue );

    int AppendChoice( const wxString& label, int value = wxPG_INVALID_VALUE )
    {
        return InsertChoice(label,-1,value);
    }

    wxPGCell* AcquireCell( unsigned int column )
    {
        if ( column >= m_cells.size() )
            return NULL;

        wxPGCell* cell = (wxPGCell*) m_cells[column];
        m_cells[column] = NULL;
        return cell;
    }

    bool AreChildrenComponents() const
    {
        if ( m_flags & (wxPG_PROP_COMPOSED_VALUE|wxPG_PROP_AGGREGATE) )
            return true;

        return false;
    }

    void AddPrivateChild( wxPGProperty* prop )
    {
        AddChild(prop);
    }

    wxPGProperty* AppendChild( wxPGProperty* prop )
    {
        return InsertChild(-1, prop);
    }

    wxPGProperty* InsertChild( int index, wxPGProperty* childProperty );

    void DeleteChildren();

    void DeleteChoice( int index );

    void Empty()
    {
        DeleteChildren();
    }

    void EnableCommonValue( bool enable = true )
    {
        if ( enable ) SetFlag( wxPG_PROP_USES_COMMON_VALUE );
        else ClearFlag( wxPG_PROP_USES_COMMON_VALUE );
    }

    void GenerateComposedValue( wxString& text, int argFlags = 0 ) const;

    const wxString& GetLabel() const { return m_label; }

    wxString GetName() const;

    const wxString& GetBaseName() const { return m_name; }

    wxPGChoices& GetChoices();

    const wxPGChoices& GetChoices() const;

    const wxPGChoiceEntry* GetCurrentChoice() const;

    int GetY() const;

    wxVariant GetValue() const
    {
    #ifdef __WXPYTHON__
        wxVariant val = DoGetValue();
        if ( val.IsNull() )
            return PyObjectToVariant( Py_None );
        return val;
    #else
        return DoGetValue();
    #endif
    }

    wxVariant& GetValueRef()
    {
        return m_value;
    }

    const wxVariant& GetValueRef() const
    {
        return m_value;
    }

    wxString GetValueString( int argFlags = 0 ) const;

    wxPGCell* GetCell( unsigned int column ) const
    {
        if ( column >= m_cells.size() )
            return NULL;

        return (wxPGCell*) m_cells[column];
    }

    wxPGCell* GetOrCreateCell( unsigned int column );

    const wxChar* GetClassName() const
    {
        return GetClassInfo()->GetClassName();
    }

    unsigned int GetChoiceCount() const;

    wxString GetChoiceString( unsigned int index );

    int GetDisplayedCommonValueCount() const;

    wxString GetDisplayedString() const
    {
        return GetValueString(0);
    }

#if wxPG_COMPATIBILITY_1_2_0

    wxPGId GetId() { return this; }
#endif

    wxPropertyGrid* GetGrid() const;

    wxPropertyGrid* GetGridIfDisplayed() const;

    wxPGProperty* GetMainParent() const;

    wxPGProperty* GetParent() const { return m_parent; }

    bool IsFlagSet( FlagType flag ) const
    {
        return ( m_flags & flag ) ? true : false;
    }

    bool IsTextEditable() const;

    bool IsValueUnspecified() const
    {
        return m_value.IsNull();
    }

    FlagType HasFlag( FlagType flag ) const
    {
        return ( m_flags & flag );
    }

    bool CanHaveExtraChildren() const
    {
        return !IsFlagSet(wxPG_PROP_AGGREGATE);
    }

    const wxPGAttributeStorage& GetAttributes() const
    {
        return m_attributes;
    }

    wxVariant GetAttributesAsList() const;

    FlagType GetFlags() const
    {
        return m_flags;
    }

    const wxPGEditor* GetEditorClass() const;

    const wxPGEditor* GetColumnEditor( int column ) const
    {
        if ( column == 1 )
            return GetEditorClass();

        return NULL;
    }

    int GetCommonValue() const
    {
        return m_commonValue;
    }

    wxString GetType() const
    {
        return m_value.GetType();
    }

    bool HasVisibleChildren() const;

    int InsertChoice( const wxString& label, int index, int value = wxPG_INVALID_VALUE );

    bool IsCategory() const { return IsFlagSet(wxPG_PROP_CATEGORY); }

    bool IsRoot() const { return (m_parent == NULL); }

    bool IsSubProperty() const
    {
        wxPGProperty* parent = (wxPGProperty*)m_parent;
        if ( parent && !parent->IsCategory() )
            return true;
        return false;
    }

    const wxPGProperty* GetLastVisibleSubItem() const;

    wxVariant GetDefaultValue() const;

    int GetMaxLength() const
    {
        return (int) m_maxLen;
    }

#ifdef SWIG
    %pythoncode {
        def GetValue(self):
            return self.GetGrid().GetPropertyValue(self)
    }
#else

  #if wxPG_COMPATIBILITY_1_2_0
    wxVariant GetValueAsVariant() const
    {
        return GetValue();
    }
  #endif
#endif

    bool AreAllChildrenSpecified( wxVariant* pendingList = NULL ) const;

    wxPGProperty* UpdateParentValues();

    FlagType UsesAutoUnspecified() const
    {
        return HasFlag(wxPG_PROP_AUTO_UNSPECIFIED);
    }

    wxBitmap* GetValueImage() const
    {
        return m_valueBitmap;
    }

    wxVariant GetAttribute( const wxString& name ) const;

    wxString GetAttribute( const wxString& name, const wxString& defVal ) const;

    long GetAttributeAsLong( const wxString& name, long defVal ) const;

    double GetAttributeAsDouble( const wxString& name, double defVal ) const;

    inline unsigned int GetArrIndex() const { return m_arrIndex; }

    inline unsigned int GetDepth() const { return (unsigned int)m_depth; }

    wxString GetFlagsAsString( FlagType flagsMask ) const;

    unsigned int GetIndexInParent() const
    {
        return m_arrIndex;
    }

    inline bool Hide( bool hide, int flags = wxPG_RECURSE );

    bool IsExpanded() const { return (!(m_flags & wxPG_PROP_COLLAPSED) && GetChildCount()); }

    bool IsVisible() const;

    bool IsEnabled() const
    {
        return ( m_flags & wxPG_PROP_DISABLED ) ? false : true;
    }

    bool RecreateEditor();

    void RefreshEditor();

    void SetAttribute( const wxString& name, wxVariant value );

    void SetAttributes( const wxPGAttributeStorage& attributes );

    void SetDefaultValue( wxVariant& value )
    {
        SetAttribute(wxT("DefaultValue"), value);
    }

#ifndef SWIG
    void SetEditor( const wxPGEditor* editor )
    {
        m_customEditor = editor;
    }
#endif

    inline void SetEditor( const wxString& editorName );

    void SetCell( int column, wxPGCell* cellObj );

    void SetChoiceSelection( int newValue, const wxPGChoiceInfo& choiceInfo );

    void SetCommonValue( int commonValue )
    {
        m_commonValue = commonValue;
    }

    void SetFlagsFromString( const wxString& str );

    void SetValueInEvent( wxVariant value ) const;

    void SetValue( wxVariant value, wxVariant* pList = NULL,
                   int flags = wxPG_SETVAL_REFRESH_EDITOR );

    void SetValueImage( wxBitmap& bmp );

    void SetChoicesExclusive();

    void SetExpanded( bool expanded )
    {
        if ( !expanded ) m_flags |= wxPG_PROP_COLLAPSED;
        else m_flags &= ~wxPG_PROP_COLLAPSED;
    }

    void SetFlag( FlagType flag ) { m_flags |= flag; }

    void ChangeFlag( FlagType flag, bool set )
    {
        if ( set )
            m_flags |= flag;
        else
            m_flags &= ~flag;
    }

    void SetFlagRecursively( FlagType flag, bool set );

    void SetHelpString( const wxString& helpString )
    {
        m_helpString = helpString;
    }

    void SetLabel( const wxString& label ) { m_label = label; }

    void SetName( const wxString& newName );

    void SetValueToUnspecified()
    {
        wxVariant val;  // Create NULL variant
        SetValue(val);
    }

#if wxUSE_VALIDATORS

    void SetValidator( const wxValidator& validator )
    {
        m_validator = wxDynamicCast(validator.Clone(),wxValidator);
    }

    wxValidator* GetValidator() const
    {
        if ( m_validator )
            return m_validator;
        return DoGetValidator();
    }
#endif // #if wxUSE_VALIDATORS

    bool PrepareValueForDialogEditing( wxPropertyGrid* propgrid );

    //
    // NB: There is something slightly wrong with the Python
    //     client data code. What exactly, I have no idea. Increfs
    //     and decrefs seemed to be correct, but in certain complex
    //     situations (where two separate grids refer to same
    //     client data objects are being destroyed?) it causes a hard
    //     crash. Current workaround is not to use this "native" client
    //     data but use some Python dict system instead. I won't replace
    //     current system with such just yet... (but maybe I should
    //     or need to).
    ClientDataType GetClientData() const
    {
#ifdef __WXPYTHON__
        if ( m_clientData )
            Py_INCREF( m_clientData );
        else
            Py_RETURN_NONE;
#endif
        return m_clientData;
    }

    void SetClientData( ClientDataType clientData )
    {
#ifdef __WXPYTHON__
        if ( m_clientData )
            Py_DECREF( m_clientData );

        if ( clientData == Py_None )
        {
            m_clientData = NULL;
            return;
        }

        Py_INCREF( clientData );
#endif
        m_clientData = clientData;
    }

    bool SetChoices( wxPGChoices& choices );

    inline bool SetChoices( const wxArrayString& labels,
                            const wxArrayInt& values = wxPG_EMPTY_ARRAYINT );

    inline bool SetMaxLength( int maxLen );

    void SetWasModified( bool set = true )
    {
        if ( set ) m_flags |= wxPG_PROP_WAS_MODIFIED;
        else m_flags &= ~wxPG_PROP_WAS_MODIFIED;
    }

    const wxString& GetHelpString() const
    {
        return m_helpString;
    }

    void ClearFlag( FlagType flag ) { m_flags &= ~(flag); }

    // Use, for example, to detect if item is inside collapsed section.
    bool IsSomeParent( wxPGProperty* candidate_parent ) const;

#if defined(__WXPYTHON__) && !defined(SWIG)
    // This is the python object that contains and owns the C++ representation.
    PyObject*                   m_scriptObject;
#endif

    void AdaptListToValue( wxVariant& list, wxVariant* value ) const;

    int GetChildrenHeight( int lh, int iMax = -1 ) const;

    unsigned int GetChildCount() const
    {
        return (unsigned int) m_children.GetCount();
    }

    unsigned int GetCount() const
    {
        return GetChildCount();
    }

    wxPGProperty* Item( unsigned int i ) const
    {
        return (wxPGProperty*)m_children.Item(i);
    }

    wxPGProperty* Last() const { return (wxPGProperty*)m_children.Last(); }

    int Index( const wxPGProperty* p ) const { return m_children.Index((wxPGProperty*)p); }

    // Puts correct indexes to children
    void FixIndexesOfChildren( unsigned int starthere = 0 );

#ifndef SWIG
    // Returns wxPropertyGridState in which this property resides.
    wxPropertyGridState* GetParentState() const { return m_parentState; }
#endif

    wxPGProperty* GetItemAtY( unsigned int y, unsigned int lh, unsigned int* nextItemY ) const;

    wxPGProperty* GetPropertyByName( const wxString& name ) const;

    int GetImageOffset( int imageWidth ) const;

protected:

    void AddChild( wxPGProperty* prop );

#ifndef SWIG

    wxString GetColumnText( unsigned int col ) const;

    wxPGProperty* GetPropertyByNameWH( const wxString& name, unsigned int hintIndex ) const;

    void AddChild2( wxPGProperty* prop, int index = -1, bool correct_mode = true );

    void DoSetName(const wxString& str) { m_name = str; }

    void DoEmpty();

    // Call for after sub-properties added with AddChild
    void PrepareSubProperties();

    void SetParentalType( int flag )
    {
        m_flags = (m_flags&(~(wxPG_PROP_PROPERTY|wxPG_PROP_PARENTAL_FLAGS)))|flag;
    }

    void SetParentState( wxPropertyGridState* pstate ) { m_parentState = pstate; }

    // Call after fixed sub-properties added/removed after creation.
    // if oldSelInd >= 0 and < new max items, then selection is
    // moved to it.
    void SubPropsChanged( int oldSelInd = -1 );

    int GetY2( int lh ) const;

    wxString                    m_label;
    wxString                    m_name;
    wxPGProperty*               m_parent;
    wxPropertyGridState*        m_parentState;
    ClientDataType              m_clientData;
    const wxPGEditor*           m_customEditor; // Overrides editor returned by property class
#if wxUSE_VALIDATORS
    wxValidator*                m_validator; // Editor is going to get this validator
#endif
    // TODO: Can bitmap be implemented with wxPGCell?
    wxBitmap*                   m_valueBitmap; // Show this in front of the value

    wxVariant                   m_value;
    wxPGAttributeStorage        m_attributes;
    wxArrayPtrVoid              m_children;
    wxArrayPtrVoid              m_cells;  // Extended cell information
    wxString                    m_helpString; // Help shown in statusbar or help box.

    unsigned int                m_arrIndex; // Index in parent's property array.
    int                         m_commonValue; // If not -1, then overrides m_value

    FlagType                    m_flags;

    short                       m_maxLen; // Maximum length (mainly for string properties).
                                          // Could be in some sort of wxBaseStringProperty, but currently,
                                          // for maximum flexibility and compatibility, we'll stick it here.
                                          // Anyway, we had 3 excess bytes to use so short int will fit in
                                          // just fine.

    unsigned char               m_depth; // Root has 0, categories etc. at that level 1, etc.

    // m_depthBgCol indicates width of background colour between margin and item
    // (essentially this is category's depth, if none then equals m_depth).
    unsigned char               m_depthBgCol;

    unsigned char               m_bgColIndex; // Background brush index.
    unsigned char               m_fgColIndex; // Foreground colour index.

private:
    // Called in constructors.
    void Init();
    void Init( const wxString& label, const wxString& name );
#endif // #ifndef SWIG
};


#if wxPG_COMPATIBILITY_1_2_0
    typedef wxPGProperty wxPGPropertyWithChildren;
#endif

#define wxPGPropNameStr            const wxString&
#define wxPGNameConv(STR)      STR

// -----------------------------------------------------------------------


#ifndef SWIG

WX_DECLARE_VOIDPTR_HASH_MAP_WITH_DECL(void*,
                                      wxPGHashMapP2P,
                                      class WXDLLIMPEXP_PG);

#else
class WXDLLIMPEXP_PG wxPGHashMapP2P;
#endif // #ifndef SWIG

// -----------------------------------------------------------------------

#ifndef SWIG

WX_DECLARE_HASH_MAP_WITH_DECL(wxInt32,
                              wxInt32,
                              wxIntegerHash,
                              wxIntegerEqual,
                              wxPGHashMapI2I,
                              class WXDLLIMPEXP_PG);

#else
class WXDLLIMPEXP_PG wxPGHashMapI2I;
#endif // #ifndef SWIG

// -----------------------------------------------------------------------

#ifndef SWIG

class WXDLLIMPEXP_PG wxPGRootProperty : public wxPGProperty
{
public:
    WX_PG_DECLARE_PROPERTY_CLASS(wxPGRootProperty)
public:

    wxPGRootProperty();
    virtual ~wxPGRootProperty();

    virtual bool StringToValue( wxVariant&, const wxString&, int ) const
    {
        return false;
    }

    virtual void ChildChanged( wxVariant&, int, wxVariant& ) const
    {
    }

protected:
};

// -----------------------------------------------------------------------

class WXDLLIMPEXP_PG wxPropertyCategory : public wxPGProperty
{
    WX_PG_DECLARE_PROPERTY_CLASS(wxPropertyCategory)
public:

    wxPropertyCategory();

    wxPropertyCategory( const wxString& label, const wxString& name = wxPG_LABEL );
    ~wxPropertyCategory();

    virtual wxString GetValueAsString( int argFlags ) const;

    virtual void ChildChanged( wxVariant&, int, wxVariant& ) const
    {
    }

    int GetTextExtent( const wxWindow* wnd, const wxFont& font ) const;

    void CalculateTextExtent( wxWindow* wnd, const wxFont& font );

    void SetTextColIndex( unsigned int colInd ) { m_capFgColIndex = (wxByte) colInd; }
    unsigned int GetTextColIndex() const { return (unsigned int) m_capFgColIndex; }

protected:
    int     m_textExtent;  // pre-calculated length of text
    wxByte  m_capFgColIndex;  // caption text colour index

private:
    void Init();
};

#endif  // !SWIG

// -----------------------------------------------------------------------

class WXDLLIMPEXP_PG wxPGCommonValue
{
public:

    wxPGCommonValue( const wxString& label, wxPGCellRenderer* renderer )
    {
        m_label = label;
        m_renderer = renderer;
        renderer->IncRef();
    }
    virtual ~wxPGCommonValue()
    {
        m_renderer->DecRef();
    }

    virtual wxString GetEditableText() const { return m_label; }
    const wxString& GetLabel() const { return m_label; }
    wxPGCellRenderer* GetRenderer() const { return m_renderer; }

protected:
    wxString            m_label;
    wxPGCellRenderer*   m_renderer;
};

// -----------------------------------------------------------------------


#ifndef SWIG

class WXDLLIMPEXP_PG wxPGChoiceEntry : public wxPGCell
{
public:
    wxPGChoiceEntry();
    wxPGChoiceEntry( const wxPGChoiceEntry& entry );
    wxPGChoiceEntry( const wxString& label,
                     int value = wxPG_INVALID_VALUE )
        : wxPGCell(), m_value(value)
    {
        m_text = label;
    }

    wxPGChoiceEntry( const wxString& label,
                     int value,
                     const wxBitmap& bitmap,
                     const wxColour& fgCol = wxNullColour,
                     const wxColour& bgCol = wxNullColour )
        : wxPGCell(label, bitmap, fgCol, bgCol), m_value(value)
    {
    }

    virtual ~wxPGChoiceEntry()
    {
    }

    void SetValue( int value ) { m_value = value; }

    int GetValue() const { return m_value; }

protected:
    int m_value;
};


typedef void* wxPGChoicesId;

class WXDLLIMPEXP_PG wxPGChoicesData
{
    friend class wxPGChoices;
public:
    // Constructor sets m_refCount to 1.
    wxPGChoicesData();

    void CopyDataFrom( wxPGChoicesData* data );

    // Takes ownership of 'item'
    void Insert( int index, wxPGChoiceEntry* item )
    {
        wxArrayPtrVoid::iterator it;
        if ( index == -1 )
        {
            it = m_items.end();
            index = (int) m_items.size();
        }
        else
        {
            it = m_items.begin() + index;
        }

        // Need to fix value?
        if ( item->GetValue() == wxPG_INVALID_VALUE )
            item->SetValue(index);

        m_items.insert(it, item);
    }

    // Delete all entries
    void Clear();

    unsigned int GetCount() const
    {
        return (unsigned int) m_items.size();
    }

    wxPGChoiceEntry* Item( unsigned int i ) const
    {
        return (wxPGChoiceEntry*) m_items[i];
    }

    void DecRef()
    {
        m_refCount--;
        wxASSERT( m_refCount >= 0 );
        if ( m_refCount == 0 )
            delete this;
    }

private:
    wxArrayPtrVoid  m_items;

    // So that multiple properties can use the same set
    int             m_refCount;

    virtual ~wxPGChoicesData();
};

#define wxPGChoicesEmptyData    ((wxPGChoicesData*)NULL)

#endif // SWIG


class WXDLLIMPEXP_PG wxPGChoices
{
public:

    wxPGChoices()
    {
        Init();
    }

    wxPGChoices( const wxPGChoices& src )
    {
        if ( src.m_data != wxPGChoicesEmptyData )
        {
            m_data = src.m_data;
            m_data->m_refCount++;
        }
    }

    wxPGChoices( const wxChar** labels, const long* values = NULL )
    {
        Init();
        Set(labels,values);
    }

    wxPGChoices( const wxArrayString& labels, const wxArrayInt& values = wxPG_EMPTY_ARRAYINT )
    {
        Init();
        Set(labels,values);
    }

    wxPGChoices( wxPGChoicesData* data )
    {
        wxASSERT(data);
        m_data = data;
        data->m_refCount++;
    }

    ~wxPGChoices()
    {
        Free();
    }

    void AssignData( wxPGChoicesData* data );

    void Assign( const wxPGChoices& src )
    {
        AssignData(src.m_data);
    }

#ifndef SWIG
    void operator= (const wxPGChoices& a)
    {
        AssignData(a.m_data);
    }
#endif

    typedef long ValArrItem;

    void Add( const wxChar** labels, const ValArrItem* values = NULL );

    void Add( const wxArrayString& arr, const ValArrItem* values = NULL );

    void Add( const wxArrayString& arr, const wxArrayInt& arrint );

    wxPGChoiceEntry& Add( const wxString& label, int value = wxPG_INVALID_VALUE );

    wxPGChoiceEntry& Add( const wxString& label, const wxBitmap& bitmap, int value = wxPG_INVALID_VALUE );

    wxPGChoiceEntry& Add( const wxPGChoiceEntry& entry )
    {
        return Insert(entry, -1);
    }

    wxPGChoiceEntry& AddAsSorted( const wxString& label, int value = wxPG_INVALID_VALUE );

    void Clear()
    {
        if ( m_data != wxPGChoicesEmptyData )
            m_data->Clear();
    }

    wxPGChoices Copy() const
    {
        wxPGChoices dst;
        dst.EnsureData();
        dst.m_data->CopyDataFrom(m_data);
        return dst;
    }

    void EnsureData()
    {
        if ( m_data == wxPGChoicesEmptyData )
            m_data = new wxPGChoicesData();
    }

    const wxPGChoiceEntry& Item( unsigned int i ) const
    {
        wxASSERT( IsOk() );
        return *m_data->Item(i);
    }

    wxPGChoiceEntry& Item( unsigned int i )
    {
        wxASSERT( IsOk() );
        return *m_data->Item(i);
    }

    wxPGChoiceEntry& operator[](unsigned int i)
    {
        return Item(i);
    }

    const wxPGChoiceEntry& operator[](unsigned int i) const
    {
        return Item(i);
    }

    bool IsOk() const
    {
        return ( m_data != wxPGChoicesEmptyData );
    }

    wxPGChoicesId GetId() const { return (wxPGChoicesId) m_data; };

    void RemoveAt(size_t nIndex, size_t count = 1);

#ifndef SWIG

    void Set( const wxChar** labels, const long* values = NULL )
    {
        Free();
        Add(labels,values);
    }

    void Set( wxArrayString& arr, const long* values = (const long*) NULL )
    {
        Free();
        Add(arr,values);
    }
#endif // SWIG

    void Set( const wxArrayString& labels, const wxArrayInt& values = wxPG_EMPTY_ARRAYINT )
    {
        Free();
        if ( &values )
            Add(labels,values);
        else
            Add(labels);
    }

    // Creates exclusive copy of current choices
    void SetExclusive()
    {
        if ( m_data->m_refCount != 1 )
        {
            wxPGChoicesData* data = new wxPGChoicesData();
            data->CopyDataFrom(m_data);
            Free();
            m_data = data;
        }
    }

    const wxString& GetLabel( unsigned int ind ) const
    {
        wxASSERT( ind >= 0 && ind < GetCount() );
        return Item(ind).GetText();
    }

    unsigned int GetCount () const
    {
        if ( m_data )
            return m_data->GetCount();
        return 0;
    }

#if wxPG_COMPATIBILITY_1_2_0

    wxDEPRECATED( bool HasValues() const );

    wxDEPRECATED( bool HasValue( unsigned int i ) const );
#endif

    int GetValue( unsigned int ind ) const { return Item(ind).GetValue(); }

    wxArrayInt GetValuesForStrings( const wxArrayString& strings ) const;

    wxArrayInt GetIndicesForStrings( const wxArrayString& strings, wxArrayString* unmatched = NULL ) const;

    int Index( const wxString& str ) const;
    int Index( int val ) const;

    wxPGChoiceEntry& Insert( const wxString& label, int index, int value = wxPG_INVALID_VALUE );

    wxPGChoiceEntry& Insert( const wxPGChoiceEntry& entry, int index );

    // Returns data, increases refcount.
    wxPGChoicesData* GetData()
    {
        wxASSERT( m_data->m_refCount != 0xFFFFFFF );
        m_data->m_refCount++;
        return m_data;
    }

    // Returns plain data ptr - no refcounting stuff is done.
    wxPGChoicesData* GetDataPtr() const { return m_data; }

    // Changes ownership of data to you.
    wxPGChoicesData* ExtractData()
    {
        wxPGChoicesData* data = m_data;
        m_data = wxPGChoicesEmptyData;
        return data;
    }

    wxArrayString GetLabels() const;

#ifndef SWIG

protected:
    wxPGChoicesData*    m_data;

    void Init();
    void Free();
#endif
};


// -----------------------------------------------------------------------

#ifndef SWIG
  #if wxMINOR_VERSION < 7 || ( wxMINOR_VERSION == 7 && wxRELEASE_NUMBER < 1 )
    // NOTE: Since wxWidgets at this point doesn't have wxArrayDouble, we have
    //   to create it ourself, using wxObjArray model.
    WX_DECLARE_OBJARRAY_WITH_DECL(double, wxArrayDouble, class WXDLLIMPEXP_PG);
  #endif
#endif // !SWIG

// -----------------------------------------------------------------------
// Property declaration.

// Doxygen will only generate warnings here
#define wxPG_CONSTFUNC(PROP) PROP##Create
#define wxPG_PROPCLASS(PROP) PROP

// Macro based constructor.
#define wxPG_NEWPROPERTY(PROP,LABEL,NAME,VALUE) wx##PROP##Property(LABEL,NAME,VALUE)


WXDLLIMPEXP_PG 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)

// -----------------------------------------------------------------------

#define wxPG_IT_CHILDREN(A)         (A<<16)

enum wxPG_ITERATOR_FLAGS
{

wxPG_ITERATE_PROPERTIES             = (wxPG_PROP_PROPERTY|wxPG_PROP_MISC_PARENT|wxPG_PROP_AGGREGATE| \
                                       wxPG_PROP_COLLAPSED|((wxPG_PROP_MISC_PARENT|wxPG_PROP_CATEGORY)<<16)),

wxPG_ITERATE_HIDDEN                 = (wxPG_PROP_HIDDEN|wxPG_IT_CHILDREN(wxPG_PROP_COLLAPSED)),

wxPG_ITERATE_FIXED_CHILDREN         = (wxPG_IT_CHILDREN(wxPG_PROP_AGGREGATE)|wxPG_ITERATE_PROPERTIES),

wxPG_ITERATE_CATEGORIES             = (wxPG_PROP_CATEGORY|wxPG_IT_CHILDREN(wxPG_PROP_CATEGORY)|wxPG_PROP_COLLAPSED),

wxPG_ITERATE_ALL_PARENTS            = (wxPG_PROP_MISC_PARENT|wxPG_PROP_AGGREGATE|wxPG_PROP_CATEGORY),

wxPG_ITERATE_ALL_PARENTS_RECURSIVELY        = (wxPG_ITERATE_ALL_PARENTS|wxPG_IT_CHILDREN(wxPG_ITERATE_ALL_PARENTS)),

wxPG_ITERATOR_FLAGS_ALL             = (wxPG_PROP_PROPERTY|wxPG_PROP_MISC_PARENT|wxPG_PROP_AGGREGATE| \
                                      wxPG_PROP_HIDDEN|wxPG_PROP_CATEGORY|wxPG_PROP_COLLAPSED),

wxPG_ITERATOR_MASK_OP_ITEM          = wxPG_ITERATOR_FLAGS_ALL,

wxPG_ITERATOR_MASK_OP_PARENT        = wxPG_ITERATOR_FLAGS_ALL,  // (wxPG_PROP_MISC_PARENT|wxPG_PROP_AGGREGATE|wxPG_PROP_CATEGORY)

wxPG_ITERATE_VISIBLE                = (wxPG_ITERATE_PROPERTIES|wxPG_PROP_CATEGORY|wxPG_IT_CHILDREN(wxPG_PROP_AGGREGATE)),

wxPG_ITERATE_ALL                    = (wxPG_ITERATE_VISIBLE|wxPG_ITERATE_HIDDEN),

wxPG_ITERATE_NORMAL                 = (wxPG_ITERATE_PROPERTIES|wxPG_ITERATE_HIDDEN),

wxPG_ITERATE_DEFAULT                = wxPG_ITERATE_NORMAL

};

#define wxPG_ITERATOR_CREATE_MASKS(FLAGS, A, B) \
    A = (FLAGS ^ wxPG_ITERATOR_MASK_OP_ITEM) & wxPG_ITERATOR_MASK_OP_ITEM & 0xFFFF; \
    B = ((FLAGS>>16) ^ wxPG_ITERATOR_MASK_OP_PARENT) & wxPG_ITERATOR_MASK_OP_PARENT & 0xFFFF;


// Macro to test if children of PWC should be iterated through
#define wxPG_ITERATOR_PARENTEXMASK_TEST(PWC, PARENTMASK) \
        ( \
        !(PWC->GetFlags() & PARENTMASK) && \
        PWC->GetChildCount() \
        )


class WXDLLIMPEXP_PG wxPropertyGridIteratorBase
{
public:
    wxPropertyGridIteratorBase()
    {
    }

    void Assign( const wxPropertyGridIteratorBase& it );

    bool AtEnd() const { return m_property == NULL; }

    wxPGProperty* GetProperty() const { return m_property; }

    void Init( wxPropertyGridState* state, int flags, wxPGProperty* property, int dir = 1 );

    void Init( wxPropertyGridState* state, int flags, int startPos = wxTOP, int dir = 0 );

    void Next( bool iterateChildren = true );

    void Prev();

    void SetBaseParent( wxPGProperty* baseParent ) { m_baseParent = baseParent; }

protected:

    wxPGProperty*               m_property;

private:
    wxPropertyGridState*        m_state;
    wxPGProperty*               m_baseParent;

    // Masks are used to quickly exclude items
    int                         m_itemExMask;
    int                         m_parentExMask;
};


#define wxPG_IMPLEMENT_ITERATOR(CLASS, PROPERTY, STATE) \
    CLASS( STATE* state, int flags = wxPG_ITERATE_DEFAULT, PROPERTY* property = NULL, int dir = 1 ) \
        : wxPropertyGridIteratorBase() \
        { Init( (wxPropertyGridState*)state, flags, (wxPGProperty*)property, dir ); } \
    CLASS( STATE* state, int flags, int startPos, int dir = 0 ) \
        : wxPropertyGridIteratorBase() \
        { Init( (wxPropertyGridState*)state, flags, startPos, dir ); } \
    CLASS() \
        : wxPropertyGridIteratorBase() \
    { \
        m_property = NULL; \
    } \
    CLASS( const CLASS& it ) \
        : wxPropertyGridIteratorBase( ) \
    { \
        Assign(it); \
    } \
    ~CLASS() \
    { \
    } \
    const CLASS& operator=( const CLASS& it ) \
    { \
        Assign(it); \
        return *this; \
    } \
    CLASS& operator++() { Next(); return *this; } \
    CLASS operator++(int) { CLASS it=*this;Next();return it; } \
    CLASS& operator--() { Prev(); return *this; } \
    CLASS operator--(int) { CLASS it=*this;Prev();return it; } \
    PROPERTY* operator *() const { return (PROPERTY*)m_property; } \
    static PROPERTY* OneStep( STATE* state, int flags = wxPG_ITERATE_DEFAULT, PROPERTY* property = NULL, int dir = 1 ) \
    { \
        CLASS it( state, flags, property, dir ); \
        if ( property ) \
        { \
            if ( dir == 1 ) it.Next(); \
            else it.Prev(); \
        } \
        return *it; \
    }


class WXDLLIMPEXP_PG wxPropertyGridIterator : public wxPropertyGridIteratorBase
{
public:

    wxPG_IMPLEMENT_ITERATOR(wxPropertyGridIterator,
                            wxPGProperty,
                            wxPropertyGridState)

protected:
};


class WXDLLIMPEXP_PG wxPropertyGridConstIterator : public wxPropertyGridIteratorBase
{
public:
    wxPG_IMPLEMENT_ITERATOR(wxPropertyGridConstIterator,
                            const wxPGProperty,
                            const wxPropertyGridState)

    
    wxPropertyGridConstIterator( const wxPropertyGridIterator& other )
    {
        Assign(other);
    }

    const wxPropertyGridConstIterator& operator=( const wxPropertyGridIterator& it )
    {
        Assign(it);
        return *this;
    }

protected:
};

// -----------------------------------------------------------------------

class WXDLLIMPEXP_PG wxPGVIteratorBase
{
    friend class wxPGVIterator;
public:
    wxPGVIteratorBase() { m_refCount = 1; }
    virtual void Next() = 0;
    void IncRef()
    {
        m_refCount++;
    }
    void DecRef()
    {
        m_refCount--;
        if ( m_refCount <= 0 )
            delete this;
    }
protected:
    virtual ~wxPGVIteratorBase() { }

    wxPropertyGridIterator  m_it;
private:
    int     m_refCount;
};

class WXDLLIMPEXP_PG wxPGVIterator
{
public:
    wxPGVIterator() { m_pIt = NULL; }
    wxPGVIterator( wxPGVIteratorBase* obj ) { m_pIt = obj; }
    ~wxPGVIterator() { UnRef(); }
    void UnRef() { if (m_pIt) m_pIt->DecRef(); }
    wxPGVIterator( const wxPGVIterator& it )
    {
        m_pIt = it.m_pIt;
        m_pIt->IncRef();
    }
#ifndef SWIG
    const wxPGVIterator& operator=( const wxPGVIterator& it )
    {
        UnRef();
        m_pIt = it.m_pIt;
        m_pIt->IncRef();
        return *this;
    }
#endif
    void Next() { m_pIt->Next(); }
    bool AtEnd() const { return m_pIt->m_it.AtEnd(); }
    wxPGProperty* GetProperty() const { return m_pIt->m_it.GetProperty(); }
protected:
    wxPGVIteratorBase*  m_pIt;
};

// -----------------------------------------------------------------------

class WXDLLIMPEXP_PG wxPropertyGridHitTestResult
{
    friend class wxPropertyGrid;
public:
    wxPropertyGridHitTestResult()
    {
        property = NULL;
        column = -1;
        splitter = -1;
        splitterHitOffset = 0;
    }

    ~wxPropertyGridHitTestResult()
    {
    }

    int GetColumn() const { return column; }

    wxPGProperty* GetProperty() const
    {
        return property;
    }

    int GetSplitter() const { return splitter; }

    int GetSplitterHitOffset() const { return splitterHitOffset; }

    wxPGProperty*   property;

    int             column;

    int             splitter;

    int             splitterHitOffset;
};

// -----------------------------------------------------------------------

enum wxPG_VALIDATION_FAILURE_BEHAVIOR_FLAGS
{

wxPG_VFB_STAY_IN_PROPERTY           = 0x01,

wxPG_VFB_BEEP                       = 0x02,

wxPG_VFB_MARK_CELL                  = 0x04,

wxPG_VFB_SHOW_MESSAGE               = 0x08,

wxPG_VFB_DEFAULT                    = wxPG_VFB_STAY_IN_PROPERTY|wxPG_VFB_BEEP,

wxPG_VFB_UNDEFINED                  = 0x80

};

typedef wxByte wxPGVFBFlags;

struct wxPGValidationInfo
{
    wxVariant*      m_pValue;

    wxString        m_failureMessage;

    wxPGVFBFlags    m_failureBehavior;

    wxPGVFBFlags GetFailureBehavior() const { return m_failureBehavior; }

    void SetFailureBehavior(wxPGVFBFlags failureBehavior) { m_failureBehavior = failureBehavior; }

    const wxString& GetFailureMessage() const { return m_failureMessage; }

    void SetFailureMessage(const wxString& message) { m_failureMessage = message; }
};

// -----------------------------------------------------------------------

enum wxPG_KEYBOARD_ACTIONS
{
    wxPG_ACTION_INVALID = 0,
    wxPG_ACTION_NEXT_PROPERTY,
    wxPG_ACTION_PREV_PROPERTY,
    wxPG_ACTION_EXPAND_PROPERTY,
    wxPG_ACTION_COLLAPSE_PROPERTY,
    wxPG_ACTION_CANCEL_EDIT,
    wxPG_ACTION_CUT,
    wxPG_ACTION_COPY,
    wxPG_ACTION_PASTE,
    wxPG_ACTION_SELECT_ALL,
    wxPG_ACTION_MAX
};

#ifndef SWIG
// We won't need this class from wxPython

// BM_STATE
class WXDLLIMPEXP_PG wxPropertyGridState
{
    friend class wxPGProperty;
    friend class wxPropertyGrid;
    friend class wxPGCanvas;
    friend class wxPropertyGridPage;
    friend class wxPropertyGridManager;
    friend class wxPropertyGridInterface;
public:

    wxPropertyGridState();

    virtual ~wxPropertyGridState();

    wxPGProperty* DoAppend( wxPGProperty* property );

    wxPGProperty* BaseGetPropertyByName( wxPGPropNameStr name ) const;

    void DoClear();

    bool DoIsPropertySelected( wxPGProperty* prop ) const;

    void ClearModifiedStatus( wxPGProperty* p );

    bool DoClearSelection()
    {
        return DoSelectProperty(NULL);
    }

    void DoRemoveFromSelection( wxPGProperty* prop );

    bool DoCollapse( wxPGProperty* p );

    bool DoExpand( wxPGProperty* p );

        void CalculateFontAndBitmapStuff( int vspacing );

    void CheckColumnWidths( int widthChange = 0 );

    virtual void DoDelete( wxPGProperty* item, bool doDelete = true );

    wxSize DoFitColumns( bool allowGridResize = false );

    wxPGProperty* DoGetItemAtY( int y ) const;

    virtual wxPGProperty* DoInsert( wxPGProperty* parent, int index, wxPGProperty* property );

    virtual void DoSetSplitterPosition( int pos, int splitterColumn = 0, bool allPages = false, bool fromAutoCenter = false );

    bool EnableCategories( bool enable );

    void EnsureVirtualHeight()
    {
        if ( m_vhCalcPending )
        {
            RecalculateVirtualHeight();
            m_vhCalcPending = 0;
        }
    }

    bool DoEnableProperty( wxPGProperty* p, bool enable );

    unsigned int GetVirtualHeight() const
    {
        wxASSERT( !m_vhCalcPending );
        return m_virtualHeight;
    }

    unsigned int GetVirtualHeight()
    {
        EnsureVirtualHeight();
        return m_virtualHeight;
    }

    inline unsigned int GetActualVirtualHeight() const;

    unsigned int GetColumnCount() const
    {
        return (unsigned int) m_colWidths.size();
    }

    int GetColumnMinWidth( int column ) const;

    int GetColumnWidth( unsigned int column ) const
    {
        return m_colWidths[column];
    }

    wxPropertyGrid* GetGrid() const { return m_pPropGrid; }

    wxPGProperty* GetLastItem( int flags = wxPG_ITERATE_DEFAULT );

    const wxPGProperty* GetLastItem( int flags = wxPG_ITERATE_DEFAULT ) const
    {
        return ((wxPropertyGridState*)this)->GetLastItem(flags);
    }

#if wxPG_COMPATIBILITY_1_2_0
    wxPGProperty* GetNextCategory( wxPGProperty* id ) const;

    wxPGProperty* GetNextProperty( wxPGProperty* id );

    wxPGProperty* GetNextSiblingProperty( wxPGProperty* id );

    wxPGProperty* GetPrevSiblingProperty( wxPGProperty* id );

    wxPGProperty* GetPrevProperty( wxPGProperty* id );
#endif // wxPG_COMPATIBILITY_1_2_0

    wxPropertyCategory* GetPropertyCategory( const wxPGProperty* p ) const;

    wxPGProperty* GetPropertyByLabel( const wxString& name, wxPGProperty* parent = NULL ) const;

    wxVariant DoGetPropertyValues( const wxString& listname, wxPGProperty* baseparent, long flags ) const;

    wxPGProperty* DoGetRoot() const { return m_properties; }

    // Returns combined width of margin and all the columns
    int GetVirtualWidth() const
    {
        return m_width;
    }

    int GetColumnFitWidth(wxClientDC& dc, wxPGProperty* pwc, unsigned int col, bool subProps) const;

    wxPGProperty* GetSelection() const
    {
        if ( m_selection.size() == 0 )
            return NULL;
        return m_selection[0];
    }

    void DoSetSelection( wxPGProperty* prop )
    {
        m_selection.clear();
        if ( prop )
            m_selection.push_back(prop);
    }

    wxPropertyGridHitTestResult HitTest( const wxPoint& pt ) const;

    inline bool IsDisplayed() const;

    bool IsInNonCatMode() const { return (bool)(m_properties == m_abcArray); }

    void InitNonCatMode ();

    void DoLimitPropertyEditing( wxPGProperty* p, bool limit = true )
    {
        p->SetFlagRecursively(wxPG_PROP_NOEDITOR, limit);
    }

    bool DoSelectProperty( wxPGProperty* p, unsigned int flags = 0 );

    void OnClientWidthChange( int newWidth, int widthChange, bool fromOnResize = false );

    void RecalculateVirtualHeight()
    {
        m_virtualHeight = GetActualVirtualHeight();
    }

    void SetColumnCount( int colCount );

    void PropagateColSizeDec( int column, int decrease, int dir );

    bool DoHideProperty( wxPGProperty* p, bool hide, int flags = wxPG_RECURSE );

    bool DoSetPropertyValueString( wxPGProperty* p, const wxString& value );

    bool DoSetPropertyValue( wxPGProperty* p, wxVariant& value );

    bool DoSetPropertyValueWxObjectPtr( wxPGProperty* p, wxObject* value );
    void DoSetPropertyValues( const wxVariantList& list, wxPGProperty* default_category );

#ifdef wxPG_COMPATIBILITY_1_2_0
    #define SetPropertyUnspecified SetPropertyValueUnspecified
#endif

    void SetSplitterLeft( bool subProps = false );

    void SetVirtualWidth( int width );

    void Sort( wxPGProperty* p );
    void Sort();

    void VirtualHeightChanged()
    {
        m_vhCalcPending = 1;
    }

protected:

    // Utility to check if two properties are visibly next to each other
    bool ArePropertiesAdjacent( wxPGProperty* prop1,
                                wxPGProperty* prop2,
                                int iterFlags = wxPG_ITERATE_VISIBLE ) const;

    int DoGetSplitterPosition( int splitterIndex = 0 ) const;

    int HitTestH( int x, int* pSplitterHit, int* pSplitterHitOffset ) const;

#ifndef DOXYGEN
    int PrepareToAddItem ( wxPGProperty* property, wxPGProperty* scheduledParent );

    wxPropertyGrid*             m_pPropGrid;

    wxPGProperty*               m_properties;

    wxPGRootProperty            m_regularArray;

    wxPGRootProperty*           m_abcArray;

    wxPGHashMapS2P              m_dictName;

    wxArrayInt                  m_colWidths;

    wxArrayInt                  m_editableColumns;

    double                      m_fSplitterX;

    wxPropertyCategory*         m_currentCategory;

    wxArrayPGProperty           m_selection;

    int                         m_width;

    unsigned int                m_virtualHeight;

    unsigned char               m_lastCaptionBottomnest;

    unsigned char               m_itemsAdded;

    unsigned char               m_anyModified;

    unsigned char               m_vhCalcPending;

#endif // #ifndef DOXYGEN

};

#endif // #ifndef SWIG

inline bool wxPGProperty::SetChoices( const wxArrayString& labels,
                                      const wxArrayInt& values )
{
    wxPGChoices chs(labels,values);
    return SetChoices(chs);
}

// -----------------------------------------------------------------------

// GetPropertyName version used internally. Use GetPropertyName for slight speed advantage,
// or GetPropertyNameA for nice assertion (essential for wxPython bindings).
#define GetPropertyByNameI          GetPropertyByNameA

// FOR BACKWARDS COMPATIBILITY
#define GetPropertyByNameWithAssert GetPropertyByNameA


// 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)


class WXDLLIMPEXP_PG wxPropertyGridInterface
// BM_METHODS
{
    friend class wxPropertyGrid;
    friend class wxPropertyGridManager;
public:

    virtual ~wxPropertyGridInterface() { };

    void AddPropertyChoice( wxPGPropArg id, const wxString& label, int value = wxPG_INVALID_VALUE );

    wxPGProperty* Append( wxPGProperty* property );

#if wxPG_COMPATIBILITY_1_2_0
    wxDEPRECATED( wxPGProperty* AppendCategory( const wxString& label, const wxString& name = wxPG_LABEL ) );
#endif

    wxPGProperty* AppendIn( wxPGPropArg id, wxPGProperty* newproperty );

    void BeginAddChildren( wxPGPropArg id );

    void EndAddChildren( wxPGPropArg id );

    void InsertPropertyChoice( wxPGPropArg id, const wxString& label, int index, int value = wxPG_INVALID_VALUE );

    virtual void Clear() = 0;

    bool ClearSelection( bool validation = true );

    bool Collapse( wxPGPropArg id );

    bool CollapseAll() { return ExpandAll(false); }

    void DeletePropertyChoice( wxPGPropArg id, int index );

    bool ChangePropertyValue( wxPGPropArg id, wxVariant newValue );

    bool ClearPropertyValue( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
        p->SetValue(p->GetDefaultValue());
        return true;
    }

    static wxPGProperty* CreatePropertyByClass(const wxString &classname,
                                               const wxString &label,
                                               const wxString &name);

    static wxPGProperty* CreatePropertyByType(const wxString &valuetype,
                                              const wxString &label,
                                              const wxString &name);

    void DeleteProperty( wxPGPropArg id );

    wxPGProperty* RemoveProperty( wxPGPropArg id );

#if wxPG_COMPATIBILITY_1_2_0

    wxDEPRECATED( void Delete( wxPGPropArg id ) );
#endif

#if wxPG_COMPATIBILITY_1_2_0

    wxDEPRECATED( bool Disable( wxPGPropArg id ) );
#endif

    bool DisableProperty( wxPGPropArg id ) { return EnableProperty(id,false); }

    bool EnableProperty( wxPGPropArg id, bool enable = true );

    bool Expand( wxPGPropArg id );

    bool ExpandAll( bool expand = true );

    wxArrayPGProperty GetExpandedProperties() const
    {
        wxArrayPGProperty array;
        GetPropertiesWithFlag(&array, wxPG_PROP_COLLAPSED, true,
            wxPG_ITERATE_ALL_PARENTS_RECURSIVELY|wxPG_ITERATE_HIDDEN);
        return array;
    }

    wxPGProperty* GetFirstChild( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)

        if ( !p->GetChildCount() || p->IsFlagSet(wxPG_PROP_AGGREGATE) )
            return wxNullProperty;

        return p->Item(0);
    }

    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 );
    }

    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 );
    }

    virtual wxPGVIterator GetVIterator( int flags ) const;

    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 ((wxPropertyGridInterface*)this)->GetFirst(flags);
    }

#if wxPG_COMPATIBILITY_1_2_0

    wxPGProperty* GetNextSiblingProperty( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
        return m_pState->GetNextSiblingProperty(p);
    }
#endif

    const wxPGAttributeStorage& GetPropertyAttributes( wxPGPropArg id ) const
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(*((const wxPGAttributeStorage*)NULL));
        return p->GetAttributes();
    }

    void SetPropertyAttributes( wxPGPropArg id, const wxPGAttributeStorage& attributes )
    {
        wxPG_PROP_ARG_CALL_PROLOG()
        p->SetAttributes(attributes);
    }

    void GetPropertiesWithFlag( wxArrayPGProperty* targetArr,
                                wxPGProperty::FlagType flags,
                                bool inverse = false,
                                int iterFlags = (wxPG_ITERATE_PROPERTIES|wxPG_ITERATE_HIDDEN|wxPG_ITERATE_CATEGORIES) ) const;

    wxVariant GetPropertyAttribute( wxPGPropArg id, const wxString& attrName ) const
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullVariant)
        return p->GetAttribute(attrName);
    }

    wxPGProperty* GetProperty( wxPGPropNameStr name ) const
    {
        return GetPropertyByName(name);
    }

    wxPGProperty* GetPropertyByName( wxPGPropNameStr name ) const;

    wxPGProperty* GetPropertyByName( wxPGPropNameStr name, wxPGPropNameStr subname ) const;

    wxPGChoices& GetPropertyChoices( wxPGPropArg id );

    wxPG_CONST_WXCHAR_PTR GetPropertyClassName( wxPGPropArg id ) const
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxPG_CONST_WXCHAR_DEFVAL)
        return p->GetClassName();
    }

    wxPGProperty::ClientDataType GetPropertyClientData( wxPGPropArg id ) const
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
        return p->GetClientData();
    }
    const wxPGEditor* GetPropertyEditor( wxPGPropArg id ) const
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
        return p->GetEditorClass();
    }

    wxBitmap* GetPropertyImage( wxPGPropArg id ) const
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
        return p->GetValueImage();
    }

    unsigned int GetPropertyIndex( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(INT_MAX)
        return p->GetIndexInParent();
    }

    const wxString& GetPropertyLabel( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(m_emptyString)
        return p->GetLabel();
    }
    wxString GetPropertyName( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(m_emptyString)
        return p->GetName();
    }

    wxPGProperty* GetPropertyParent( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
        return p->GetParent();
    }

#if wxPG_COMPATIBILITY_1_2_0

    wxPGProperty* GetPropertyPtr( wxPGPropArg id ) const
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
        return p;
    }
#endif

    wxString GetPropertyHelpString( wxPGPropArg id ) const
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(m_emptyString)
        return p->GetHelpString();
    }

    wxString GetPropertyShortClassName( wxPGPropArg id );

#if wxUSE_VALIDATORS

    wxValidator* GetPropertyValidator( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
        return p->GetValidator();
    }
#endif

#ifndef SWIG

    wxVariant GetPropertyValue( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxVariant())
        return p->GetValue();
    }
#endif

    wxString GetPropertyValueAsString( wxPGPropArg id ) const;
    long GetPropertyValueAsLong( wxPGPropArg id ) const;
    unsigned long GetPropertyValueAsULong( wxPGPropArg id ) const
    {
        return (unsigned long) GetPropertyValueAsLong(id);
    }
#ifndef SWIG
    int GetPropertyValueAsInt( wxPGPropArg id ) const { return (int)GetPropertyValueAsLong(id); }
#endif
    bool GetPropertyValueAsBool( wxPGPropArg id ) const;
    double GetPropertyValueAsDouble( wxPGPropArg id ) const;
    wxObject* GetPropertyValueAsWxObjectPtr( wxPGPropArg id ) const;
    void* GetPropertyValueAsVoidPtr( wxPGPropArg id ) const;

#define wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(TYPENAME, DEFVAL) \
    wxPG_PROP_ARG_CALL_PROLOG_RETVAL(DEFVAL) \
    if ( p->m_value.GetType() != TYPENAME ) \
    { \
        wxPGGetFailed(p,TYPENAME); \
        return DEFVAL; \
    }

#define wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL_WFALLBACK(TYPENAME, DEFVAL) \
    wxPG_PROP_ARG_CALL_PROLOG_RETVAL(DEFVAL) \
    if ( p->m_value.GetType() != TYPENAME ) \
        return DEFVAL; \

    wxArrayString GetPropertyValueAsArrayString( wxPGPropArg id ) const
    {
        wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(wxT("arrstring"), wxArrayString())
        return p->m_value.GetArrayString();
    }

    wxPoint GetPropertyValueAsPoint( wxPGPropArg id ) const
    {
        wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(wxT("wxPoint"), wxPoint())
        return WX_PG_VARIANT_GETVALUEREF(p->GetValue(), wxPoint);
    }

    wxSize GetPropertyValueAsSize( wxPGPropArg id ) const
    {
        wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(wxT("wxSize"), wxSize())
        return WX_PG_VARIANT_GETVALUEREF(p->GetValue(), wxSize);
    }

    wxLongLong_t GetPropertyValueAsLongLong( wxPGPropArg id ) const
    {
        wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL_WFALLBACK(wxT("wxLongLong"), (long) GetPropertyValueAsLong(id))
        return WX_PG_VARIANT_GETVALUEREF(p->GetValue(), wxLongLong).GetValue();
    }

    wxULongLong_t GetPropertyValueAsULongLong( wxPGPropArg id ) const
    {
        wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL_WFALLBACK(wxT("wxULongLong"), (unsigned long) GetPropertyValueAsULong(id))
        return WX_PG_VARIANT_GETVALUEREF(p->GetValue(), wxULongLong).GetValue();
    }

    wxArrayInt GetPropertyValueAsArrayInt( wxPGPropArg id ) const
    {
        wxPG_PROP_ID_GETPROPVAL_CALL_PROLOG_RETVAL(wxT("wxArrayInt"), wxArrayInt())
        wxArrayInt arr = WX_PG_VARIANT_GETVALUEREF(p->GetValue(), wxArrayInt);
        return arr;
    }

#if wxUSE_DATETIME
    wxDateTime GetPropertyValueAsDateTime( wxPGPropArg id ) const
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxDateTime())

        if ( wxStrcmp(p->m_value.GetType(),wxT("datetime")) != 0 )
        {
            wxPGGetFailed(p,wxT("datetime"));
            return wxDateTime();
        }
        return p->m_value.GetDateTime();
    }
#endif

#if defined(SWIG) || defined(__WXPYTHON__)

    PyObject* GetPropertyValueAsPyObject( wxPGPropArg id ) const;
#endif

#ifndef SWIG

    wxVariant GetPropertyValues( const wxString& listname = wxEmptyString,
        wxPGProperty* baseparent = NULL, long flags = 0 ) const
    {
        return m_pState->DoGetPropertyValues(listname, baseparent, flags);
    }
#endif

    wxString GetPropertyValueType( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(m_emptyString)
        return p->GetType();
    }

#ifdef __WXPYTHON__
    ptrdiff_t GetPVTI( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(1)
        //wxLogDebug(wxT("GetPVTI(%s)"),p->GetLabel().c_str());
        wxVariant v = p->GetValue();
        wxVariantData* data = v.GetData();
        if ( !data )
            return 0;
        return (ptrdiff_t)wxPGVariantDataGetClassInfo(data);
    }
#endif

    wxPGProperty* GetSelection() const;

    const wxArrayPGProperty& GetSelectedProperties() const
    {
        return m_pState->m_selection;
    }

#ifndef SWIG
    wxPropertyGridState* GetState() const { return m_pState; }
#endif

    bool HideProperty( wxPGPropArg id, bool hide = true, int flags = wxPG_RECURSE );

#if wxPG_INCLUDE_ADVPROPS

    static void RegisterAdditionalEditors();
#else
    static void RegisterAdditionalEditors() { }
#endif

#if wxPG_INCLUDE_ADVPROPS

    static void InitAllTypeHandlers();
#else
    static void InitAllTypeHandlers() { }
#endif

    wxPGProperty* Insert( wxPGPropArg priorThis, wxPGProperty* newproperty );

    wxPGProperty* Insert( wxPGPropArg parent, int index, wxPGProperty* newproperty );

#if wxPG_COMPATIBILITY_1_2_0
    wxPGProperty* InsertCategory( wxPGPropArg id, int index, const wxString& label, const wxString& name = wxPG_LABEL )
    {
        return Insert( id, index, new wxPropertyCategory(label,name) );
    }
#endif

    bool IsPropertyEnabled( wxPGPropArg id ) const
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
        return (!(p->GetFlags() & wxPG_PROP_DISABLED))?true:false;
    }

    virtual bool IsPropertySelected( wxPGPropArg id ) const;

    bool IsPropertyShown( wxPGPropArg id ) const
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
        return (!(p->GetFlags() & wxPG_PROP_HIDDEN))?true:false;
    }

#if wxPG_COMPATIBILITY_1_2_0

    wxDEPRECATED( bool IsPropertyValueType( wxPGPropArg id, const wxChar* typestr ) const );
#endif

    bool IsPropertyExpanded( wxPGPropArg id ) const;

    bool IsPropertyKindOf( wxPGPropArg id, wxClassInfo* info ) const
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
        return p->IsKindOf(info);
    }

#if wxPG_COMPATIBILITY_1_2_0

    wxDEPRECATED( bool IsModified( wxPGPropArg id ) const );
#endif

    bool IsPropertyCategory( wxPGPropArg id ) const
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
        return p->IsCategory();
    }

    bool IsPropertyModified( wxPGPropArg id ) const
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
        return ( (p->GetFlags() & wxPG_PROP_MODIFIED) ? true : false );
    }

#ifdef wxPG_COMPATIBILITY_1_0_0
    bool IsPropertyValueUnspecified( wxPGPropArg id ) const
#else
    bool IsPropertyUnspecified( wxPGPropArg id ) const
#endif
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
        return p->IsValueUnspecified();
    }

    void LimitPropertyEditing( wxPGPropArg id, bool limit = true );

    void PropertiesToNames( wxArrayString* names, const wxArrayPGProperty& properties ) const;

    void NamesToProperties( wxArrayPGProperty* properties, const wxArrayString& names ) const;

    virtual void RefreshGrid( wxPropertyGridState* state = NULL );

    wxPGProperty* ReplaceProperty( wxPGPropArg id, wxPGProperty* property );

    enum EditableStateFlags
    {
        SelectionState   = 0x01,
        ExpandedState    = 0x02,
        ScrollPosState   = 0x04,
        PageState        = 0x08,
        SplitterPosState = 0x10,
        DescBoxState     = 0x20,

        AllStates        = SelectionState |
                           ExpandedState |
                           ScrollPosState |
                           PageState |
                           SplitterPosState |
                           DescBoxState
    };

    bool RestoreEditableState( const wxString& src,
                               int restoreStates = AllStates );

    wxString SaveEditableState( int includedStates = AllStates ) const;

    static void SetBoolChoices( const wxString& true_choice, const wxString& false_choice );

    void SetExpandedProperties( const wxArrayPGProperty& array, bool expand = true )
    {
        SetPropertiesFlag(array, wxPG_PROP_COLLAPSED, expand);
    }

    void SetPropertiesFlag( const wxArrayPGProperty& srcArr, wxPGProperty::FlagType flags,
                            bool inverse = false );

    void SetPropertyCell( wxPGPropArg id,
                          int column,
                          const wxString& text = wxEmptyString,
                          const wxBitmap& bitmap = wxNullBitmap,
                          const wxColour& fgCol = wxNullColour,
                          const wxColour& bgCol = wxNullColour )
    {
        wxPG_PROP_ARG_CALL_PROLOG()
        p->SetCell( column, new wxPGCell(text, bitmap, fgCol, bgCol) );
    }

    void SetPropertyChoices( wxPGPropArg id, wxPGChoices& choices)
    {
        wxPG_PROP_ARG_CALL_PROLOG()
        p->SetChoices(choices);
    }


    void SetPropertyChoicesExclusive( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG()
        p->SetChoicesExclusive();
    }

    void SetPropertyAttribute( wxPGPropArg id, const wxString& attrName, wxVariant value, long argFlags = 0 )
    {
        DoSetPropertyAttribute(id,attrName,value,argFlags);
    }

#ifndef SWIG

    void SetPropertyEditor( wxPGPropArg id, const wxPGEditor* editor )
    {
        wxPG_PROP_ARG_CALL_PROLOG()
        wxCHECK_RET( editor, wxT("unknown/NULL editor") );
        p->SetEditor(editor);
        RefreshProperty(p);
    }
#endif // #ifndef SWIG

    void SetPropertyEditor( wxPGPropArg id, const wxString& editorName )
    {
        SetPropertyEditor(id,GetEditorByName(editorName));
    }

    void SetPropertyLabel( wxPGPropArg id, const wxString& newproplabel );

    void SetPropertyClientData( wxPGPropArg id, wxPGProperty::ClientDataType clientData )
    {
        wxPG_PROP_ARG_CALL_PROLOG()
        p->SetClientData(clientData);
    }

    void SetPropertyValueUnspecified( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG()
        wxVariant nullVariant;
        SetPropVal(p, nullVariant);
    }

    void SetPropertyReadOnly( wxPGPropArg id, bool set = true, int flags = wxPG_RECURSE )
    {
        wxPG_PROP_ARG_CALL_PROLOG()
        if ( flags & wxPG_RECURSE )
            p->SetFlagRecursively(wxPG_PROP_READONLY, set);
        else
            p->ChangeFlag(wxPG_PROP_READONLY, set);
    }

#ifndef SWIG

    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);
    }

    void SetPropertyValues( const wxVariant& list,
                                                        wxPGPropArg defaultCategory = wxNullProperty )
    {
        SetPropertyValues(list.GetList(),defaultCategory);
    }
#endif

    wxPropertyCategory* GetPropertyCategory( wxPGPropArg id ) const
    {
        wxPG_PROP_ID_CONST_CALL_PROLOG_RETVAL(NULL)
        return m_pState->GetPropertyCategory(p);
    }

    void SetPropertyHelpString( wxPGPropArg id, const wxString& helpString )
    {
        wxPG_PROP_ARG_CALL_PROLOG()
        p->SetHelpString(helpString);
    }

    void SetPropertyImage( wxPGPropArg id, wxBitmap& bmp )
    {
        wxPG_PROP_ARG_CALL_PROLOG()
        p->SetValueImage(bmp);
        RefreshProperty(p);
    }

    bool SetPropertyMaxLength( wxPGPropArg id, int maxLen );

#if wxUSE_VALIDATORS

    void SetPropertyValidator( wxPGPropArg id, const wxValidator& validator )
    {
        wxPG_PROP_ARG_CALL_PROLOG()
        p->SetValidator(validator);
    }
#endif

    void SetPropertyValueLong( wxPGPropArg id, long value )
    {
        wxVariant v(value);
        SetPropVal( id, v );
    }

#ifndef __WXPYTHON__

    void SetPropertyValue( wxPGPropArg id, int value )
    {
        wxVariant v((long)value);
        SetPropVal( id, v );
    }
#endif

    void SetPropertyValueDouble( wxPGPropArg id, double value )
    {
        wxVariant v(value);
        SetPropVal( id, v );
    }
    void SetPropertyValueBool( wxPGPropArg id, bool value )
    {
        wxVariant v(value);
        SetPropVal( id, v );
    }
#ifndef __WXPYTHON__
    void SetPropertyValue( wxPGPropArg id, const wxChar* value )
    {
        SetPropertyValueString( id, wxString(value) );
    }
#endif

    void SetPropertyValueArrstr2( wxPGPropArg id, const wxArrayString& value )
    {
        wxVariant v(value);
        SetPropVal( id, v );
    }


#if wxUSE_DATETIME
    void SetPropertyValueDatetime( wxPGPropArg id, const wxDateTime& value )
    {
        wxVariant v(value);
        SetPropVal( id, v );
    }
#endif

    void SetPropertyValueString( wxPGPropArg id, const wxString& value );

    void SetPropertyValueWxObjectPtr( wxPGPropArg id, wxObject* value )
    {
        wxVariant v(value);
        SetPropVal( id, v );
    }

#ifndef __WXPYTHON__

    void SetPropertyValue( wxPGPropArg id, void* value )
    {
        wxVariant v(value);
        SetPropVal( id, v );
    }
    void SetPropertyValue ( wxPGPropArg id, wxObject& value )
    {
        wxVariant v(&value);
        SetPropVal( id, v );
    }

    void SetPropertyValue( wxPGPropArg id, wxVariant value )
    {
        SetPropVal( id, value );
    }
#endif

    void SetPropertyValuePoint( wxPGPropArg id, const wxPoint& value )
    {
        wxVariant v = WXVARIANT(value);
        SetPropVal( id, v );
    }
    void SetPropertyValueSize( wxPGPropArg id, const wxSize& value )
    {
        wxVariant v = WXVARIANT(value);
        SetPropVal( id, v );
    }
    void SetPropertyValueLongLong( wxPGPropArg id, wxLongLong_t value )
    {
        wxVariant v = WXVARIANT(wxLongLong(value));
        SetPropVal( id, v );
    }
    void SetPropertyValueULongLong( wxPGPropArg id, wxULongLong_t value )
    {
        wxVariant v = WXVARIANT(wxULongLong(value));
        SetPropVal( id, v );
    }
    void SetPropertyValueArrint2( wxPGPropArg id, const wxArrayInt& value )
    {
        wxVariant v = WXVARIANT(value);
        SetPropVal( id, v );
    }
#ifdef __WXPYTHON__
    void SetPropertyValuePyObject( wxPGPropArg id, PyObject* value )
    {
        wxVariant v = WXVARIANT(value);
        SetPropVal( id, v );
    }
#endif

#ifndef SWIG

    void SetPropVal( wxPGPropArg id, wxVariant& value );
#endif

    void SetValidationFailureBehavior( int vfbFlags );

#ifdef SWIG
    %pythoncode {
        def MapType(class_,factory):
            "Registers Python type/class to property mapping.\n\nfactory: Property builder function/class."
            global _type2property
            try:
                mappings = _type2property
            except NameError:
                raise AssertionError("call only after a propertygrid or manager instance constructed")

            mappings[class_] = factory


        def DoDefaultTypeMappings(self):
            "Map built-in properties."
            global _type2property
            try:
                mappings = _type2property

                return
            except NameError:
                mappings = {}
                _type2property = mappings

            mappings[str] = StringProperty
            mappings[unicode] = StringProperty
            mappings[int] = IntProperty
            mappings[float] = FloatProperty
            mappings[bool] = BoolProperty
            mappings[list] = ArrayStringProperty
            mappings[tuple] = ArrayStringProperty
            mappings[wx.Font] = FontProperty
            mappings[wx.Colour] = ColourProperty
            mappings[wx.Size] = SizeProperty
            mappings[wx.Point] = PointProperty
            mappings[wx.FontData] = FontDataProperty


        def GetPropertyValue(self,p):
            "Returns Python object value for property.\n\nCaches getters on value type id basis for performance purposes."
            global _vt2getter
            vtid = self.GetPVTI(p)
            if not vtid:
                return None
            if vtid == 1:
                raise TypeError("Property '%s' doesn't have valid value type"%(p.GetName()))
            try:
                getter = _vt2getter[vtid]
            except KeyError:

                cls = PropertyGridInterface
                vtn = self.GetPropertyValueType(p)

                if vtn == 'long':
                    getter = cls.GetPropertyValueAsLong
                elif vtn == 'string':
                    getter = cls.GetPropertyValueAsString
                elif vtn == 'double':
                    getter = cls.GetPropertyValueAsDouble
                elif vtn == 'bool':
                    getter = cls.GetPropertyValueAsBool
                elif vtn == 'arrstring':
                    getter = cls.GetPropertyValueAsArrayString
                elif vtn == 'wxArrayInt':
                    getter = cls.GetPropertyValueAsArrayInt
                elif vtn == 'PyObject*':
                    getter = cls.GetPropertyValueAsPyObject
                elif vtn == 'datetime':
                    getter = cls.GetPropertyValueAsDateTime
                elif vtn == 'wxPoint':
                    getter = cls.GetPropertyValueAsPoint
                elif vtn == 'wxSize':
                    getter = cls.GetPropertyValueAsSize
                elif vtn.startswith('wx'):
                    getter = cls.GetPropertyValueAsWxObjectPtr
                elif vtn == 'null':
                    return None
                elif not vtn:
                    if p:
                        raise ValueError("no property with name '%s'"%p)
                    else:
                        raise ValueError("NULL property")
                else:
                    raise AssertionError("Unregistered property grid value type '%s'"%vtn)
                _vt2getter[vtid] = getter
            return getter(self,p)


        def SetPropertyValueArrstr(self,p,v):
            "NB: We must implement this in Python because SWIG has problems combining"
            "    conversion of list to wxArrayXXX and overloaded arguments."
            if not isinstance(p,basestring):
                self._SetPropertyValueArrstr(p,v)
            else:
                self._SetPropertyValueArrstr(self.GetPropertyByNameI(p),v)


        def SetPropertyValueArrint(self,p,v):
            "NB: We must implement this in Python because SWIG has problems combining"
            "    conversion of list to wxArrayXXX and overloaded arguments."
            if not isinstance(p,basestring):
                self._SetPropertyValueArrint(p,v)
            else:
                self._SetPropertyValueArrint(self.GetPropertyByNameI(p),v)


        def DoDefaultValueTypeMappings(self):
            "Map pg value type ids to getter methods."
            global _vt2getter
            try:
                vt2getter = _vt2getter

                return
            except NameError:
                vt2getter = {}
                _vt2getter = vt2getter


        def _GetValues(self,parent,fc,dict_,getter,inc_attributes):
            p = fc

            while p:
                pfc = self.GetFirstChild(p)
                if pfc:
                    self._GetValues(p,pfc,dict_,getter,inc_attributes)
                else:
                    dict_[p.GetName()] = getter(p)

                if inc_attributes:
                    attrs = p.GetAttributes()
                    if attrs and len(attrs):
                        dict_['@%s@attr'%(p.GetName())] = attrs

                p = self.GetNextSiblingProperty(p)


        def GetPropertyValues(self,dict_=None, as_strings=False, inc_attributes=False):
            "Returns values in the grid."
            ""
            "dict_: if not given, then a new one is created. dict_ can be"
            "  object as well, in which case it's __dict__ is used."
            "as_strings: if True, then string representations of values"
            "  are fetched instead of native types. Useful for config and such."
            "inc_attributes: if True, then property attributes are added"
            "  as @<propname>@<attr>."
            ""
            "Return value: dictionary with values. It is always a dictionary,"
            "so if dict_ was object with __dict__ attribute, then that attribute"
            "is returned."

            if dict_ is None:
                dict_ = {}
            elif hasattr(dict_,'__dict__'):
                dict_ = dict_.__dict__

            if not as_strings:
                getter = self.GetPropertyValue
            else:
                getter = self.GetPropertyValueAsString

            root = self.GetGrid().GetRoot()
            self._GetValues(root,self.GetFirstChild(root),dict_,getter,inc_attributes)

            return dict_

        GetValues = GetPropertyValues


        def SetPropertyValues(self,dict_):
            "Sets property values from dict_, which can be either\ndictionary or an object with __dict__ attribute."
            ""
            "autofill: If true, keys with not relevant properties"
            "  are auto-created. For more info, see AutoFill."
            ""
            "Notes:"
            "  * Keys starting with underscore are ignored."
            "  * Attributes can be set with entries named @<propname>@<attr>."
            ""

            autofill = False

            if dict_ is None:
                dict_ = {}
            elif hasattr(dict_,'__dict__'):
                dict_ = dict_.__dict__

            attr_dicts = []

            def set_sub_obj(k0,dict_):
                for k,v in dict_.iteritems():
                    if k[0] != '_':
                        if k.endswith('@attr'):
                            attr_dicts.append((k[1:-5],v))
                        else:
                            try:
                                self.SetPropertyValue(k,v)
                            except:
                                try:
                                    if autofill:
                                        self._AutoFillOne(k0,k,v)
                                        continue
                                except:
                                    if isinstance(v,dict):
                                        set_sub_obj(k,v)
                                    elif hasattr(v,'__dict__'):
                                        set_sub_obj(k,v.__dict__)


            for k,v in attr_dicts:
                p = GetPropertyByName(k)
                if not p:
                    raise AssertionError("No such property: '%s'"%k)
                for an,av in v.iteritems():
                    p.SetAttribute(an, av)


            cur_page = False
            is_manager = isinstance(self,PropertyGridManager)

            try:
                set_sub_obj(self.GetGrid().GetRoot(),dict_)
            except:
                import traceback
                traceback.print_exc()

            self.Refresh()


        SetValues = SetPropertyValues


        def _AutoFillMany(self,cat,dict_):
            for k,v in dict_.iteritems():
                self._AutoFillOne(cat,k,v)


        def _AutoFillOne(self,cat,k,v):
            global _type2property

            factory = _type2property.get(v.__class__,None)

            if factory:
                self.AppendIn( cat, factory(k,k,v) )
            elif hasattr(v,'__dict__'):
                cat2 = self.AppendIn( cat, PropertyCategory(k) )
                self._AutoFillMany(cat2,v.__dict__)
            elif isinstance(v,dict):
                cat2 = self.AppendIn( cat, PropertyCategory(k) )
                self._AutoFillMany(cat2,v)
            elif not k.startswith('_'):
                raise AssertionError("member '%s' is of unregisted type/class '%s'"%(k,v.__class__))


        def AutoFill(self,obj,parent=None):
            "Clears properties and re-fills to match members and\nvalues of given object or dictionary obj."

            self.edited_objects[parent] = obj

            cur_page = False
            is_manager = isinstance(self,PropertyGridManager)

            if not parent:
                if is_manager:
                    page = self.GetCurrentPage()
                    page.Clear()
                    parent = page.GetRoot()
                else:
                    self.Clear()
                    parent = self.GetGrid().GetRoot()
            else:
                p = self.GetFirstChild(parent)
                while p:
                    self.Delete(p)
                    p = self.GetNextSiblingProperty(p)

            if not is_manager or page == self.GetCurrentPage():
                self.Freeze()
                cur_page = True

            try:
                self._AutoFillMany(parent,obj.__dict__)
            except:
                import traceback
                traceback.print_exc()

            if cur_page:
                self.Thaw()


        def RegisterEditor(self, editor, editorName=None):
            "Transform class into instance, if necessary."
            if not isinstance(editor, PGEditor):
                editor = editor()
            if not editorName:
                editorName = editor.__class__.__name__
            try:
                self._editor_instances.append(editor)
            except:
                self._editor_instances = [editor]
            RegisterEditor(editor, editorName)

    }
#endif

    // GetPropertyByNameI With nice assertion error message.
    wxPGProperty* GetPropertyByNameA( wxPGPropNameStr name ) const;

    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,
                           int selFlags = 0 );

    virtual bool SetEditableStateItem( const wxString& name, wxVariant value )
    {
        wxUnusedVar(name);
        wxUnusedVar(value);
        return false;
    }

    virtual wxVariant GetEditableStateItem( const wxString& name ) const
    {
        wxUnusedVar(name);
        return wxNullVariant;
    }

    // Returns page state data for given (sub) page (-1 means current page).
    virtual wxPropertyGridState* 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( wxPGPropNameStr name ) const;

#ifndef SWIG
    // Deriving classes must set this (it must be only or current page).
    wxPropertyGridState*         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();
    }
    const wxPropertyGrid* GetPropertyGrid() const
    {
        if ( !m_pState )
            return NULL;
        return (const wxPropertyGrid*) m_pState->GetGrid();
    }
#endif // #ifndef SWIG
};

// For backwards compatibility
typedef wxPropertyGridInterface wxPropertyContainerMethods;

// -----------------------------------------------------------------------


// wxPropertyGrid::DoSelectProperty flags (selFlags)
#define wxPG_SEL_FOCUS      0x0001 // Focuses to created editor
#define wxPG_SEL_FORCE      0x0002 // Forces deletion and recreation of editor
#define wxPG_SEL_NONVISIBLE 0x0004 // For example, doesn't cause EnsureVisible
#define wxPG_SEL_NOVALIDATE 0x0008 // Do not validate editor's value before selecting
#define wxPG_SEL_DELETING   0x0010 // Property being deselected is about to be deleted
#define wxPG_SEL_SETUNSPEC  0x0020 // Property's values was set to unspecified by the user
#define wxPG_SEL_DIALOGVAL  0x0040 // Property's event handler changed the value

// Set to disable sending of wxEVT_PG_SELECTED event
// NOTE! This doesn't do anything in wxPG 1.4, is just here
//       to reduce code difference with wxWidgets 2.9.
#define wxPG_SEL_DONT_SEND_EVENT        0x0080

#define wxPG_SEL_NO_REFRESH             0x0100 // Do not call Refresh()


// -----------------------------------------------------------------------

#ifndef SWIG

// Internal flags
#define wxPG_FL_INITIALIZED                 0x0001
#define wxPG_FL_ACTIVATION_BY_CLICK         0x0002 // Set when creating editor controls if it was clicked on.
#define wxPG_FL_DONT_CENTER_SPLITTER        0x0004
#define wxPG_FL_FOCUSED                     0x0008
#define wxPG_FL_MOUSE_CAPTURED              0x0010
#define wxPG_FL_MOUSE_INSIDE                0x0020
#define wxPG_FL_VALUE_MODIFIED              0x0040
#define wxPG_FL_PRIMARY_FILLS_ENTIRE        0x0080 // don't clear background of m_wndEditor
#define wxPG_FL_CUR_USES_CUSTOM_IMAGE       0x0100 // currently active editor uses custom image
#define wxPG_FL_CELL_OVERRIDES_SEL          0x0200 // cell colours override selection colours for selected cell
#define wxPG_FL_SCROLLED                    0x0400
#define wxPG_FL_ADDING_HIDEABLES            0x0800 // set when all added/inserted properties get hideable flag
#define wxPG_FL_NOSTATUSBARHELP             0x1000 // Disables showing help strings on statusbar.
#define wxPG_FL_CREATEDSTATE                0x2000 // Marks that we created the state, so we have to destroy it too.
#define wxPG_FL_SCROLLBAR_DETECTED          0x4000 // Set if scrollbar's existence was detected in last onresize.
#define wxPG_FL_DESC_REFRESH_REQUIRED       0x8000 // Set if wxPGMan requires redrawing of description text box.
#define wxPG_FL_IN_MANAGER                  0x00020000 // Set if contained in wxPropertyGridManager
#define wxPG_FL_GOOD_SIZE_SET               0x00040000 // Set after wxPropertyGrid is shown in its initial good size
#define wxPG_FL_IGNORE_NEXT_NAVKEY          0x00080000 // Next navigation key event will get ignored
#define wxPG_FL_IN_SELECT_PROPERTY          0x00100000 // Set when in SelectProperty.
#define wxPG_FL_STRING_IN_STATUSBAR         0x00200000 // Set when help string is shown in status bar
#define wxPG_FL_SPLITTER_PRE_SET            0x00400000 // Splitter position has been custom-set by the user
#define wxPG_FL_VALIDATION_FAILED           0x00800000 // Validation failed. Clear on modify event.
#define wxPG_FL_CATMODE_AUTO_SORT           0x01000000 // Auto sort is enabled (for categorized mode)
#define wxPG_MAN_FL_PAGE_INSERTED           0x02000000 // Set after page has been inserted to manager
#define wxPG_FL_ABNORMAL_EDITOR             0x04000000 // Active editor control is abnormally large
#define wxPG_FL_IN_ONCUSTOMEDITOREVENT      0x08000000 // Recursion guard for OnCustomEditorEvent
#define wxPG_FL_VALUE_CHANGE_IN_EVENT       0x10000000
#define wxPG_FL_FIXED_WIDTH_EDITOR          0x20000000 // Editor control width should not change on resize
#define wxPG_FL_HAS_VIRTUAL_WIDTH           0x40000000 // Width of panel can be different than width of grid
#define wxPG_FL_RECALCULATING_VIRTUAL_SIZE  0x80000000 // Prevents RecalculateVirtualSize re-entrancy

#endif // #ifndef SWIG

#if !defined(__wxPG_SOURCE_FILE__) && !defined(SWIG)
    // Reduce compile time, but still include in user app
    #include "props.h"
#endif

// -----------------------------------------------------------------------

#define wxPG_USE_STATE  m_pState

// BM_GRID
class WXDLLIMPEXP_PG wxPropertyGrid : public wxScrolledWindow, public wxPropertyGridInterface
{
#ifndef SWIG
    friend class wxPropertyGridState;
    friend class wxPropertyGridInterface;
    friend class wxPropertyGridManager;
    friend class wxPGCanvas;

    DECLARE_DYNAMIC_CLASS(wxPropertyGrid)
#endif

public:
#ifdef SWIG
    %pythonAppend wxPropertyGrid {
        self._setOORInfo(self)
        self.DoDefaultTypeMappings()
        self.edited_objects = {}
        self.DoDefaultValueTypeMappings()
        if not hasattr(self.__class__,'_vt2setter'):
            self.__class__._vt2setter = {}
    }
    %pythonAppend wxPropertyGrid() ""

    wxPropertyGrid( wxWindow *parent, wxWindowID id = wxID_ANY,
                    const wxPoint& pos = wxDefaultPosition,
                    const wxSize& size = wxDefaultSize,
                    long style = wxPG_DEFAULT_STYLE,
                    const wxChar* name = wxPyPropertyGridNameStr );
    %RenameCtor(PrePropertyGrid,  wxPropertyGrid());

#else

    wxPropertyGrid();

    wxPropertyGrid( wxWindow *parent, wxWindowID id = wxID_ANY,
                    const wxPoint& pos = wxDefaultPosition,
                    const wxSize& size = wxDefaultSize,
                    long style = wxPG_DEFAULT_STYLE,
                    const wxChar* name = wxPropertyGridNameStr );

    virtual ~wxPropertyGrid();
#endif

    void AddActionTrigger( int action, int keycode, int modifiers = 0 );

    static void AutoGetTranslation( bool enable );

    bool CanClose()
    {
        return DoEditorValidate();
    }

    void ClearActionTriggers( int action );

    bool EditorValidate()
    {
        return DoEditorValidate();
    }

    void CenterSplitter( bool enable_auto_centering = false );

    bool ChangePropertyValue( wxPGPropArg id, wxVariant newValue );

    bool Create( wxWindow *parent, wxWindowID id = wxID_ANY,
                 const wxPoint& pos = wxDefaultPosition,
                 const wxSize& size = wxDefaultSize,
                 long style = wxPG_DEFAULT_STYLE,
                 const wxChar* name = wxPropertyGridNameStr );

    virtual void Clear();

    void ClearModifiedStatus( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG()
        m_pState->ClearModifiedStatus(p);
    }

    void ClearModifiedStatus()
    {
        m_pState->ClearModifiedStatus(m_pState->m_properties);
        m_pState->m_anyModified = false;
    }

    bool UnfocusEditor();

#if wxPG_COMPATIBILITY_1_2_0

    wxDEPRECATED( void ClearTargetPage() );
#endif

    bool EnableCategories( bool enable );

    wxPanel* GetPanel() const
    {
        return m_canvas;
    }

    const wxPGCommonValue* GetCommonValue( unsigned int i ) const
    {
        return (wxPGCommonValue*) m_commonValues[i];
    }

    unsigned int GetCommonValueCount() const
    {
        return (unsigned int) m_commonValues.size();
    }

    wxString GetCommonValueLabel( unsigned int i ) const
    {
        wxASSERT( GetCommonValue(i) );
        return GetCommonValue(i)->GetLabel();
    }

    bool EnsureVisible( wxPGPropArg id );

    wxSize FitColumns()
    {
        wxSize sz = m_pState->DoFitColumns();
        return sz;
    }

    wxFont& GetCaptionFont() { return m_captionFont; }

#ifndef SWIG
    const wxFont& GetCaptionFont() const { return m_captionFont; }
#endif

    wxColour GetCaptionBackgroundColour() const { return m_colCapBack; }

    wxColour GetCaptionForegroundColour() const { return m_colCapFore; }

    wxColour GetCellBackgroundColour() const { return m_colPropBack; }

    wxColour GetCellDisabledTextColour() const { return m_colDisPropFore; }

    wxColour GetCellTextColour() const { return m_colPropFore; }

    unsigned int GetChildrenCount()
    {
        return GetChildrenCount( m_pState->m_properties );
    }

    unsigned int GetChildrenCount( wxPGPropArg id ) const
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(0)
        return p->GetChildCount();
    }

    unsigned int GetColumnCount() const
    {
        return (unsigned int) m_pState->m_colWidths.size();
    }

    wxColour GetEmptySpaceColour() const { return m_colEmptySpace; }

#if wxPG_COMPATIBILITY_1_2_0

    const wxPGProperty* GetFirstVisible() const
    {
        return wxPropertyGridInterface::GetFirst( wxPG_ITERATE_VISIBLE );
    }

    wxPGProperty* GetFirstVisible()
    {
        return wxPropertyGridInterface::GetFirst( wxPG_ITERATE_VISIBLE );
    }
#endif

    int GetFontHeight() const { return m_fontHeight; }

    wxPropertyGrid* GetGrid() { return this; }

#if wxPG_COMPATIBILITY_1_2_0

    wxPGProperty* GetFirstCategory() const
    {
        return (wxPGProperty*) wxPropertyGridInterface::GetFirst( wxPG_ITERATE_CATEGORIES );
    }

    wxPGProperty* GetFirstProperty()
    {
        return (wxPGProperty*) wxPropertyGridInterface::GetFirst( wxPG_ITERATE_DEFAULT );
    }
#endif

    wxSize GetImageSize( wxPGProperty* p = NULL, int item = -1 ) const;

    wxRect GetImageRect( wxPGProperty* p, int item ) const;

    //wxSize GetEditorImageSize() const;

    wxPGProperty* GetItemAtY( int y ) const { return DoGetItemAtY(y); }

    wxPGProperty* GetLastItem( int flags = wxPG_ITERATE_DEFAULT )
    {
        return m_pState->GetLastItem(flags);
    }

    const wxPGProperty* GetLastItem( int flags = wxPG_ITERATE_DEFAULT ) const
    {
        return m_pState->GetLastItem(flags);
    }

#if wxPG_COMPATIBILITY_1_2_0

    wxPGProperty* GetLastProperty()
    {
        if ( !m_pState->m_properties->GetCount() ) return NULL;
        wxPGProperty* p = GetLastItem(wxPG_ITERATE_DEFAULT);
        if ( p->IsCategory() )
            return GetPrevProperty(p);
        return p;
    }

    wxPGProperty* GetLastChild( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)

        if ( !p->GetChildCount() ) return wxNullProperty;

        return p->Last();
    }
    wxPGProperty* GetLastVisible()
    {
        return GetLastItem(wxPG_ITERATE_VISIBLE);
    }
#endif // wxPG_COMPATIBILITY_1_2_0

    wxColour GetLineColour() const { return m_colLine; }

    wxColour GetMarginColour() const { return m_colMargin; }

#if wxPG_COMPATIBILITY_1_2_0

    wxPGProperty* GetNextProperty( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
        return m_pState->GetNextProperty(p);
    }

    wxPGProperty* GetNextCategory( wxPGPropArg id ) const
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
        return m_pState->GetNextCategory(p);
    }

    wxPGProperty* GetNextVisible( wxPGPropArg id ) const
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
        return wxPropertyGridIterator::OneStep(m_pState,wxPG_ITERATE_VISIBLE,p,1);
    }
#endif // wxPG_COMPATIBILITY_1_2_0

#if wxPG_COMPATIBILITY_1_2_0

    wxPGProperty* GetPrevProperty( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(NULL)
        return m_pState->GetPrevProperty(p);
    }
    wxPGProperty* GetPrevSiblingProperty( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
        return m_pState->GetPrevSiblingProperty(p);
    }
    wxPGProperty* GetPrevVisible( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
        return wxPropertyGridIterator::OneStep(m_pState,wxPG_ITERATE_VISIBLE,p,-1);
    }
#endif // wxPG_COMPATIBILITY_1_2_0

    wxColour GetPropertyBackgroundColour( wxPGPropArg id ) const;

    wxColour GetPropertyColour( wxPGPropArg id ) const
    {
        return GetPropertyBackgroundColour( id );
    }

    wxColour GetPropertyTextColour( wxPGPropArg id ) const;

    wxPGProperty* GetPropertyByLabel( const wxString& name ) const
    {
        return m_pState->GetPropertyByLabel(name);
    }

    wxPGProperty* GetRoot() const { return m_pState->m_properties; }

    int GetRowHeight() const { return m_lineHeight; }

    wxPGProperty* GetSelectedProperty () const { return GetSelection(); }

    wxPGProperty* GetSelection() const
    {
        return m_pState->GetSelection();
    }

    wxColour GetSelectionBackgroundColour() const { return m_colSelBack; }

    wxColour GetSelectionForegroundColour() const { return m_colSelFore; }

    int GetSplitterPosition() const { return m_pState->DoGetSplitterPosition(0); }

    wxTextCtrl* GetEditorTextCtrl() const;

    int GetUnspecifiedCommonValue() const { return m_cvUnspecified; }

    wxPGValidationInfo& GetValidationInfo()
    {
        return m_validationInfo;
    }

    int GetVerticalSpacing() const { return (int)m_vspacing; }

    bool HasSelection() const { return (m_pState->m_selection.size() > 0); }

    bool HasVirtualWidth() const { return (m_iFlags & wxPG_FL_HAS_VIRTUAL_WIDTH)?true:false; }

    wxPropertyGridHitTestResult HitTest( const wxPoint& pt ) const;

    bool IsAnyModified() const { return (m_pState->m_anyModified>0); }

    bool IsFrozen() const { return (m_frozen>0)?true:false; }

    void OnTLPChanging( wxWindow* newTLP );

    virtual void RefreshProperty( wxPGProperty* p );

    void RefreshEditor();

    void SetColumnCount( int colCount )
    {
        m_pState->SetColumnCount(colCount);
        Refresh();
    }

    void SetSplitterLeft( bool subProps = false )
    {
        m_pState->SetSplitterLeft(subProps);
    }

#ifndef SWIG

    static wxPGEditor* RegisterEditorClass( wxPGEditor* editor, const wxString& name,
                                            bool noDefCheck = false );
#endif

    void ResetColours();

    void SetButtonShortcut( int keycode, bool ctrlDown = false, bool altDown = false );

    void SetCaptionTextColour( wxPGPropArg id, const wxColour& col );

    void SetCurrentCategory( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG()
        wxPropertyCategory* pc = (wxPropertyCategory*)p;
        wxASSERT( !pc || pc->IsCategory() );
        m_pState->m_currentCategory = pc;
    }

    void SetPropertyAttributeAll( const wxString& attrName, wxVariant value );

    void SetPropertyBackgroundColour( wxPGPropArg id, const wxColour& col );

#if wxPG_COMPATIBILITY_1_2_0

    wxDEPRECATED( void SetPropertyColour( wxPGPropArg id, const wxColour& col ) );
#endif

    void SetPropertyTextColour( wxPGPropArg id, const wxColour& col );

    void SetPropertyColourToDefault( wxPGPropArg id );

    void SetCaptionBackgroundColour(const wxColour& col);

    void SetCaptionForegroundColour(const wxColour& col);

    void SetCellBackgroundColour(const wxColour& col);

    void SetCellDisabledTextColour(const wxColour& col);

    void SetCellTextColour(const wxColour& col);

    void SetEmptySpaceColour(const wxColour& col);

    void SetLineColour(const wxColour& col);

    void SetMarginColour(const wxColour& col);

    void SetSelectionBackground(const wxColour& col);

    void SetSelectionForeground(const wxColour& col);

    void SetSplitterPosition( int newxpos, bool refresh = true )
    {
        DoSetSplitterPosition_(newxpos,refresh,0);
        m_iFlags |= wxPG_FL_SPLITTER_PRE_SET;
    }

    void SetSortFunction( wxPGSortCallback sortFunction )
    {
        m_sortFunction = sortFunction;
    }

    wxPGSortCallback GetSortFunction() const
    {
        return m_sortFunction;
    }

    void SetUnspecifiedCommonValue( int index ) { m_cvUnspecified = index; }

    void SetVirtualWidth( int width );

    bool SelectProperty( wxPGPropArg id, bool focus = false )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
        return DoSelectProperty(p, focus ? wxPG_SEL_FOCUS : 0);
    }

    void SetSelection( const wxArrayPGProperty& newSelection )
    {
        DoSetSelection( newSelection, wxPG_SEL_DONT_SEND_EVENT );
    }

    bool AddToSelection( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
        return DoAddToSelection(p, wxPG_SEL_DONT_SEND_EVENT);
    }

    bool RemoveFromSelection( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
        return DoRemoveFromSelection(p, wxPG_SEL_DONT_SEND_EVENT);
    }

    void MakeColumnEditable( unsigned int column, bool editable = true );

    void BeginLabelEdit( unsigned int column = 0 )
    {
        DoBeginLabelEdit(column, wxPG_SEL_DONT_SEND_EVENT);
    }

    void EndLabelEdit( bool commit = true )
    {
        DoEndLabelEdit(commit, wxPG_SEL_DONT_SEND_EVENT);
    }

    wxTextCtrl* GetLabelEditor() const;

#ifndef SWIG
    void SwitchState( wxPropertyGridState* pNewState );
#endif

    void SetPropertyName( wxPGPropArg id, const wxString& newname )
    {
        wxPG_PROP_ARG_CALL_PROLOG()
        DoSetPropertyName( p, newname );
    }

    void SetVerticalSpacing( int vspacing )
    {
        m_vspacing = (unsigned char)vspacing;
        CalculateFontAndBitmapStuff( vspacing );
        if ( !m_pState->m_itemsAdded ) Refresh();
    }

    void ShowPropertyError( wxPGPropArg id, const wxString& msg )
    {
        wxPG_PROP_ARG_CALL_PROLOG()
        DoShowPropertyError(p, msg);
    }

    void Sort();

    void Sort( wxPGPropArg id );

    virtual void SetWindowStyleFlag( long style );

    void EditorsValueWasModified() { m_iFlags |= wxPG_FL_VALUE_MODIFIED; }

    void EditorsValueWasNotModified()
    {
        m_iFlags &= ~(wxPG_FL_VALUE_MODIFIED);
    }

    bool IsEditorsValueModified() const { return  ( m_iFlags & wxPG_FL_VALUE_MODIFIED ) ? true : false; }

    wxWindow* GenerateEditorButton( const wxPoint& pos, const wxSize& sz );

    void FixPosForTextCtrl( wxWindow* ctrl,
                            unsigned int forColumn = 1,
                            const wxPoint& offset = wxPoint(0, 0) );

    wxWindow* GenerateEditorTextCtrl( const wxPoint& pos,
                                      const wxSize& sz,
                                      const wxString& value,
                                      wxWindow* secondary,
                                      int extraStyle = 0,
                                      int maxLen = 0,
                                      unsigned int forColumn = 1 );

    /* Generates both textctrl and button.
    */
    wxWindow* GenerateEditorTextCtrlAndButton( const wxPoint& pos,
        const wxSize& sz, wxWindow** psecondary, int limited_editing,
        wxPGProperty* property );

    wxPoint GetGoodEditorDialogPosition( wxPGProperty* p,
                                         const wxSize& sz );

    // Converts escape sequences in src_str to newlines,
    // tabs, etc. and copies result to dst_str.
    static wxString& ExpandEscapeSequences( wxString& dst_str, wxString& src_str );

    // Converts newlines, tabs, etc. in src_str to escape
    // sequences, and copies result to dst_str.
    static wxString& CreateEscapeSequences( wxString& dst_str, wxString& src_str );

    wxRect GetPropertyRect( const wxPGProperty* p1, const wxPGProperty* p2 ) const;

    wxWindow* GetEditorControl() const;

    bool IsEditorFocused() const;

    bool AdjustPosForClipperWindow( wxWindow* topCtrlWnd, int* x, int* y );

    wxWindow* GetPrimaryEditor() const
    {
        return GetEditorControl();
    }

    wxWindow* GetEditorControlSecondary() const
    {
        return m_wndEditor2;
    }

#ifdef __WXPYTHON__
    // Dummy method to put wxRect type info into the wrapper
    wxRect DummywxRectTypeInit() const { return wxRect(1,2,3,4); }
#endif

    virtual bool CommitChangesFromEditor( wxUint32 flags = 0 );

#ifndef SWIG

    static void ArrayStringToString( wxString& dst, const wxArrayString& src,
                                     wxChar preDelim, wxChar postDelim,
                                     int flags );

    void OnCustomEditorEvent( wxCommandEvent &event );

    bool HasInternalFlag( long flag ) const { return (m_iFlags & flag) ? true : false; }
    long GetInternalFlags() const { return m_iFlags; }
    void SetInternalFlag( long flag ) { m_iFlags |= flag; }
    void ClearInternalFlag( long flag ) { m_iFlags &= ~(flag); }
    void IncFrozen() { m_frozen++; }
    void DecFrozen() { m_frozen--; }

    void OnComboItemPaint( wxPGCustomComboControl* pCb,int item,wxDC& dc,
                           wxRect& rect,int flags );

    // Used by simple check box for keyboard navigation
    void SendNavigationKeyEvent( int dir );

    static void DoubleToString( wxString& target,
                                double value,
                                int precision,
                                bool removeZeroes,
                                wxString* precTemplate );

    void ValueChangeInEvent( wxVariant variant )
    {
        m_changeInEventValue = variant;
        m_iFlags |= wxPG_FL_VALUE_CHANGE_IN_EVENT;
    }

    bool WasValueChangedInEvent() const
    {
        return (m_iFlags & wxPG_FL_VALUE_CHANGE_IN_EVENT) ? true : false;
    }

    bool IsMainButtonEvent( const wxEvent& event )
    {
        return (event.GetEventType() == wxEVT_COMMAND_BUTTON_CLICKED) && (m_wndSecId == event.GetId());
    }

    virtual bool DoPropertyChanged( wxPGProperty* p, unsigned int selFlags = 0 );

    virtual bool PerformValidation( wxPGProperty* p, wxVariant& pendingValue );

    bool OnValidationFailure( wxPGProperty* property, wxVariant& invalidValue );

    void OnValidationFailureReset( wxPGProperty* property )
    {
        if ( property && property->HasFlag(wxPG_PROP_INVALID_VALUE) )
        {
            DoOnValidationFailureReset(property);
            property->ClearFlag(wxPG_PROP_INVALID_VALUE);
        }
        m_validationInfo.m_failureMessage.clear();
    }

    virtual void DoShowPropertyError( wxPGProperty* property, const wxString& msg );

    virtual bool DoOnValidationFailure( wxPGProperty* property, wxVariant& invalidValue );

    virtual void DoOnValidationFailureReset( wxPGProperty* property );

    int GetSpacingY() const { return m_spacingy; }

    void SetupTextCtrlValue( const wxString text ) { m_prevTcValue = text; }

    void DrawItem( wxPGProperty* p )
    {
        DrawItems(p,p);
    }

    virtual void DrawItemAndChildren( wxPGProperty* p );

    void DrawItemAndValueRelated( wxPGProperty* p );

protected:

    virtual wxPropertyGridState* CreateState() const;

#ifndef DOXYGEN
public:

    // Control font changer helper.
    void SetCurControlBoldFont();

    //
    // Public methods for semi-public use
    //
    bool DoSelectProperty( wxPGProperty* p, unsigned int flags = 0 );

    // Overridden functions.
    virtual bool Destroy();
    virtual wxSize DoGetBestSize() const;
    virtual void Refresh( bool eraseBackground = true,
                          const wxRect *rect = (const wxRect *) NULL );
    virtual bool SetFont( const wxFont& font );
#if wxPG_SUPPORT_TOOLTIPS
    void SetToolTip( const wxString& tipString );
#endif
    virtual void Freeze();
    virtual void SetExtraStyle( long exStyle );
    virtual void Thaw();
    virtual bool Reparent( wxWindowBase *newParent );

protected:

#ifndef wxPG_ICON_WIDTH
        wxBitmap            *m_expandbmp, *m_collbmp;
#endif

    wxCursor            *m_cursorSizeWE;

    wxWindow            *m_wndEditor;
    wxWindow            *m_wndEditor2;

    wxPanel             *m_canvas;

#if wxPG_DOUBLE_BUFFER
    wxBitmap            *m_doubleBuffer;
#endif

    wxArrayPtrVoid      *m_windowsToDelete;

    wxLongLong          m_timeCreated;

    wxVariant           m_changeInEventValue;

    int                 m_wndSecId;

        int                 m_spacingy;

    int                 m_width;

    int                 m_height;

    int                 m_ncWidth;

    //int                 m_fWidth;

    int                 m_prevVY;

        int                 m_gutterWidth;

    int                 m_lineHeight;

    int                 m_marginWidth;

    int                 m_buttonSpacingY; // y spacing for expand/collapse button.

    int                 m_subgroup_extramargin;

        int                 m_iconWidth;

#ifndef wxPG_ICON_WIDTH

        int                 m_iconHeight;
#endif

    int                 m_curcursor;

        wxFont              m_captionFont;

        int                 m_fontHeight;  // Height of the font.

    int                 m_pushButKeyCode;  // Base keycode for triggering push button.

    int                 m_startingSplitterX;

    int                 m_draggedSplitter;

    wxPGProperty*       m_chgInfo_changedProperty;

    wxPGProperty*       m_chgInfo_baseChangedProperty;

    wxVariant           m_chgInfo_pendingValue;

    wxVariant           m_chgInfo_valueList;

    wxPGValidationInfo  m_validationInfo;

    wxPGHashMapI2I      m_actionTriggers;

    //
    // Temporary values
    //

    unsigned short      m_coloursCustomized;

    signed char                 m_dragOffset;

    unsigned char       m_dragStatus;

    unsigned char       m_mouseSide;

    unsigned char       m_editorFocused;

    //unsigned char       m_lastCaptionBottomnest;

    unsigned char       m_frozen;

    unsigned char       m_vspacing;

    unsigned char       m_pushButKeyCodeNeedsAlt;  // Does triggering push button need Alt down?

    unsigned char       m_pushButKeyCodeNeedsCtrl;  // Does triggering push button need Ctrl down?

    unsigned char       m_keyComboConsumed;  // Used to track when Alt/Ctrl+Key was consumed.

    unsigned char       m_inDoPropertyChanged;

    unsigned char       m_inCommitChangesFromEditor;

    unsigned char       m_inDoSelectProperty;

    wxPGVFBFlags        m_permanentValidationFailureBehavior;  // Set by app

    wxUint32            m_iFlags;

    int                 m_clearThisMany;

    // Mouse is hovering over this column (index)
    unsigned int        m_colHover;

    wxPGProperty*       m_propHover;  // pointer to property that has mouse hovering

    // Active label editor
    wxWindow*           m_labelEditor;

    // For which property the label editor is active
    wxPGProperty*       m_labelEditorProperty;

    wxWindow*           m_eventObject;  // EventObject for wxPropertyGridEvents

    wxWindow*           m_curFocused;  // What (global) window is currently focused
                                       // (needed to resolve event handling mess).

    // Last closed top-level parent
    wxWindow*           m_tlpClosed;

    // Local time ms when tlp was closed.
    wxLongLong          m_tlpClosedTime;

    wxWindow*           m_tlp;  // Last known top-level parent

    // Event currently being sent - NULL if no event being sent right now
    wxPropertyGridEvent*    m_processedEvent;

    wxPGSortCallback    m_sortFunction;  // Sort function

    int                 m_propHoverY;   // y coordinate of property that mouse hovering
    unsigned int        m_selColumn;  // Which column's editor is selected (usually 1)?

    int                 m_ctrlXAdjust; // x relative to splitter (needed for resize).

    wxColour            m_colLine;     // lines between cells
    wxColour            m_colPropFore; // property labels and values are written in this colour
    wxColour            m_colDisPropFore;  // or with this colour when disabled
    wxColour            m_colPropBack; // background for m_colPropFore
    wxColour            m_colCapFore;  // text color for captions
    wxColour            m_colCapBack;  // background color for captions
    wxColour            m_colSelFore;  // foreground for selected property
    wxColour            m_colSelBack;  // background for selected property (actually use background color when control out-of-focus)
    wxColour            m_colMargin;   // background colour for margin
    wxColour            m_colEmptySpace;  // background colour for empty space below the grid

    wxArrayPtrVoid      m_visPropArray;  // temp property array used in DoDrawItems

    // NB: These *cannot* be moved to globals.
    wxArrayPtrVoid      m_arrBgBrushes; // Array of background colour brushes.
    wxArrayPtrVoid      m_arrFgCols; // Array of foreground colours.

    wxArrayPtrVoid      m_commonValues;  // labels when properties use common values
    int                 m_cvUnspecified;  // Which cv selection really sets value to unspecified?

    wxString            m_prevTcValue;  // Used to skip excess text editor events

protected:

    // Sets some members to defaults (called constructors).
        void Init1();

    // Initializes some members (called by Create and complex constructor).
        void Init2();

        void OnPaint(wxPaintEvent &event );

    // main event receivers
    void OnMouseMove( wxMouseEvent &event );
    void OnMouseMoveBottom( wxMouseEvent &event );
    void OnMouseClick( wxMouseEvent &event );
    void OnMouseRightClick( wxMouseEvent &event );
    void OnMouseDoubleClick( wxMouseEvent &event );
    void OnMouseUp( wxMouseEvent &event );
    void OnKey( wxKeyEvent &event );
    void OnKeyUp( wxKeyEvent &event );
    void OnNavigationKey( wxNavigationKeyEvent& event );
    void OnResize( wxSizeEvent &event );

    // event handlers
    bool HandleMouseMove( int x, unsigned int y, wxMouseEvent &event );
    bool HandleMouseClick( int x, unsigned int y, wxMouseEvent &event );
    bool HandleMouseRightClick( int x, unsigned int y, wxMouseEvent &event );
    bool HandleMouseDoubleClick( int x, unsigned int y, wxMouseEvent &event );
    bool HandleMouseUp( int x, unsigned int y, wxMouseEvent &event );
    void HandleKeyEvent( wxKeyEvent &event );
    bool HandleChildKey( wxKeyEvent& event ); // Handle TAB and ESCAPE in control

    void OnMouseEntry( wxMouseEvent &event );

    void OnIdle( wxIdleEvent &event );
    void OnFocusEvent( wxFocusEvent &event );
    void OnChildFocusEvent( wxChildFocusEvent& event );

    bool OnMouseCommon( wxMouseEvent &event, int* px, int *py );
    bool OnMouseChildCommon( wxMouseEvent &event, int* px, int *py );

    // sub-control event handlers
    void OnMouseClickChild( wxMouseEvent &event );
    void OnMouseRightClickChild( wxMouseEvent &event );
    void OnMouseMoveChild( wxMouseEvent &event );
    void OnMouseUpChild( wxMouseEvent &event );
    void OnChildKeyDown( wxKeyEvent &event );
    void OnChildKeyUp( wxKeyEvent &event );

    void OnCaptureChange( wxMouseCaptureChangedEvent &event );

    void OnScrollEvent( wxScrollWinEvent &event );

    void OnSysColourChanged( wxSysColourChangedEvent &event );

    void OnTLPClose( wxCloseEvent& event );

protected:

    bool AddToSelectionFromInputEvent( wxPGProperty* prop,
                                       unsigned int colIndex,
                                       wxMouseEvent* event = NULL,
                                       int selFlags = 0 );

        void CalculateFontAndBitmapStuff( int vspacing );

    wxRect GetEditorWidgetRect( wxPGProperty* p, int column ) const;

    void CorrectEditorWidgetSizeX();

    void CorrectEditorWidgetPosY();

#ifdef __WXDEBUG__
    void _log_items();
    void OnScreenNote( const wxChar* format, ... );
#endif

    int DoDrawItems( wxDC& dc,
                     const wxPGProperty* first_item,
                     const wxPGProperty* last_item,
                     const wxRect* clip_rect,
                     bool isBuffered ) const;

    virtual void DrawExpanderButton( wxDC& dc, const wxRect& rect,
                                     wxPGProperty* property ) const;

    void DrawItems( wxDC& dc, unsigned int topitemy, unsigned int bottomitemy,
                    const wxRect* clip_rect = (const wxRect*) NULL );

    void DrawItems( const wxPGProperty* p1, const wxPGProperty* p2 );

#if wxPG_COMPATIBILITY_1_2_0

    wxPGProperty& GetPropertyById( wxPGPropArg id )
    {
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(*((wxPGProperty*)NULL))
        return *p;
    }
#endif

    // Translate wxKeyEvent to wxPG_ACTION_XXX
    int KeyEventToActions(wxKeyEvent &event, int* pSecond) const;

    int KeyEventToAction(wxKeyEvent &event) const
    {
        return KeyEventToActions(event, NULL);
    }

    void ImprovedClientToScreen( int* px, int* py );

    // Called by focus event handlers. newFocused is the window that becomes focused.
    void HandleFocusChange( wxWindow* newFocused );

    void RegainColours();

    bool DoEditorValidate();

    // Similar to DoSelectProperty() but also works on columns
    // other than 1. Does not active editor if column is not
    // editable.
    bool DoSelectAndEdit( wxPGProperty* prop,
                          unsigned int colIndex,
                          unsigned int selFlags );

    void DoSetSelection( const wxArrayPGProperty& newSelection,
                         int selFlags = 0 );

    bool DoAddToSelection( wxPGProperty* prop,
                           int selFlags = 0 );

    bool DoRemoveFromSelection( wxPGProperty* prop,
                                int selFlags = 0 );

    void DoBeginLabelEdit( unsigned int colIndex, int selFlags = 0 );
    void DoEndLabelEdit( bool commit, int selFlags = 0 );
    void OnLabelEditorEnterPress( wxCommandEvent& event );
    void OnLabelEditorKeyPress( wxKeyEvent& event );

    wxPGProperty* DoGetItemAtY( int y ) const;

    void DoSetSplitterPosition_( int newxpos, bool refresh = true, int splitterIndex = 0, bool allPages = false );

    void DestroyEditorWnd( wxWindow* wnd );
    void FreeEditors();

    virtual bool DoExpand( wxPGProperty* p, bool sendEvent = false );

    virtual bool DoCollapse( wxPGProperty* p, bool sendEvent = false );

    // Returns nearest paint visible property (such that will be painted unless
    // window is scrolled or resized). If given property is paint visible, then
    // it itself will be returned.
    wxPGProperty* GetNearestPaintVisible( wxPGProperty* p ) const;

    static void RegisterDefaultEditors();

    // Sets m_bgColIndex to this property and all its children.
    void SetBackgroundColourIndex( wxPGProperty* p, int index );

    // Sets m_fgColIndex to this property and all its children.
    void SetTextColourIndex( wxPGProperty* p, int index, int flags );

    int CacheColour( const wxColour& colour );

    void DoSetPropertyName( wxPGProperty* p, const wxString& newname );

    // Setups event handling for child control
    void SetupEventHandling( wxWindow* wnd, int id );

    void CustomSetCursor( int type, bool override = false );

    virtual bool ProcessEvent(wxEvent& event);

    void RecalculateVirtualSize( int forceXPos = -1 );

    void PrepareAfterItemsAdded();

    // Omit the wxPG_SEL_NOVALIDATE flag to allow vetoing the event
    bool SendEvent( int eventType, wxPGProperty* p,
                    wxVariant* pValue = NULL,
                    unsigned int selFlags = wxPG_SEL_NOVALIDATE,
                    unsigned int column = 1 );

    void SetFocusOnCanvas()
    {
        m_canvas->SetFocusIgnoringChildren();
        m_editorFocused = 0;
    }

    bool DoHideProperty( wxPGProperty* p, bool hide, int flags );

private:

    bool ButtonTriggerKeyTest( wxKeyEvent &event );

#endif // DOXYGEN_SHOULD_SKIP_THIS

private:
    DECLARE_EVENT_TABLE()
#endif // #ifndef SWIG
};

#undef wxPG_USE_STATE

// -----------------------------------------------------------------------
//
// Bunch of inlines that need to resolved after all classes have been defined.
//

#ifndef SWIG
inline bool wxPropertyGridState::IsDisplayed() const
{
    return ( this == m_pPropGrid->GetState() );
}

inline unsigned int wxPropertyGridState::GetActualVirtualHeight() const
{
    return DoGetRoot()->GetChildrenHeight(GetGrid()->GetRowHeight());
}
#endif

inline int wxPGProperty::GetDisplayedCommonValueCount() const
{
    if ( HasFlag(wxPG_PROP_USES_COMMON_VALUE) )
    {
        wxPropertyGrid* pg = GetGrid();
        if ( pg )
            return (int) pg->GetCommonValueCount();
    }
    return 0;
}

inline void wxPGProperty::SetEditor( const wxString& editorName )
{
    m_customEditor = wxPropertyGridInterface::GetEditorByName(editorName);
}

inline bool wxPGProperty::Hide( bool hide, int flags )
{
    return GetGrid()->HideProperty(this, hide, flags);
}

inline bool wxPGProperty::SetMaxLength( int maxLen )
{
    return GetGrid()->SetPropertyMaxLength(this,maxLen);
}

// -----------------------------------------------------------------------


#ifndef SWIG

#define wxPG_BASE_EVT_PRE_ID     1775

BEGIN_DECLARE_EVENT_TYPES()
    DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_PG, wxEVT_PG_SELECTED,           wxPG_BASE_EVT_PRE_ID)
    DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_PG, wxEVT_PG_CHANGING,           wxPG_BASE_EVT_PRE_ID+1)
    DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_PG, wxEVT_PG_CHANGED,            wxPG_BASE_EVT_PRE_ID+2)
    DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_PG, wxEVT_PG_HIGHLIGHTED,        wxPG_BASE_EVT_PRE_ID+3)
    DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_PG, wxEVT_PG_RIGHT_CLICK,        wxPG_BASE_EVT_PRE_ID+4)
    DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_PG, wxEVT_PG_PAGE_CHANGED,       wxPG_BASE_EVT_PRE_ID+5)
    DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_PG, wxEVT_PG_ITEM_COLLAPSED,     wxPG_BASE_EVT_PRE_ID+6)
    DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_PG, wxEVT_PG_ITEM_EXPANDED,      wxPG_BASE_EVT_PRE_ID+7)
    DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_PG, wxEVT_PG_DOUBLE_CLICK,       wxPG_BASE_EVT_PRE_ID+8)
    DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_PG, wxEVT_PG_LABEL_EDIT_BEGIN,   wxPG_BASE_EVT_PRE_ID+9)
    DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_PG, wxEVT_PG_LABEL_EDIT_ENDING,  wxPG_BASE_EVT_PRE_ID+10)
END_DECLARE_EVENT_TYPES()
#else
    enum {
        wxEVT_PG_SELECTED = wxPG_BASE_EVT_PRE_ID,
        wxEVT_PG_CHANGING,
        wxEVT_PG_CHANGED,
        wxEVT_PG_HIGHLIGHTED,
        wxEVT_PG_RIGHT_CLICK,
        wxEVT_PG_PAGE_CHANGED,
        wxEVT_PG_ITEM_COLLAPSED,
        wxEVT_PG_ITEM_EXPANDED,
        wxEVT_PG_DOUBLE_CLICK,
        wxEVT_PG_LABEL_EDIT_BEGIN,
        wxEVT_PG_LABEL_EDIT_ENDING
    };
#endif


#define wxPG_BASE_EVT_TYPE       wxEVT_PG_SELECTED
#define wxPG_MAX_EVT_TYPE        (wxPG_BASE_EVT_TYPE+30)


#ifndef SWIG
typedef void (wxEvtHandler::*wxPropertyGridEventFunction)(wxPropertyGridEvent&);

#define EVT_PG_SELECTED(id, fn)              DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_SELECTED, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxPropertyGridEventFunction, & fn ), (wxObject *) NULL ),
#define EVT_PG_CHANGING(id, fn)              DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_CHANGING, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxPropertyGridEventFunction, & fn ), (wxObject *) NULL ),
#define EVT_PG_CHANGED(id, fn)               DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_CHANGED, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxPropertyGridEventFunction, & fn ), (wxObject *) NULL ),
#define EVT_PG_HIGHLIGHTED(id, fn)           DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_HIGHLIGHTED, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxPropertyGridEventFunction, & fn ), (wxObject *) NULL ),
#define EVT_PG_RIGHT_CLICK(id, fn)           DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_RIGHT_CLICK, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxPropertyGridEventFunction, & fn ), (wxObject *) NULL ),
#define EVT_PG_DOUBLE_CLICK(id, fn)          DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_DOUBLE_CLICK, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxPropertyGridEventFunction, & fn ), (wxObject *) NULL ),
#define EVT_PG_PAGE_CHANGED(id, fn)          DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_PAGE_CHANGED, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxPropertyGridEventFunction, & fn ), (wxObject *) NULL ),
#define EVT_PG_ITEM_COLLAPSED(id, fn)        DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_ITEM_COLLAPSED, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxPropertyGridEventFunction, & fn ), (wxObject *) NULL ),
#define EVT_PG_ITEM_EXPANDED(id, fn)         DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_ITEM_EXPANDED, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxPropertyGridEventFunction, & fn ), (wxObject *) NULL ),
#define EVT_PG_LABEL_EDIT_BEGIN(id, fn)      DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_LABEL_EDIT_BEGIN, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxPropertyGridEventFunction, & fn ), (wxObject *) NULL ),
#define EVT_PG_LABEL_EDIT_ENDING(id, fn)     DECLARE_EVENT_TABLE_ENTRY( wxEVT_PG_LABEL_EDIT_ENDING, id, -1, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxPropertyGridEventFunction, & fn ), (wxObject *) NULL ),

#define wxPropertyGridEventHandler(A) ((wxObjectEventFunction)(wxEventFunction)(wxPropertyGridEventFunction)&A)

#endif


class WXDLLIMPEXP_PG wxPropertyGridEvent : public wxCommandEvent
{
public:

    wxPropertyGridEvent(wxEventType commandType=0, int id=0);
#ifndef SWIG

    wxPropertyGridEvent(const wxPropertyGridEvent& event);
#endif

    ~wxPropertyGridEvent();

    virtual wxEvent* Clone() const;

    void EnableProperty( bool enable = true )
    {
        m_pg->EnableProperty(m_property,enable);
    }

    void DisableProperty()
    {
        m_pg->EnableProperty(m_property,false);
    }

    unsigned int GetColumn() const
    {
        return m_column;
    }

    wxPGProperty* GetMainParent() const
    {
        wxASSERT(m_property);
        return m_property->GetMainParent();
    }

    wxPGProperty* GetProperty() const
    {
        return m_property;
    }

#if wxPG_COMPATIBILITY_1_2_0
  #ifndef SWIG

    wxPGProperty* GetPropertyPtr() const
    {
        return m_property;
    }
  #endif
#endif

    const wxString& GetPropertyLabel() const
    {
        wxASSERT( m_property );
        return m_property->GetLabel();
    }

    wxString GetPropertyName() const
    {
        wxASSERT( m_property );
        return m_property->GetName();
    }

    wxPGProperty::ClientDataType GetPropertyClientData() const
    {
        wxASSERT( m_property );
        return m_property->GetClientData();
    }

#ifndef SWIG

    wxVariant GetPropertyValue() const
    {
        wxASSERT( m_property );
        return m_property->GetValue();
    }

    wxString GetPropertyValueAsString() const
    {
        return m_pg->GetPropertyValueAsString( m_property );
    }
    long GetPropertyValueAsLong() const
    {
        return m_pg->GetPropertyValueAsLong( m_property );
    }
    int GetPropertyValueAsInt() const
    {
        return (int)GetPropertyValueAsLong();
    }
    long GetPropertyValueAsBool() const
    {
        return m_pg->GetPropertyValueAsBool( m_property );
    }
    double GetPropertyValueAsDouble() const
    {
        return m_pg->GetPropertyValueAsDouble( m_property );
    }
    const wxObject* GetPropertyValueAsWxObjectPtr() const
    {
        return m_pg->GetPropertyValueAsWxObjectPtr( m_property );
    }
    void* GetPropertyValueAsVoidPtr() const
    {
        return m_pg->GetPropertyValueAsVoidPtr( m_property );
    }
    wxArrayString GetPropertyValueAsArrayString() const
    {
        return m_pg->GetPropertyValueAsArrayString( m_property );
    }
    wxPoint GetPropertyValueAsPoint() const
    {
        return m_pg->GetPropertyValueAsPoint( m_property );
    }
    wxSize GetPropertyValueAsSize() const
    {
        return m_pg->GetPropertyValueAsSize( m_property );
    }
    wxArrayInt GetPropertyValueAsArrayInt() const
    {
        return m_pg->GetPropertyValueAsArrayInt( m_property );
    }

#else
    %pythoncode {
        def GetPropertyValue(self):
            return self.GetProperty().GetValue()
    }
#endif

    wxPGValidationInfo& GetValidationInfo()
    {
        wxASSERT(m_validationInfo);
        return *m_validationInfo;
    }

    bool HasProperty() const { return ( m_property != (wxPGProperty*) NULL ); }

    bool IsPropertyEnabled() const
    {
        return m_pg->IsPropertyEnabled(m_property);
    }

    bool CanVeto() const { return m_canVeto; }

    void Veto( bool veto = true ) { m_wasVetoed = veto; }

    const wxVariant& GetValue() const
    {
        wxASSERT_MSG( m_validationInfo,
                      wxT("Only call GetValue from a handler of event type that supports it") );
        return *m_validationInfo->m_pValue;
    }

    void SetValidationFailureBehavior( int flags )
    {
        wxASSERT( GetEventType() == wxEVT_PG_CHANGING );
        m_validationInfo->m_failureBehavior = (wxPGVFBFlags) flags;
    }

    void SetValidationFailureMessage( const wxString& message )
    {
        wxASSERT( GetEventType() == wxEVT_PG_CHANGING );
        m_validationInfo->m_failureMessage = message;
    }

#ifndef SWIG
    wxPGVFBFlags GetValidationFailureBehavior() const
    {
        wxASSERT( GetEventType() == wxEVT_PG_CHANGING );
        return m_validationInfo->m_failureBehavior;
    }

    void SetCanVeto( bool canVeto ) { m_canVeto = canVeto; }
    bool WasVetoed() const { return m_wasVetoed; }

    void SetProperty( wxPGProperty* p ) { m_property = p; }

    void SetPropertyGrid( wxPropertyGrid* pg ) { m_pg = pg; }

    void SetupValidationInfo()
    {
        wxASSERT(m_pg);
        wxASSERT( GetEventType() == wxEVT_PG_CHANGING );
        m_validationInfo = &m_pg->GetValidationInfo();
    }

    void SetColumn( unsigned int column )
    {
        m_column = column;
    }

private:
    void Init();
    DECLARE_DYNAMIC_CLASS(wxPropertyGridEvent)

    wxPGProperty*       m_property;
    wxPropertyGrid*     m_pg;
    wxPGValidationInfo* m_validationInfo;

    unsigned int        m_column;

    bool                m_canVeto;
    bool                m_wasVetoed;

#endif
};


// -----------------------------------------------------------------------

class WXDLLIMPEXP_PG wxPropertyGridPopulator
{
public:
    wxPropertyGridPopulator();

    virtual ~wxPropertyGridPopulator();

    void SetState( wxPropertyGridState* state );

    void SetGrid( wxPropertyGrid* pg );

    wxPGProperty* Add( const wxString& propClass,
                       const wxString& propLabel,
                       const wxString& propName,
                       const wxString* propValue,
                       wxPGChoices* pChoices = NULL );

    void AddChildren( wxPGProperty* property );

    bool AddAttribute( const wxString& name,
                       const wxString& type,
                       const wxString& value );

    virtual void DoScanForChildren() = 0;

    wxPGProperty* GetCurParent() const
    {
        return (wxPGProperty*) m_propHierarchy[m_propHierarchy.size()-1];
    }

    wxPropertyGridState* GetState() { return m_state; }
    const wxPropertyGridState* GetState() const { return m_state; }

    static bool ToLongPCT( const wxString& s, long* pval, long max );

    wxPGChoices ParseChoices( const wxString& choicesString,
                              const wxString& idString );

    virtual void ProcessError( const wxString& msg );

protected:

    wxPropertyGrid*         m_pg;

    wxPropertyGridState*    m_state;

    wxArrayPGProperty       m_propHierarchy;

    wxPGHashMapS2P          m_dictIdChoices;
};

// -----------------------------------------------------------------------

//
// Undefine macros that are not needed outside propertygrid sources
//
#ifndef __wxPG_SOURCE_FILE__
    #undef wxPG_FL_DESC_REFRESH_REQUIRED
    #undef wxPG_FL_SCROLLBAR_DETECTED
    #undef wxPG_FL_CREATEDSTATE
    #undef wxPG_FL_NOSTATUSBARHELP
    #undef wxPG_FL_SCROLLED
    #undef wxPG_FL_FOCUS_INSIDE_CHILD
    #undef wxPG_FL_FOCUS_INSIDE
    #undef wxPG_FL_MOUSE_INSIDE_CHILD
    #undef wxPG_FL_CUR_USES_CUSTOM_IMAGE
    #undef wxPG_FL_PRIMARY_FILLS_ENTIRE
    #undef wxPG_FL_VALUE_MODIFIED
    #undef wxPG_FL_MOUSE_INSIDE
    #undef wxPG_FL_FOCUSED
    #undef wxPG_FL_MOUSE_CAPTURED
    #undef wxPG_FL_INITIALIZED
    #undef wxPG_FL_ACTIVATION_BY_CLICK
    #undef wxPG_FL_DONT_CENTER_SPLITTER
    #undef wxPG_SUPPORT_TOOLTIPS
    #undef wxPG_DOUBLE_BUFFER
    #undef wxPG_ICON_WIDTH
    #undef wxPG_USE_RENDERER_NATIVE
// Following are needed by the manager headers
//    #undef wxPGPropNameStr
#endif

// Doxygen special
#ifdef DOXYGEN
    #include "editor.h"
    #include "manager.h"
#endif

// -----------------------------------------------------------------------

#endif // __WX_PROPGRID_PROPGRID_H__

---

wxpropgrid
Author(s): Jaakko Salli
autogenerated on Fri Jan 11 09:34:05 2013