reset the tooltip text before changing it, this apparently prevents a spurious redraw...

[wxWidgets.git] / src / propgrid / propgrid.cpp

diff --git a/src/propgrid/propgrid.cpp b/src/propgrid/propgrid.cpp
index 9ecf73f6b110c6ead6f85560a1222d94caf0cbca..6a5a83ab252f152c6e98dd6851b3442af05c9e51 100644 (file)
--- a/src/propgrid/propgrid.cpp
+++ b/src/propgrid/propgrid.cpp
@@ -4,7 +4,7 @@
 // Author:      Jaakko Salli
 // Modified by:
 // Created:     2004-09-25
 // Author:      Jaakko Salli
 // Modified by:
 // Created:     2004-09-25

-// RCS-ID:      $Id:
+// RCS-ID:      $Id$

 // Copyright:   (c) Jaakko Salli
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 // Copyright:   (c) Jaakko Salli
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////


@@ -52,22 +52,22 @@
 // This define is necessary to prevent macro clearing
 #define __wxPG_SOURCE_FILE__
 
 // This define is necessary to prevent macro clearing
 #define __wxPG_SOURCE_FILE__
 

-#include <wx/propgrid/propgrid.h>
-#include <wx/propgrid/editors.h>
+#include "wx/propgrid/propgrid.h"
+#include "wx/propgrid/editors.h"

 
 #if wxPG_USE_RENDERER_NATIVE
 
 #if wxPG_USE_RENDERER_NATIVE

-    #include <wx/renderer.h>
+    #include "wx/renderer.h"

 #endif
 
 #endif
 

-#include <wx/odcombo.h>
+#include "wx/odcombo.h"

 
 #include "wx/timer.h"
 #include "wx/dcbuffer.h"
 
 #include "wx/timer.h"
 #include "wx/dcbuffer.h"

-#include <wx/clipbrd.h>
-#include <wx/dataobj.h>
+#include "wx/clipbrd.h"
+#include "wx/dataobj.h"

 
 #ifdef __WXMSW__
 
 #ifdef __WXMSW__

-    #include <wx/msw/private.h>
+    #include "wx/msw/private.h"

 #endif
 
 // Two pics for the expand / collapse buttons.
 #endif
 
 // Two pics for the expand / collapse buttons.


@@ -92,16 +92,16 @@
 
 
 //#define wxPG_TEXT_INDENT                4 // For the wxComboControl
 
 
 //#define wxPG_TEXT_INDENT                4 // For the wxComboControl

-#define wxPG_ALLOW_CLIPPING             1 // If 1, GetUpdateRegion() in OnPaint event handler is not ignored
+//#define wxPG_ALLOW_CLIPPING             1 // If 1, GetUpdateRegion() in OnPaint event handler is not ignored

 #define wxPG_GUTTER_DIV                 3 // gutter is max(iconwidth/gutter_div,gutter_min)
 #define wxPG_GUTTER_MIN                 3 // gutter before and after image of [+] or [-]
 #define wxPG_YSPACING_MIN               1
 #define wxPG_DEFAULT_VSPACING           2 // This matches .NET propertygrid's value,
                                           // but causes normal combobox to spill out under MSW
 
 #define wxPG_GUTTER_DIV                 3 // gutter is max(iconwidth/gutter_div,gutter_min)
 #define wxPG_GUTTER_MIN                 3 // gutter before and after image of [+] or [-]
 #define wxPG_YSPACING_MIN               1
 #define wxPG_DEFAULT_VSPACING           2 // This matches .NET propertygrid's value,
                                           // but causes normal combobox to spill out under MSW
 

-#define wxPG_OPTIMAL_WIDTH              200 // Arbitrary
+//#define wxPG_OPTIMAL_WIDTH              200 // Arbitrary

 
 

-#define wxPG_MIN_SCROLLBAR_WIDTH        10 // Smallest scrollbar width on any platform
+//#define wxPG_MIN_SCROLLBAR_WIDTH        10 // Smallest scrollbar width on any platform

                                            // Must be larger than largest control border
                                            // width * 2.
 
                                            // Must be larger than largest control border
                                            // width * 2.
 


@@ -111,7 +111,7 @@
 
 //#define wxPG_NAT_CHOICE_BORDER_ANY   0
 
 
 //#define wxPG_NAT_CHOICE_BORDER_ANY   0
 

-#define wxPG_HIDER_BUTTON_HEIGHT        25
+//#define wxPG_HIDER_BUTTON_HEIGHT        25

 
 #define wxPG_PIXELS_PER_UNIT            m_lineHeight
 
 
 #define wxPG_PIXELS_PER_UNIT            m_lineHeight
 


@@ -119,7 +119,7 @@
   #define m_iconHeight m_iconWidth
 #endif
 
   #define m_iconHeight m_iconWidth
 #endif
 

-#define wxPG_TOOLTIP_DELAY              1000
+//#define wxPG_TOOLTIP_DELAY              1000

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


@@ -134,22 +134,13 @@ void wxPropertyGrid::AutoGetTranslation ( bool ) { }
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 

-const wxChar *wxPropertyGridNameStr = wxT("wxPropertyGrid");
+const char wxPropertyGridNameStr[] = "wxPropertyGrid";

 
 // -----------------------------------------------------------------------
 // Statics in one class for easy destruction.
 
 // -----------------------------------------------------------------------
 // Statics in one class for easy destruction.

-// NB: We prefer to use wxModule, as it offers more consistent behavior
-//     across platforms. However, for those rare problem situations, we
-//     also need to offer option to use simpler approach.

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

-#ifndef wxPG_USE_WXMODULE
-    #define wxPG_USE_WXMODULE 1
-#endif
-
-#if wxPG_USE_WXMODULE
-
-#include <wx/module.h>
+#include "wx/module.h"

 
 class wxPGGlobalVarsClassManager : public wxModule
 {
 
 class wxPGGlobalVarsClassManager : public wxModule
 {


@@ -162,21 +153,8 @@ public:
 
 IMPLEMENT_DYNAMIC_CLASS(wxPGGlobalVarsClassManager, wxModule)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxPGGlobalVarsClassManager, wxModule)
 

-#else // !wxPG_USE_WXMODULE
-
-class wxPGGlobalVarsClassManager
-{
-public:
-    wxPGGlobalVarsClassManager() {}
-    ~wxPGGlobalVarsClassManager() { delete wxPGGlobalVars; }
-};
-
-static wxPGGlobalVarsClassManager gs_pgGlobalVarsClassManager;
-
-#endif
-

 
 

-wxPGGlobalVarsClass* wxPGGlobalVars = (wxPGGlobalVarsClass*) NULL;
+wxPGGlobalVarsClass* wxPGGlobalVars = NULL;

 
 
 wxPGGlobalVarsClass::wxPGGlobalVarsClass()
 
 
 wxPGGlobalVarsClass::wxPGGlobalVarsClass()


@@ -186,7 +164,7 @@ wxPGGlobalVarsClass::wxPGGlobalVarsClass()
     m_boolChoices.Add(_("False"));
     m_boolChoices.Add(_("True"));
 
     m_boolChoices.Add(_("False"));
     m_boolChoices.Add(_("True"));
 

-    m_fontFamilyChoices = (wxPGChoices*) NULL;
+    m_fontFamilyChoices = NULL;

 
     m_defaultRenderer = new wxPGDefaultRenderer();
 
 
     m_defaultRenderer = new wxPGDefaultRenderer();
 


@@ -249,90 +227,10 @@ wxPGGlobalVarsClass::~wxPGGlobalVarsClass()
     delete wxPGProperty::sm_wxPG_LABEL;
 }
 
     delete wxPGProperty::sm_wxPG_LABEL;
 }
 

-// -----------------------------------------------------------------------
-// wxPGBrush
-// -----------------------------------------------------------------------
-
-//
-// This class is a wxBrush derivative used in the background colour
-// brush cache. It adds wxPG-type colour-in-long to the class.
-// JMS: Yes I know wxBrush doesn't actually hold the value (refcounted
-//   object does), but this is simpler implementation and equally
-//   effective.
-//
-
-class wxPGBrush : public wxBrush
-{
-public:
-    wxPGBrush( const wxColour& colour );
-    wxPGBrush();
-    virtual ~wxPGBrush() { }
-    void SetColour2( const wxColour& colour );
-    inline long GetColourAsLong() const { return m_colAsLong; }
-private:
-    long    m_colAsLong;
-};
-
-
-void wxPGBrush::SetColour2( const wxColour& colour )
-{
-    wxBrush::SetColour(colour);
-    m_colAsLong = wxPG_COLOUR(colour.Red(),colour.Green(),colour.Blue());
-}
-
-
-wxPGBrush::wxPGBrush() : wxBrush()
-{
-    m_colAsLong = 0;
-}
-
-
-wxPGBrush::wxPGBrush( const wxColour& colour ) : wxBrush(colour)
-{
-    m_colAsLong = wxPG_COLOUR(colour.Red(),colour.Green(),colour.Blue());
-}
-
-
-// -----------------------------------------------------------------------
-// wxPGColour
-// -----------------------------------------------------------------------
-
-//
-// Same as wxPGBrush, but for wxColour instead.
-//
-
-class wxPGColour : public wxColour
-{
-public:
-    wxPGColour( const wxColour& colour );
-    wxPGColour();
-    virtual ~wxPGColour() { }
-    void SetColour2( const wxColour& colour );
-    inline long GetColourAsLong() const { return m_colAsLong; }
-private:
-    long    m_colAsLong;
-};
-
-
-void wxPGColour::SetColour2( const wxColour& colour )
-{
-    *this = colour;
-    m_colAsLong = wxPG_COLOUR(colour.Red(),colour.Green(),colour.Blue());
-}
-
-
-wxPGColour::wxPGColour() : wxColour()
-{
-    m_colAsLong = 0;
-}
-
-
-wxPGColour::wxPGColour( const wxColour& colour ) : wxColour(colour)
+void wxPropertyGridInitGlobalsIfNeeded()

 {
 {

-    m_colAsLong = wxPG_COLOUR(colour.Red(),colour.Green(),colour.Blue());

 }
 
 }
 

-

 // -----------------------------------------------------------------------
 // wxPGTLWHandler
 //   Intercepts Close-events sent to wxPropertyGrid's top-level parent,
 // -----------------------------------------------------------------------
 // wxPGTLWHandler
 //   Intercepts Close-events sent to wxPropertyGrid's top-level parent,


@@ -426,25 +324,21 @@ protected:
         pg->OnKey( event );
     }
 
         pg->OnKey( event );
     }
 

-    void OnKeyUp( wxKeyEvent& event )
-    {
-        wxPropertyGrid* pg = wxStaticCast(GetParent(), wxPropertyGrid);
-        pg->OnKeyUp( event );
-    }
+    void OnPaint( wxPaintEvent& event );

 
 

-    void OnNavigationKey( wxNavigationKeyEvent& event )
-    {
-        wxPropertyGrid* pg = wxStaticCast(GetParent(), wxPropertyGrid);
-        pg->OnNavigationKey( event );
-    }
+    // Always be focussable, even with child windows
+    virtual void SetCanFocus(bool WXUNUSED(canFocus))
+    {  wxPanel::SetCanFocus(true); }

 
 

-    void OnPaint( wxPaintEvent& event );

 
 private:
     DECLARE_EVENT_TABLE()
 
 private:
     DECLARE_EVENT_TABLE()

+    DECLARE_ABSTRACT_CLASS(wxPGCanvas)

 };
 
 
 };
 
 

+IMPLEMENT_ABSTRACT_CLASS(wxPGCanvas,wxPanel)
+

 BEGIN_EVENT_TABLE(wxPGCanvas, wxPanel)
     EVT_MOTION(wxPGCanvas::OnMouseMove)
     EVT_PAINT(wxPGCanvas::OnPaint)
 BEGIN_EVENT_TABLE(wxPGCanvas, wxPanel)
     EVT_MOTION(wxPGCanvas::OnMouseMove)
     EVT_PAINT(wxPGCanvas::OnPaint)


@@ -453,9 +347,6 @@ BEGIN_EVENT_TABLE(wxPGCanvas, wxPanel)
     EVT_RIGHT_UP(wxPGCanvas::OnMouseRightClick)
     EVT_LEFT_DCLICK(wxPGCanvas::OnMouseDoubleClick)
     EVT_KEY_DOWN(wxPGCanvas::OnKey)
     EVT_RIGHT_UP(wxPGCanvas::OnMouseRightClick)
     EVT_LEFT_DCLICK(wxPGCanvas::OnMouseDoubleClick)
     EVT_KEY_DOWN(wxPGCanvas::OnKey)

-    EVT_KEY_UP(wxPGCanvas::OnKeyUp)
-    EVT_CHAR(wxPGCanvas::OnKey)
-    EVT_NAVIGATION_KEY(wxPGCanvas::OnNavigationKey)

 END_EVENT_TABLE()
 
 
 END_EVENT_TABLE()
 
 


@@ -473,6 +364,12 @@ void wxPGCanvas::OnPaint( wxPaintEvent& WXUNUSED(event) )
     // Update everything inside the box
     wxRect r = GetUpdateRegion().GetBox();
 
     // Update everything inside the box
     wxRect r = GetUpdateRegion().GetBox();
 

+    // FIXME: This is just a workaround for a bug that causes splitters not
+    //        to paint when other windows are being dragged over the grid.
+    wxRect fullRect = GetRect();
+    r.x = fullRect.x;
+    r.width = fullRect.width;
+

     // Repaint this rectangle
     pg->DrawItems( dc, r.y, r.y + r.height, &r );
 
     // Repaint this rectangle
     pg->DrawItems( dc, r.y, r.y + r.height, &r );
 


@@ -499,7 +396,6 @@ BEGIN_EVENT_TABLE(wxPropertyGrid, wxScrolledWindow)
   EVT_CHILD_FOCUS(wxPropertyGrid::OnChildFocusEvent)
   EVT_SET_FOCUS(wxPropertyGrid::OnFocusEvent)
   EVT_KILL_FOCUS(wxPropertyGrid::OnFocusEvent)
   EVT_CHILD_FOCUS(wxPropertyGrid::OnChildFocusEvent)
   EVT_SET_FOCUS(wxPropertyGrid::OnFocusEvent)
   EVT_KILL_FOCUS(wxPropertyGrid::OnFocusEvent)

-  EVT_TEXT_ENTER(wxPG_SUBID1,wxPropertyGrid::OnCustomEditorEvent)

   EVT_SYS_COLOUR_CHANGED(wxPropertyGrid::OnSysColourChanged)
 END_EVENT_TABLE()
 
   EVT_SYS_COLOUR_CHANGED(wxPropertyGrid::OnSysColourChanged)
 END_EVENT_TABLE()
 


@@ -519,7 +415,7 @@ wxPropertyGrid::wxPropertyGrid( wxWindow *parent,
                                 const wxPoint& pos,
                                 const wxSize& size,
                                 long style,
                                 const wxPoint& pos,
                                 const wxSize& size,
                                 long style,

-                                const wxChar* name )
+                                const wxString& name )

     : wxScrolledWindow()
 {
     Init1();
     : wxScrolledWindow()
 {
     Init1();


@@ -533,7 +429,7 @@ bool wxPropertyGrid::Create( wxWindow *parent,
                              const wxPoint& pos,
                              const wxSize& size,
                              long style,
                              const wxPoint& pos,
                              const wxSize& size,
                              long style,

-                             const wxChar* name )
+                             const wxString& name )

 {
 
     if ( !(style&wxBORDER_MASK) )
 {
 
     if ( !(style&wxBORDER_MASK) )


@@ -541,18 +437,9 @@ bool wxPropertyGrid::Create( wxWindow *parent,
 
     style |= wxVSCROLL;
 
 
     style |= wxVSCROLL;
 

-#ifdef __WXMSW__
-    // This prevents crash under Win2K, but still
-    // enables keyboard navigation
-    if ( style & wxTAB_TRAVERSAL )
-    {
-        style &= ~(wxTAB_TRAVERSAL);
-        style |= wxWANTS_CHARS;
-    }
-#else
-    if ( style & wxTAB_TRAVERSAL )
-        style |= wxWANTS_CHARS;
-#endif
+    // Filter out wxTAB_TRAVERSAL - we will handle TABs manually
+    style &= ~(wxTAB_TRAVERSAL);
+    style |= wxWANTS_CHARS;

 
     wxScrolledWindow::Create(parent,id,pos,size,style,name);
 
 
     wxScrolledWindow::Create(parent,id,pos,size,style,name);
 


@@ -568,24 +455,20 @@ bool wxPropertyGrid::Create( wxWindow *parent,
 //
 void wxPropertyGrid::Init1()
 {
 //
 void wxPropertyGrid::Init1()
 {

-#if !wxPG_USE_WXMODULE
-    if ( !wxPGGlobalVars )
-        wxPGGlobalVars = new wxPGGlobalVarsClass();
-#endif
-

     // Register editor classes, if necessary.
     if ( wxPGGlobalVars->m_mapEditorClasses.empty() )
     // Register editor classes, if necessary.
     if ( wxPGGlobalVars->m_mapEditorClasses.empty() )

-        RegisterDefaultEditors();
+        wxPropertyGrid::RegisterDefaultEditors();

 
     m_iFlags = 0;
 
     m_iFlags = 0;

-    m_pState = (wxPropertyGridPageState*) NULL;
-    m_wndEditor = m_wndEditor2 = (wxWindow*) NULL;
-    m_selected = (wxPGProperty*) NULL;
+    m_pState = NULL;
+    m_wndEditor = m_wndEditor2 = NULL;
+    m_selected = NULL;

     m_selColumn = -1;
     m_selColumn = -1;

-    m_propHover = (wxPGProperty*) NULL;
+    m_propHover = NULL;

     m_eventObject = this;
     m_eventObject = this;

-    m_curFocused = (wxWindow*) NULL;
+    m_curFocused = NULL;

     m_tlwHandler = NULL;
     m_tlwHandler = NULL;

+    m_sortFunction = NULL;

     m_inDoPropertyChanged = 0;
     m_inCommitChangesFromEditor = 0;
     m_inDoSelectProperty = 0;
     m_inDoPropertyChanged = 0;
     m_inCommitChangesFromEditor = 0;
     m_inDoSelectProperty = 0;


@@ -602,12 +485,8 @@ void wxPropertyGrid::Init1()
     AddActionTrigger( wxPG_ACTION_EXPAND_PROPERTY, WXK_RIGHT);
     AddActionTrigger( wxPG_ACTION_COLLAPSE_PROPERTY, WXK_LEFT);
     AddActionTrigger( wxPG_ACTION_CANCEL_EDIT, WXK_ESCAPE );
     AddActionTrigger( wxPG_ACTION_EXPAND_PROPERTY, WXK_RIGHT);
     AddActionTrigger( wxPG_ACTION_COLLAPSE_PROPERTY, WXK_LEFT);
     AddActionTrigger( wxPG_ACTION_CANCEL_EDIT, WXK_ESCAPE );

-    AddActionTrigger( wxPG_ACTION_CUT, 'X', wxMOD_CONTROL );
-    AddActionTrigger( wxPG_ACTION_CUT, WXK_DELETE, wxMOD_SHIFT );
-    AddActionTrigger( wxPG_ACTION_COPY, 'C', wxMOD_CONTROL);
-    AddActionTrigger( wxPG_ACTION_COPY, WXK_INSERT, wxMOD_CONTROL );
-    AddActionTrigger( wxPG_ACTION_PASTE, 'V', wxMOD_CONTROL );
-    AddActionTrigger( wxPG_ACTION_PASTE, WXK_INSERT, wxMOD_SHIFT );
+    AddActionTrigger( wxPG_ACTION_PRESS_BUTTON, WXK_DOWN, wxMOD_ALT );
+    AddActionTrigger( wxPG_ACTION_PRESS_BUTTON, WXK_F4 );

 
     m_coloursCustomized = 0;
     m_frozen = 0;
 
     m_coloursCustomized = 0;
     m_frozen = 0;


@@ -615,11 +494,9 @@ void wxPropertyGrid::Init1()
     m_canvas = NULL;
 
 #if wxPG_DOUBLE_BUFFER
     m_canvas = NULL;
 
 #if wxPG_DOUBLE_BUFFER

-    m_doubleBuffer = (wxBitmap*) NULL;
+    m_doubleBuffer = NULL;

 #endif
 
 #endif
 

-    m_windowsToDelete = NULL;
-

 #ifndef wxPG_ICON_WIDTH
        m_expandbmp = NULL;
        m_collbmp = NULL;
 #ifndef wxPG_ICON_WIDTH
        m_expandbmp = NULL;
        m_collbmp = NULL;


@@ -638,10 +515,6 @@ void wxPropertyGrid::Init1()
 
     m_width = m_height = 0;
 
 
     m_width = m_height = 0;
 

-    SetButtonShortcut(0);
-
-    m_keyComboConsumed = 0;
-

     m_commonValues.push_back(new wxPGCommonValue(_("Unspecified"), wxPGGlobalVars->m_defaultRenderer) );
     m_cvUnspecified = 0;
 
     m_commonValues.push_back(new wxPGCommonValue(_("Unspecified"), wxPGGlobalVars->m_defaultRenderer) );
     m_cvUnspecified = 0;
 


@@ -660,7 +533,7 @@ void wxPropertyGrid::Init2()
 #ifdef __WXMAC__
    // Smaller controls on Mac
    SetWindowVariant(wxWINDOW_VARIANT_SMALL);
 #ifdef __WXMAC__
    // Smaller controls on Mac
    SetWindowVariant(wxWINDOW_VARIANT_SMALL);

-#endif 
+#endif

 
     // Now create state, if one didn't exist already
     // (wxPropertyGridManager might have created it for us).
 
     // Now create state, if one didn't exist already
     // (wxPropertyGridManager might have created it for us).


@@ -700,21 +573,11 @@ void wxPropertyGrid::Init2()
        // adjust bitmap icon y position so they are centered
     m_vspacing = wxPG_DEFAULT_VSPACING;
 
        // adjust bitmap icon y position so they are centered
     m_vspacing = wxPG_DEFAULT_VSPACING;
 

-    if ( !m_font.Ok() )
-    {
-        wxFont useFont = wxScrolledWindow::GetFont();
-        wxScrolledWindow::SetOwnFont( useFont );
-    }
-    else
-        // This should be otherwise called by SetOwnFont
-           CalculateFontAndBitmapStuff( wxPG_DEFAULT_VSPACING );
-
-    // Add base brush item
-    m_arrBgBrushes.Add((void*)new wxPGBrush());
+    CalculateFontAndBitmapStuff( wxPG_DEFAULT_VSPACING );

 
 

-    // Add base colour items
-    m_arrFgCols.Add((void*)new wxPGColour());
-    m_arrFgCols.Add((void*)new wxPGColour());
+    // Allocate cell datas indirectly by calling setter
+    m_propertyDefaultCell.SetBgCol(*wxBLACK);
+    m_categoryDefaultCell.SetBgCol(*wxBLACK);

 
     RegainColours();
 
 
     RegainColours();
 


@@ -735,7 +598,7 @@ void wxPropertyGrid::Init2()
 
     m_canvas = new wxPGCanvas();
     m_canvas->Create(this, 1, wxPoint(0, 0), GetClientSize(),
 
     m_canvas = new wxPGCanvas();
     m_canvas->Create(this, 1, wxPoint(0, 0), GetClientSize(),

-                     (GetWindowStyle() & wxTAB_TRAVERSAL) | wxWANTS_CHARS | wxCLIP_CHILDREN);
+                     wxWANTS_CHARS | wxCLIP_CHILDREN);

     m_canvas->SetBackgroundStyle( wxBG_STYLE_CUSTOM );
 
     m_iFlags |= wxPG_FL_INITIALIZED;
     m_canvas->SetBackgroundStyle( wxBG_STYLE_CUSTOM );
 
     m_iFlags |= wxPG_FL_INITIALIZED;


@@ -777,9 +640,7 @@ wxPropertyGrid::~wxPropertyGrid()
         delete m_doubleBuffer;
 #endif
 
         delete m_doubleBuffer;
 #endif
 

-    delete m_windowsToDelete;
-
-    //m_selected = (wxPGProperty*) NULL;
+    //m_selected = NULL;

 
     if ( m_iFlags & wxPG_FL_CREATEDSTATE )
         delete m_pState;
 
     if ( m_iFlags & wxPG_FL_CREATEDSTATE )
         delete m_pState;


@@ -791,18 +652,6 @@ wxPropertyGrid::~wxPropertyGrid()
        delete m_collbmp;
 #endif
 
        delete m_collbmp;
 #endif
 

-    // Delete cached text colours.
-    for ( i=0; i<m_arrFgCols.size(); i++ )
-    {
-        delete (wxPGColour*)m_arrFgCols.Item(i);
-    }
-
-    // Delete cached brushes.
-    for ( i=0; i<m_arrBgBrushes.size(); i++ )
-    {
-        delete (wxPGBrush*)m_arrBgBrushes.Item(i);
-    }
-

     // Delete common value records
     for ( i=0; i<m_commonValues.size(); i++ )
     {
     // Delete common value records
     for ( i=0; i<m_commonValues.size(); i++ )
     {


@@ -876,7 +725,7 @@ void wxPropertyGrid::SetWindowStyleFlag( long style )
             //
             // Tooltips disabled
             //
             //
             // Tooltips disabled
             //

-            m_canvas->SetToolTip( (wxToolTip*) NULL );
+            m_canvas->SetToolTip( NULL );

         }
     #endif
     }
         }
     #endif
     }


@@ -1108,8 +957,6 @@ static int wxPGGetColAvg( const wxColour& col )
 
 void wxPropertyGrid::RegainColours()
 {
 
 void wxPropertyGrid::RegainColours()
 {

-    wxColour def_bgcol = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOW );
-

     if ( !(m_coloursCustomized & 0x0002) )
     {
         wxColour col = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE );
     if ( !(m_coloursCustomized & 0x0002) )
     {
         wxColour col = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE );


@@ -1124,6 +971,7 @@ void wxPropertyGrid::RegainColours()
             m_colCapBack = wxPGAdjustColour(col,-colDec);
         else
             m_colCapBack = col;
             m_colCapBack = wxPGAdjustColour(col,-colDec);
         else
             m_colCapBack = col;

+        m_categoryDefaultCell.GetData()->SetBgCol(m_colCapBack);

     }
 
     if ( !(m_coloursCustomized & 0x0001) )
     }
 
     if ( !(m_coloursCustomized & 0x0001) )


@@ -1138,27 +986,21 @@ void wxPropertyGrid::RegainColours()
     #endif
         wxColour capForeCol = wxPGAdjustColour(m_colCapBack,colDec,5000,5000,true);
         m_colCapFore = capForeCol;
     #endif
         wxColour capForeCol = wxPGAdjustColour(m_colCapBack,colDec,5000,5000,true);
         m_colCapFore = capForeCol;

-
-        // Set the cached colour as well.
-        ((wxPGColour*)m_arrFgCols.Item(1))->SetColour2(capForeCol);
+        m_categoryDefaultCell.GetData()->SetFgCol(capForeCol);

     }
 
     if ( !(m_coloursCustomized & 0x0008) )
     {
         wxColour bgCol = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOW );
         m_colPropBack = bgCol;
     }
 
     if ( !(m_coloursCustomized & 0x0008) )
     {
         wxColour bgCol = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOW );
         m_colPropBack = bgCol;

-
-        // Set the cached brush as well.
-        ((wxPGBrush*)m_arrBgBrushes.Item(0))->SetColour2(bgCol);
+        m_propertyDefaultCell.GetData()->SetBgCol(bgCol);

     }
 
     if ( !(m_coloursCustomized & 0x0010) )
     {
         wxColour fgCol = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT );
         m_colPropFore = fgCol;
     }
 
     if ( !(m_coloursCustomized & 0x0010) )
     {
         wxColour fgCol = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT );
         m_colPropFore = fgCol;

-
-        // Set the cached colour as well.
-        ((wxPGColour*)m_arrFgCols.Item(0))->SetColour2(fgCol);
+        m_propertyDefaultCell.GetData()->SetFgCol(fgCol);

     }
 
     if ( !(m_coloursCustomized & 0x0020) )
     }
 
     if ( !(m_coloursCustomized & 0x0020) )


@@ -1192,39 +1034,16 @@ void wxPropertyGrid::ResetColours()
 bool wxPropertyGrid::SetFont( const wxFont& font )
 {
     // Must disable active editor.
 bool wxPropertyGrid::SetFont( const wxFont& font )
 {
     // Must disable active editor.

-    if ( m_selected )
-    {
-        bool selRes = ClearSelection();
-        wxPG_CHECK_MSG_DBG( selRes,
-                            false,
-                            wxT("failed to deselect a property (editor probably had invalid value)") );
-    }
+    ClearSelection(false);

 
 

-    // TODO: Following code is disabled with wxMac because
-    //   it is reported to fail. I (JMS) cannot debug it
-    //   personally right now.
-#if !defined(__WXMAC__)

     bool res = wxScrolledWindow::SetFont( font );
     if ( res )
     {
         CalculateFontAndBitmapStuff( m_vspacing );
     bool res = wxScrolledWindow::SetFont( font );
     if ( res )
     {
         CalculateFontAndBitmapStuff( m_vspacing );

-
-        if ( m_pState )
-            m_pState->CalculateFontAndBitmapStuff(m_vspacing);
-

         Refresh();
     }
 
     return res;
         Refresh();
     }
 
     return res;

-#else
-    // ** wxMAC Only **
-    // TODO: Remove after SetFont crash fixed.
-    if ( m_iFlags & wxPG_FL_INITIALIZED )
-    {
-        wxLogDebug(wxT("WARNING: propGrid.cpp: wxPropertyGrid::SetFont has been disabled on wxMac since there has been crash reported in it. If you are willing to debug the cause, replace line '#if !defined(__WXMAC__)' with line '#if 1' in wxPropertyGrid::SetFont."));
-    }
-    return false;
-#endif

 }
 
 // -----------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------


@@ -1252,8 +1071,7 @@ void wxPropertyGrid::SetCellBackgroundColour( const wxColour& col )
     m_colPropBack = col;
     m_coloursCustomized |= 0x08;
 
     m_colPropBack = col;
     m_coloursCustomized |= 0x08;
 

-    // Set the cached brush as well.
-    ((wxPGBrush*)m_arrBgBrushes.Item(0))->SetColour2(col);
+    m_propertyDefaultCell.GetData()->SetBgCol(col);

 
     Refresh();
 }
 
     Refresh();
 }


@@ -1265,8 +1083,7 @@ void wxPropertyGrid::SetCellTextColour( const wxColour& col )
     m_colPropFore = col;
     m_coloursCustomized |= 0x10;
 
     m_colPropFore = col;
     m_coloursCustomized |= 0x10;
 

-    // Set the cached colour as well.
-    ((wxPGColour*)m_arrFgCols.Item(0))->SetColour2(col);
+    m_propertyDefaultCell.GetData()->SetFgCol(col);

 
     Refresh();
 }
 
     Refresh();
 }


@@ -1313,6 +1130,9 @@ void wxPropertyGrid::SetCaptionBackgroundColour( const wxColour& col )
 {
     m_colCapBack = col;
     m_coloursCustomized |= 0x02;
 {
     m_colCapBack = col;
     m_coloursCustomized |= 0x02;

+
+    m_categoryDefaultCell.GetData()->SetBgCol(col);
+

     Refresh();
 }
 
     Refresh();
 }
 


@@ -1323,161 +1143,11 @@ void wxPropertyGrid::SetCaptionTextColour( const wxColour& col )
     m_colCapFore = col;
     m_coloursCustomized |= 0x04;
 
     m_colCapFore = col;
     m_coloursCustomized |= 0x04;
 

-    // Set the cached colour as well.
-    ((wxPGColour*)m_arrFgCols.Item(1))->SetColour2(col);
+    m_categoryDefaultCell.GetData()->SetFgCol(col);

 
     Refresh();
 }
 
 
     Refresh();
 }
 

-// -----------------------------------------------------------------------
-
-void wxPropertyGrid::SetBackgroundColourIndex( wxPGProperty* p, int index )
-{
-    unsigned char ind = index;
-
-    p->m_bgColIndex = ind;
-
-    unsigned int i;
-    for ( i=0; i<p->GetChildCount(); i++ )
-        SetBackgroundColourIndex(p->Item(i),index);
-}
-
-// -----------------------------------------------------------------------
-
-void wxPropertyGrid::SetPropertyBackgroundColour( wxPGPropArg id, const wxColour& colour )
-{
-    wxPG_PROP_ARG_CALL_PROLOG()
-
-    size_t i;
-    int colInd = -1;
-
-    long colAsLong = wxPG_COLOUR(colour.Red(),colour.Green(),colour.Blue());
-
-    // As it is most likely that the previous colour is used, start comparison
-    // from the end.
-    for ( i=(m_arrBgBrushes.size()-1); i>0; i-- )
-    {
-        if ( ((wxPGBrush*)m_arrBgBrushes.Item(i))->GetColourAsLong() == colAsLong )
-        {
-            colInd = i;
-            break;
-        }
-    }
-
-    if ( colInd < 0 )
-    {
-        colInd = m_arrBgBrushes.size();
-        wxCHECK_RET( colInd < 256, wxT("wxPropertyGrid: Warning - Only 255 different property background colours allowed.") );
-        m_arrBgBrushes.Add( (void*)new wxPGBrush(colour) );
-    }
-
-    // Set indexes
-    SetBackgroundColourIndex(p,colInd);
-
-    // If this was on a visible grid, then draw it.
-    DrawItemAndChildren(p);
-}
-
-// -----------------------------------------------------------------------
-
-wxColour wxPropertyGrid::GetPropertyBackgroundColour( wxPGPropArg id ) const
-{
-    wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxColour())
-
-    return ((wxPGBrush*)m_arrBgBrushes.Item(p->m_bgColIndex))->GetColour();
-}
-
-// -----------------------------------------------------------------------
-
-void wxPropertyGrid::SetTextColourIndex( wxPGProperty* p, int index, int flags )
-{
-    unsigned char ind = index;
-
-    p->m_fgColIndex = ind;
-
-    if ( p->GetChildCount() && (flags & wxPG_RECURSE) )
-    {
-        unsigned int i;
-        for ( i=0; i<p->GetChildCount(); i++ )
-            SetTextColourIndex( p->Item(i), index, flags );
-    }
-}
-
-// -----------------------------------------------------------------------
-
-int wxPropertyGrid::CacheColour( const wxColour& colour )
-{
-    unsigned int i;
-    int colInd = -1;
-
-    long colAsLong = wxPG_COLOUR(colour.Red(),colour.Green(),colour.Blue());
-
-    // As it is most likely that the previous colour is used, start comparison
-    // from the end.
-    for ( i=(m_arrFgCols.size()-1); i>0; i-- )
-    {
-        if ( ((wxPGColour*)m_arrFgCols.Item(i))->GetColourAsLong() == colAsLong )
-        {
-            colInd = i;
-            break;
-        }
-    }
-
-    if ( colInd < 0 )
-    {
-        colInd = m_arrFgCols.size();
-        wxCHECK_MSG( colInd < 256, 0, wxT("wxPropertyGrid: Warning - Only 255 different property foreground colours allowed.") );
-        m_arrFgCols.Add( (void*)new wxPGColour(colour) );
-    }
-
-    return colInd;
-}
-
-// -----------------------------------------------------------------------
-
-void wxPropertyGrid::SetPropertyTextColour( wxPGPropArg id, const wxColour& colour,
-                                            bool recursively )
-{
-    wxPG_PROP_ARG_CALL_PROLOG()
-
-    if ( p->IsCategory() )
-    {
-        wxPropertyCategory* cat = (wxPropertyCategory*) p;
-        cat->SetTextColIndex(CacheColour(colour));
-    }
-
-    // Set indexes
-    int flags = 0;
-    if ( recursively )
-        flags |= wxPG_RECURSE;
-    SetTextColourIndex(p, CacheColour(colour), flags);
-
-    DrawItemAndChildren(p);
-}
-
-// -----------------------------------------------------------------------
-
-wxColour wxPropertyGrid::GetPropertyTextColour( wxPGPropArg id ) const
-{
-    wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxColour())
-
-    return wxColour(*((wxPGColour*)m_arrFgCols.Item(p->m_fgColIndex)));
-}
-
-void wxPropertyGrid::SetPropertyColoursToDefault( wxPGPropArg id )
-{
-    wxPG_PROP_ARG_CALL_PROLOG()
-
-    SetBackgroundColourIndex( p, 0 );
-    SetTextColourIndex( p, 0, wxPG_RECURSE );
-
-    if ( p->IsCategory() )
-    {
-        wxPropertyCategory* cat = (wxPropertyCategory*) p;
-        cat->SetTextColIndex(1);
-    }
-}
-

 // -----------------------------------------------------------------------
 // wxPropertyGrid property adding and removal
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // wxPropertyGrid property adding and removal
 // -----------------------------------------------------------------------


@@ -1489,44 +1159,15 @@ void wxPropertyGrid::PrepareAfterItemsAdded()
     m_pState->m_itemsAdded = 0;
 
     if ( m_windowStyle & wxPG_AUTO_SORT )
     m_pState->m_itemsAdded = 0;
 
     if ( m_windowStyle & wxPG_AUTO_SORT )

-        Sort();
+        Sort(wxPG_SORT_TOP_LEVEL_ONLY);

 
     RecalculateVirtualSize();
 }
 
 
     RecalculateVirtualSize();
 }
 

-// -----------------------------------------------------------------------
-// wxPropertyGrid property value setting and getting
-// -----------------------------------------------------------------------
-
-void wxPropertyGrid::DoSetPropertyValueUnspecified( wxPGProperty* p )
-{
-    m_pState->DoSetPropertyValueUnspecified(p);
-    DrawItemAndChildren(p);
-
-    wxPGProperty* parent = p->GetParent();
-    while ( (parent->GetFlags() & wxPG_PROP_PARENTAL_FLAGS) == wxPG_PROP_MISC_PARENT )
-    {
-        DrawItem(parent);
-        parent = parent->GetParent();
-    }
-}
-

 // -----------------------------------------------------------------------
 // wxPropertyGrid property operations
 // -----------------------------------------------------------------------
 
 // -----------------------------------------------------------------------
 // wxPropertyGrid property operations
 // -----------------------------------------------------------------------
 

-void wxPropertyGrid::DoSetPropertyName( wxPGProperty* p, const wxString& newname )
-{
-    wxCHECK_RET( p, wxT("invalid property id") );
-
-    if ( p->GetBaseName().Len() ) m_pState->m_dictName.erase( p->GetBaseName() );
-    if ( newname.Len() ) m_pState->m_dictName[newname] = (void*) p;
-
-    p->DoSetName(newname);
-}
-
-// -----------------------------------------------------------------------
-

 bool wxPropertyGrid::EnsureVisible( wxPGPropArg id )
 {
     wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
 bool wxPropertyGrid::EnsureVisible( wxPGPropArg id )
 {
     wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)


@@ -1643,7 +1284,7 @@ wxString& wxPropertyGrid::ExpandEscapeSequences( wxString& dst_str, wxString& sr
 
     dst_str.clear();
 
 
     dst_str.clear();
 

-    for ( ; i != src_str.end(); i++ )
+    for ( ; i != src_str.end(); ++i )

     {
         wxUniChar a = *i;
 
     {
         wxUniChar a = *i;
 


@@ -1701,7 +1342,7 @@ wxString& wxPropertyGrid::CreateEscapeSequences( wxString& dst_str, wxString& sr
 
     dst_str.clear();
 
 
     dst_str.clear();
 

-    for ( ; i != src_str.end(); i++ )
+    for ( ; i != src_str.end(); ++i )

     {
         wxChar a = *i;
 
     {
         wxChar a = *i;
 


@@ -1742,7 +1383,7 @@ wxPGProperty* wxPropertyGrid::DoGetItemAtY( int y ) const
 {
     // Outside?
     if ( y < 0 )
 {
     // Outside?
     if ( y < 0 )

-        return (wxPGProperty*) NULL;
+        return NULL;

 
     unsigned int a = 0;
     return m_pState->m_properties->GetItemAtY(y, m_lineHeight, &a);
 
     unsigned int a = 0;
     return m_pState->m_properties->GetItemAtY(y, m_lineHeight, &a);


@@ -1894,7 +1535,7 @@ void wxPropertyGrid::DrawItems( wxDC& dc,
         if ( dcPtr )
         {
             dc.SetClippingRegion( *clipRect );
         if ( dcPtr )
         {
             dc.SetClippingRegion( *clipRect );

-            paintFinishY = DoDrawItems( *dcPtr, NULL, NULL, clipRect, isBuffered );
+            paintFinishY = DoDrawItems( *dcPtr, clipRect, isBuffered );

         }
 
     #if wxPG_DOUBLE_BUFFER
         }
 
     #if wxPG_DOUBLE_BUFFER


@@ -1920,30 +1561,17 @@ void wxPropertyGrid::DrawItems( wxDC& dc,
 // -----------------------------------------------------------------------
 
 int wxPropertyGrid::DoDrawItems( wxDC& dc,
 // -----------------------------------------------------------------------
 
 int wxPropertyGrid::DoDrawItems( wxDC& dc,

-                                 const wxPGProperty* firstItem,
-                                 const wxPGProperty* lastItem,

                                  const wxRect* clipRect,
                                  bool isBuffered ) const
 {
                                  const wxRect* clipRect,
                                  bool isBuffered ) const
 {

-    // TODO: This should somehow be eliminated.
-    wxRect tempClipRect;
-    if ( !clipRect )
-    {
-        wxASSERT(firstItem);
-        wxASSERT(lastItem);
-        tempClipRect = GetPropertyRect(firstItem, lastItem);
-        clipRect = &tempClipRect;
-    }
+    const wxPGProperty* firstItem;
+    const wxPGProperty* lastItem;

 
 

-    if ( !firstItem )
-        firstItem = DoGetItemAtY(clipRect->y);
+    firstItem = DoGetItemAtY(clipRect->y);
+    lastItem = DoGetItemAtY(clipRect->y+clipRect->height-1);

 
     if ( !lastItem )
 
     if ( !lastItem )

-    {
-        lastItem = DoGetItemAtY(clipRect->y+clipRect->height-1);
-        if ( !lastItem )
-            lastItem = GetLastItem( wxPG_ITERATE_VISIBLE );
-    }
+        lastItem = GetLastItem( wxPG_ITERATE_VISIBLE );

 
     if ( m_frozen || m_height < 1 || firstItem == NULL )
         return clipRect->y;
 
     if ( m_frozen || m_height < 1 || firstItem == NULL )
         return clipRect->y;


@@ -2002,13 +1630,10 @@ int wxPropertyGrid::DoDrawItems( wxDC& dc,
 
         //
         // clipRect conversion
 
         //
         // clipRect conversion

-        if ( clipRect )
-        {
-            cr2 = *clipRect;
-            cr2.x -= xRelMod;
-            cr2.y -= yRelMod;
-            clipRect = &cr2;
-        }
+        cr2 = *clipRect;
+        cr2.x -= xRelMod;
+        cr2.y -= yRelMod;
+        clipRect = &cr2;

         firstItemTopY -= yRelMod;
         lastItemBottomY -= yRelMod;
     }
         firstItemTopY -= yRelMod;
         lastItemBottomY -= yRelMod;
     }


@@ -2018,9 +1643,9 @@ int wxPropertyGrid::DoDrawItems( wxDC& dc,
 
     int x = m_marginWidth - xRelMod;
 
 
     int x = m_marginWidth - xRelMod;
 

-    const wxFont& normalfont = m_font;
+    wxFont normalFont = GetFont();

 
 

-    bool reallyFocused = (m_iFlags & wxPG_FL_FOCUSED) ? true : false;
+    bool reallyFocused = (m_iFlags & wxPG_FL_FOCUSED) != 0;

 
     bool isEnabled = IsEnabled();
 
 
     bool isEnabled = IsEnabled();
 


@@ -2055,7 +1680,7 @@ int wxPropertyGrid::DoDrawItems( wxDC& dc,
 
     // TODO: Only render columns that are within clipping region.
 
 
     // TODO: Only render columns that are within clipping region.
 

-    dc.SetFont(normalfont);
+    dc.SetFont(normalFont);

 
     wxPropertyGridConstIterator it( state, wxPG_ITERATE_VISIBLE, firstItem );
     int endScanBottomY = lastItemBottomY + lh;
 
     wxPropertyGridConstIterator it( state, wxPG_ITERATE_VISIBLE, firstItem );
     int endScanBottomY = lastItemBottomY + lh;


@@ -2097,7 +1722,7 @@ int wxPropertyGrid::DoDrawItems( wxDC& dc,
 
         int rowHeight = m_fontHeight+(m_spacingy*2)+1;
         int textMarginHere = x;
 
         int rowHeight = m_fontHeight+(m_spacingy*2)+1;
         int textMarginHere = x;

-        int renderFlags = wxPGCellRenderer::Control;
+        int renderFlags = 0;

 
         int greyDepth = m_marginWidth;
         if ( !(windowStyle & wxPG_HIDE_CATEGORIES) )
 
         int greyDepth = m_marginWidth;
         if ( !(windowStyle & wxPG_HIDE_CATEGORIES) )


@@ -2141,77 +1766,103 @@ int wxPropertyGrid::DoDrawItems( wxDC& dc,
 
         dc.DrawLine( greyDepthX, y2-1, gridWidth-xRelMod, y2-1 );
 
 
         dc.DrawLine( greyDepthX, y2-1, gridWidth-xRelMod, y2-1 );
 

-        if ( p == selected )
-        {
-            renderFlags |= wxPGCellRenderer::Selected;
-#if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
-            wasSelectedPainted = true;
-#endif
-        }
-
-        wxColour rowBgCol;
+        //
+        // Need to override row colours?

         wxColour rowFgCol;
         wxColour rowFgCol;

-        wxBrush rowBgBrush;
+        wxColour rowBgCol;

 
 

-        if ( p->IsCategory() )
-        {
-            if ( p->m_fgColIndex == 0 )
-                rowFgCol = m_colCapFore;
-            else
-                rowFgCol = *(wxPGColour*)m_arrFgCols[p->m_fgColIndex];
-            rowBgBrush = wxBrush(m_colCapBack);
-        }
-        else if ( p != selected )
+        if ( p != selected )

         {
             // Disabled may get different colour.
             if ( !p->IsEnabled() )
         {
             // Disabled may get different colour.
             if ( !p->IsEnabled() )

-                rowFgCol = m_colDisPropFore;
-            else
-                rowFgCol = *(wxPGColour*)m_arrFgCols[p->m_fgColIndex];
-
-            rowBgBrush = *(wxPGBrush*)m_arrBgBrushes[p->m_bgColIndex];
-        }
-        else
-        {
-            // Selected gets different colour.
-            if ( reallyFocused )
-            {
-                rowFgCol = m_colSelFore;
-                rowBgBrush = wxBrush(m_colSelBack);
-            }
-            else if ( isEnabled )
-            {
-                rowFgCol = *(wxPGColour*)m_arrFgCols[p->m_fgColIndex];
-                rowBgBrush = marginBrush;
-            }
-            else

             {
             {

+                renderFlags |= wxPGCellRenderer::Disabled |
+                               wxPGCellRenderer::DontUseCellFgCol;

                 rowFgCol = m_colDisPropFore;
                 rowFgCol = m_colDisPropFore;

-                rowBgBrush = wxBrush(m_colSelBack);

             }
         }
             }
         }

+        else
+        {
+            renderFlags |= wxPGCellRenderer::Selected;

 
 

-        bool fontChanged = false;
+            if ( !p->IsCategory() )
+            {
+                renderFlags |= wxPGCellRenderer::DontUseCellFgCol |
+                               wxPGCellRenderer::DontUseCellBgCol;

 
 

-        wxRect butRect( ((p->m_depth - 1) * m_subgroup_extramargin) - xRelMod,
-                        y,
-                        m_marginWidth,
-                        lh );
+#if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
+                wasSelectedPainted = true;
+#endif
+
+                // Selected gets different colour.
+                if ( reallyFocused )
+                {
+                    rowFgCol = m_colSelFore;
+                    rowBgCol = m_colSelBack;
+                }
+                else if ( isEnabled )
+                {
+                    rowFgCol = m_colPropFore;
+                    rowBgCol = m_colMargin;
+                }
+                else
+                {
+                    rowFgCol = m_colDisPropFore;
+                    rowBgCol = m_colSelBack;
+                }
+            }
+        }
+
+        wxBrush rowBgBrush;
+
+        if ( rowBgCol.IsOk() )
+            rowBgBrush = wxBrush(rowBgCol);
+
+        if ( HasInternalFlag(wxPG_FL_CELL_OVERRIDES_SEL) )
+            renderFlags = renderFlags & ~wxPGCellRenderer::DontUseCellColours;
+
+        //
+        // Fill additional margin area with background colour of first cell
+        if ( greyDepthX < textMarginHere )
+        {
+            if ( !(renderFlags & wxPGCellRenderer::DontUseCellBgCol) )
+            {
+                wxPGCell& cell = p->GetCell(0);
+                rowBgCol = cell.GetBgCol();
+                rowBgBrush = wxBrush(rowBgCol);
+            }
+            dc.SetBrush(rowBgBrush);
+            dc.SetPen(rowBgCol);
+            dc.DrawRectangle(greyDepthX+1, y,
+                             textMarginHere-greyDepthX, lh-1);
+        }
+
+        bool fontChanged = false;
+
+        // Expander button rectangle
+        wxRect butRect( ((p->m_depth - 1) * m_subgroup_extramargin) - xRelMod,
+                        y,
+                        m_marginWidth,
+                        lh );

 
         if ( p->IsCategory() )
         {
 
         if ( p->IsCategory() )
         {

-            // Captions are all cells merged as one
+            // Captions have their cell areas merged as one

             dc.SetFont(m_captionFont);
             fontChanged = true;
             wxRect cellRect(greyDepthX, y, gridWidth - greyDepth + 2, rowHeight-1 );
 
             dc.SetFont(m_captionFont);
             fontChanged = true;
             wxRect cellRect(greyDepthX, y, gridWidth - greyDepth + 2, rowHeight-1 );
 

-            dc.SetBrush(rowBgBrush);
-            dc.SetPen(rowBgBrush.GetColour());
-            dc.SetTextForeground(rowFgCol);
+            if ( renderFlags & wxPGCellRenderer::DontUseCellBgCol )
+            {
+                dc.SetBrush(rowBgBrush);
+                dc.SetPen(rowBgCol);
+            }

 
 

-            dc.DrawRectangle(cellRect);
+            if ( renderFlags & wxPGCellRenderer::DontUseCellFgCol )
+            {
+                dc.SetTextForeground(rowFgCol);
+            }

 
 

-            // Foreground

             wxPGCellRenderer* renderer = p->GetCellRenderer(0);
             renderer->Render( dc, cellRect, this, p, 0, -1, renderFlags );
 
             wxPGCellRenderer* renderer = p->GetCellRenderer(0);
             renderer->Render( dc, cellRect, this, p, 0, -1, renderFlags );
 


@@ -2229,7 +1880,8 @@ int wxPropertyGrid::DoDrawItems( wxDC& dc,
 
             unsigned int ci;
             int cellX = x + 1;
 
             unsigned int ci;
             int cellX = x + 1;

-            int nextCellWidth = state->m_colWidths[0];
+            int nextCellWidth = state->m_colWidths[0] -
+                                (greyDepthX - m_marginWidth);

             wxRect cellRect(greyDepthX+1, y, 0, rowHeight-1);
             int textXAdd = textMarginHere - greyDepthX;
 
             wxRect cellRect(greyDepthX+1, y, 0, rowHeight-1);
             int textXAdd = textMarginHere - greyDepthX;
 


@@ -2238,6 +1890,11 @@ int wxPropertyGrid::DoDrawItems( wxDC& dc,
                 cellRect.width = nextCellWidth - 1;
 
                 bool ctrlCell = false;
                 cellRect.width = nextCellWidth - 1;
 
                 bool ctrlCell = false;

+                int cellRenderFlags = renderFlags;
+
+                // Tree Item Button
+                if ( ci == 0 && !HasFlag(wxPG_HIDE_MARGIN) && p->HasVisibleChildren() )
+                    DrawExpanderButton( dc, butRect, p );

 
                 // Background
                 if ( p == selected && m_wndEditor && ci == 1 )
 
                 // Background
                 if ( p == selected && m_wndEditor && ci == 1 )


@@ -2246,22 +1903,24 @@ int wxPropertyGrid::DoDrawItems( wxDC& dc,
                     dc.SetBrush(editorBgCol);
                     dc.SetPen(editorBgCol);
                     dc.SetTextForeground(m_colPropFore);
                     dc.SetBrush(editorBgCol);
                     dc.SetPen(editorBgCol);
                     dc.SetTextForeground(m_colPropFore);

+                    dc.DrawRectangle(cellRect);

 
                     if ( m_dragStatus == 0 && !(m_iFlags & wxPG_FL_CUR_USES_CUSTOM_IMAGE) )
                         ctrlCell = true;
                 }
                 else
                 {
 
                     if ( m_dragStatus == 0 && !(m_iFlags & wxPG_FL_CUR_USES_CUSTOM_IMAGE) )
                         ctrlCell = true;
                 }
                 else
                 {

-                    dc.SetBrush(rowBgBrush);
-                    dc.SetPen(rowBgBrush.GetColour());
-                    dc.SetTextForeground(rowFgCol);
-                }
-
-                dc.DrawRectangle(cellRect);
+                    if ( renderFlags & wxPGCellRenderer::DontUseCellBgCol )
+                    {
+                        dc.SetBrush(rowBgBrush);
+                        dc.SetPen(rowBgCol);
+                    }

 
 

-                // Tree Item Button
-                if ( ci == 0 && !HasFlag(wxPG_HIDE_MARGIN) && p->HasVisibleChildren() )
-                    DrawExpanderButton( dc, butRect, p );
+                    if ( renderFlags & wxPGCellRenderer::DontUseCellFgCol )
+                    {
+                        dc.SetTextForeground(rowFgCol);
+                    }
+                }

 
                 dc.SetClippingRegion(cellRect);
 
 
                 dc.SetClippingRegion(cellRect);
 


@@ -2276,26 +1935,28 @@ int wxPropertyGrid::DoDrawItems( wxDC& dc,
                     if ( cmnVal == -1 || ci != 1 )
                     {
                         renderer = p->GetCellRenderer(ci);
                     if ( cmnVal == -1 || ci != 1 )
                     {
                         renderer = p->GetCellRenderer(ci);

-                        renderer->Render( dc, cellRect, this, p, ci, -1, renderFlags );
+                        renderer->Render( dc, cellRect, this, p, ci, -1,
+                                          cellRenderFlags );

                     }
                     else
                     {
                         renderer = GetCommonValue(cmnVal)->GetRenderer();
                     }
                     else
                     {
                         renderer = GetCommonValue(cmnVal)->GetRenderer();

-                        renderer->Render( dc, cellRect, this, p, ci, -1, renderFlags );
+                        renderer->Render( dc, cellRect, this, p, ci, -1,
+                                          cellRenderFlags );

                     }
                 }
 
                 cellX += state->m_colWidths[ci];
                 if ( ci < (state->m_colWidths.size()-1) )
                     nextCellWidth = state->m_colWidths[ci+1];
                     }
                 }
 
                 cellX += state->m_colWidths[ci];
                 if ( ci < (state->m_colWidths.size()-1) )
                     nextCellWidth = state->m_colWidths[ci+1];

-                cellRect.x = cellX; 
+                cellRect.x = cellX;

                 dc.DestroyClippingRegion(); // Is this really necessary?
                 textXAdd = 0;
             }
         }
 
         if ( fontChanged )
                 dc.DestroyClippingRegion(); // Is this really necessary?
                 textXAdd = 0;
             }
         }
 
         if ( fontChanged )

-            dc.SetFont(normalfont);
+            dc.SetFont(normalFont);

 
         y += rowHeight;
     }
 
         y += rowHeight;
     }


@@ -2323,7 +1984,7 @@ wxRect wxPropertyGrid::GetPropertyRect( const wxPGProperty* p1, const wxPGProper
 
     if ( m_width < 10 || m_height < 10 ||
          !m_pState->m_properties->GetChildCount() ||
 
     if ( m_width < 10 || m_height < 10 ||
          !m_pState->m_properties->GetChildCount() ||

-         p1 == (wxPGProperty*) NULL )
+         p1 == NULL )

         return wxRect(0,0,0,0);
 
     int vy = 0;
         return wxRect(0,0,0,0);
 
     int vy = 0;


@@ -2419,11 +2080,9 @@ void wxPropertyGrid::DrawItemAndChildren( wxPGProperty* p )
     if ( m_pState->m_itemsAdded || m_frozen )
         return;
 
     if ( m_pState->m_itemsAdded || m_frozen )
         return;
 

-    wxWindow* wndPrimary = GetEditorControl();
-

     // Update child control.
     if ( m_selected && m_selected->GetParent() == p )
     // Update child control.
     if ( m_selected && m_selected->GetParent() == p )

-        m_selected->UpdateControl(wndPrimary);
+        RefreshEditor();

 
     const wxPGProperty* lastDrawn = p->GetLastVisibleSubItem();
 
 
     const wxPGProperty* lastDrawn = p->GetLastVisibleSubItem();
 


@@ -2455,13 +2114,6 @@ void wxPropertyGrid::Refresh( bool WXUNUSED(eraseBackground),
 
 void wxPropertyGrid::Clear()
 {
 
 void wxPropertyGrid::Clear()
 {

-    if ( m_selected )
-    {
-        bool selRes = DoSelectProperty(NULL, wxPG_SEL_DELETING);  // This must be before state clear
-        wxPG_CHECK_RET_DBG( selRes,
-                            wxT("failed to deselect a property (editor probably had invalid value)") );
-    }
-

     m_pState->DoClear();
 
     m_propHover = NULL;
     m_pState->DoClear();
 
     m_propHover = NULL;


@@ -2479,8 +2131,7 @@ void wxPropertyGrid::Clear()
 
 bool wxPropertyGrid::EnableCategories( bool enable )
 {
 
 bool wxPropertyGrid::EnableCategories( bool enable )
 {

-    if ( !ClearSelection() )
-        return false;
+    ClearSelection(false);

 
     if ( enable )
     {
 
     if ( enable )
     {


@@ -2532,13 +2183,7 @@ void wxPropertyGrid::SwitchState( wxPropertyGridPageState* pNewState )
 
     wxPGProperty* oldSelection = m_selected;
 
 
     wxPGProperty* oldSelection = m_selected;
 

-    // Deselect
-    if ( m_selected )
-    {
-        bool selRes = ClearSelection();
-        wxPG_CHECK_RET_DBG( selRes,
-                            wxT("failed to deselect a property (editor probably had invalid value)") );
-    }
+    ClearSelection(false);

 
     m_pState->m_selected = oldSelection;
 
 
     m_pState->m_selected = oldSelection;
 


@@ -2568,7 +2213,7 @@ void wxPropertyGrid::SwitchState( wxPropertyGridPageState* pNewState )
         pNewState->OnClientWidthChange( pgWidth, pgWidth - pNewState->m_width );
     }
 
         pNewState->OnClientWidthChange( pgWidth, pgWidth - pNewState->m_width );
     }
 

-    m_propHover = (wxPGProperty*) NULL;
+    m_propHover = NULL;

 
     // If necessary, convert state to correct mode.
     if ( orig_mode != new_state_mode )
 
     // If necessary, convert state to correct mode.
     if ( orig_mode != new_state_mode )


@@ -2579,8 +2224,7 @@ void wxPropertyGrid::SwitchState( wxPropertyGridPageState* pNewState )
     else if ( !m_frozen )
     {
         // Refresh, if not frozen.
     else if ( !m_frozen )
     {
         // Refresh, if not frozen.

-        if ( m_pState->m_itemsAdded )
-            PrepareAfterItemsAdded();
+        m_pState->PrepareAfterItemsAdded();

 
         // Reselect
         if ( m_pState->m_selected )
 
         // Reselect
         if ( m_pState->m_selected )


@@ -2595,26 +2239,6 @@ void wxPropertyGrid::SwitchState( wxPropertyGridPageState* pNewState )
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 

-void wxPropertyGrid::SortChildren( wxPGPropArg id )
-{
-    wxPG_PROP_ARG_CALL_PROLOG()
-
-    m_pState->SortChildren( p );
-}
-
-// -----------------------------------------------------------------------
-
-void wxPropertyGrid::Sort()
-{
-    bool selRes = ClearSelection();  // This must be before state clear
-    wxPG_CHECK_RET_DBG( selRes,
-                        wxT("failed to deselect a property (editor probably had invalid value)") );
-
-    m_pState->Sort();
-}
-
-// -----------------------------------------------------------------------
-

 // Call to SetSplitterPosition will always disable splitter auto-centering
 // if parent window is shown.
 void wxPropertyGrid::DoSetSplitterPosition_( int newxpos, bool refresh, int splitterIndex, bool allPages )
 // Call to SetSplitterPosition will always disable splitter auto-centering
 // if parent window is shown.
 void wxPropertyGrid::DoSetSplitterPosition_( int newxpos, bool refresh, int splitterIndex, bool allPages )


@@ -2676,24 +2300,6 @@ wxPGProperty* wxPropertyGrid::GetNearestPaintVisible( wxPGProperty* p ) const
 
 }
 
 
 }
 

-// -----------------------------------------------------------------------
-
-void wxPropertyGrid::SetButtonShortcut( int keycode, bool ctrlDown, bool altDown )
-{
-    if ( keycode )
-    {
-        m_pushButKeyCode = keycode;
-        m_pushButKeyCodeNeedsCtrl = ctrlDown ? 1 : 0;
-        m_pushButKeyCodeNeedsAlt = altDown ? 1 : 0;
-    }
-    else
-    {
-        m_pushButKeyCode = WXK_DOWN;
-        m_pushButKeyCodeNeedsCtrl = 0;
-        m_pushButKeyCodeNeedsAlt = 1;
-    }
-}
-

 // -----------------------------------------------------------------------
 // Methods related to change in value, value modification and sending events
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // Methods related to change in value, value modification and sending events
 // -----------------------------------------------------------------------


@@ -2709,7 +2315,7 @@ bool wxPropertyGrid::CommitChangesFromEditor( wxUint32 flags )
 
     // Don't do this if already processing editor event. It might
     // induce recursive dialogs and crap like that.
 
     // Don't do this if already processing editor event. It might
     // induce recursive dialogs and crap like that.

-    if ( m_iFlags & wxPG_FL_IN_ONCUSTOMEDITOREVENT )
+    if ( m_iFlags & wxPG_FL_IN_HANDLECUSTOMEDITOREVENT )

     {
         if ( m_inDoPropertyChanged )
             return true;
     {
         if ( m_inDoPropertyChanged )
             return true;


@@ -2789,7 +2395,8 @@ bool wxPropertyGrid::CommitChangesFromEditor( wxUint32 flags )
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 

-bool wxPropertyGrid::PerformValidation( wxPGProperty* p, wxVariant& pendingValue )
+bool wxPropertyGrid::PerformValidation( wxPGProperty* p, wxVariant& pendingValue,
+                                        int flags )

 {
     //
     // Runs all validation functionality.
 {
     //
     // Runs all validation functionality.


@@ -2858,33 +2465,37 @@ bool wxPropertyGrid::PerformValidation( wxPGProperty* p, wxVariant& pendingValue
 
     wxVariant evtChangingValue = value;
 
 
     wxVariant evtChangingValue = value;
 

-    // FIXME: After proper ValueToString()s added, remove
-    // this. It is just a temporary fix, as evt_changing
-    // will simply not work for wxPG_PROP_COMPOSED_VALUE
-    // (unless it is selected, and textctrl editor is open).
-    if ( changedProperty->HasFlag(wxPG_PROP_COMPOSED_VALUE) )
+    if ( flags & SendEvtChanging )

     {
     {

-        evtChangingProperty = baseChangedProperty;
-        if ( evtChangingProperty != p )
-        {
-            evtChangingProperty->AdaptListToValue( bcpPendingList, &evtChangingValue );
-        }
-        else
+        // FIXME: After proper ValueToString()s added, remove
+        // this. It is just a temporary fix, as evt_changing
+        // will simply not work for wxPG_PROP_COMPOSED_VALUE
+        // (unless it is selected, and textctrl editor is open).
+        if ( changedProperty->HasFlag(wxPG_PROP_COMPOSED_VALUE) )

         {
         {

-            evtChangingValue = pendingValue;
+            evtChangingProperty = baseChangedProperty;
+            if ( evtChangingProperty != p )
+            {
+                evtChangingProperty->AdaptListToValue( bcpPendingList, &evtChangingValue );
+            }
+            else
+            {
+                evtChangingValue = pendingValue;
+            }

         }
         }

-    }

 
 

-    if ( evtChangingProperty->HasFlag(wxPG_PROP_COMPOSED_VALUE) )
-    {
-        if ( changedProperty == m_selected )
+        if ( evtChangingProperty->HasFlag(wxPG_PROP_COMPOSED_VALUE) )

         {
         {

-            wxASSERT( m_wndEditor->IsKindOf(CLASSINFO(wxTextCtrl)) );
-            evtChangingValue = ((wxTextCtrl*)m_wndEditor)->GetValue();
-        }
-        else
-        {
-            wxLogDebug(wxT("WARNING: wxEVT_PG_CHANGING is about to happen with old value."));
+            if ( changedProperty == m_selected )
+            {
+                wxWindow* editor = GetEditorControl();
+                wxASSERT( editor->IsKindOf(CLASSINFO(wxTextCtrl)) );
+                evtChangingValue = wxStaticCast(editor, wxTextCtrl)->GetValue();
+            }
+            else
+            {
+                wxLogDebug(wxT("WARNING: wxEVT_PG_CHANGING is about to happen with old value."));
+            }

         }
     }
 
         }
     }
 


@@ -2906,9 +2517,20 @@ bool wxPropertyGrid::PerformValidation( wxPGProperty* p, wxVariant& pendingValue
             return false;
     }
 
             return false;
     }
 

-    // SendEvent returns true if event was vetoed
-    if ( SendEvent( wxEVT_PG_CHANGING, evtChangingProperty, &evtChangingValue, 0 ) )
-        return false;
+    if ( flags & SendEvtChanging )
+    {
+        // SendEvent returns true if event was vetoed
+        if ( SendEvent( wxEVT_PG_CHANGING, evtChangingProperty, &evtChangingValue, 0 ) )
+            return false;
+    }
+
+    if ( flags & IsStandaloneValidation )
+    {
+        // If called in 'generic' context, we need to reset
+        // m_chgInfo_changedProperty and write back translated value.
+        m_chgInfo_changedProperty = NULL;
+        pendingValue = value;
+    }

 
     return true;
 }
 
     return true;
 }


@@ -2945,6 +2567,29 @@ void wxPropertyGrid::DoShowPropertyError( wxPGProperty* WXUNUSED(property), cons
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 

+bool wxPropertyGrid::OnValidationFailure( wxPGProperty* property,
+                                          wxVariant& invalidValue )
+{
+    wxWindow* editor = GetEditorControl();
+
+    // First call property's handler
+    property->OnValidationFailure(invalidValue);
+
+    bool res = DoOnValidationFailure(property, invalidValue);
+
+    //
+    // For non-wxTextCtrl editors, we do need to revert the value
+    if ( !editor->IsKindOf(CLASSINFO(wxTextCtrl)) &&
+         property == m_selected )
+    {
+        property->GetEditorClass()->UpdateControl(property, editor);
+    }
+
+    property->SetFlag(wxPG_PROP_INVALID_VALUE);
+
+    return res;
+}
+

 bool wxPropertyGrid::DoOnValidationFailure( wxPGProperty* property, wxVariant& WXUNUSED(invalidValue) )
 {
     int vfb = m_validationInfo.m_failureBehavior;
 bool wxPropertyGrid::DoOnValidationFailure( wxPGProperty* property, wxVariant& WXUNUSED(invalidValue) )
 {
     int vfb = m_validationInfo.m_failureBehavior;


@@ -2955,28 +2600,34 @@ bool wxPropertyGrid::DoOnValidationFailure( wxPGProperty* property, wxVariant& W
     if ( (vfb & wxPG_VFB_MARK_CELL) &&
          !property->HasFlag(wxPG_PROP_INVALID_VALUE) )
     {
     if ( (vfb & wxPG_VFB_MARK_CELL) &&
          !property->HasFlag(wxPG_PROP_INVALID_VALUE) )
     {

-        wxASSERT_MSG( !property->GetCell(0) && !property->GetCell(1),
-                      wxT("Currently wxPG_VFB_MARK_CELL only works with properties with standard first two cells") );
+        unsigned int colCount = m_pState->GetColumnCount();
+
+        // We need backup marked property's cells
+        m_propCellsBackup = property->m_cells;
+
+        wxColour vfbFg = *wxWHITE;
+        wxColour vfbBg = *wxRED;

 
 

-        if ( !property->GetCell(0) && !property->GetCell(1) )
+        property->EnsureCells(colCount);
+
+        for ( unsigned int i=0; i<colCount; i++ )

         {
         {

-            wxColour vfbFg = *wxWHITE;
-            wxColour vfbBg = *wxRED;
-            property->SetCell(0, new wxPGCell(property->GetLabel(), wxNullBitmap, vfbFg, vfbBg));
-            property->SetCell(1, new wxPGCell(property->GetDisplayedString(), wxNullBitmap, vfbFg, vfbBg));
+            wxPGCell& cell = property->m_cells[i];
+            cell.SetFgCol(vfbFg);
+            cell.SetBgCol(vfbBg);
+        }

 
 

-            DrawItemAndChildren(property);
+        DrawItemAndChildren(property);

 
 

-            if ( property == m_selected )
-            {
-                SetInternalFlag(wxPG_FL_CELL_OVERRIDES_SEL);
+        if ( property == m_selected )
+        {
+            SetInternalFlag(wxPG_FL_CELL_OVERRIDES_SEL);

 
 

-                wxWindow* editor = GetEditorControl();
-                if ( editor )
-                {
-                    editor->SetForegroundColour(vfbFg);
-                    editor->SetBackgroundColour(vfbBg);
-                }
+            wxWindow* editor = GetEditorControl();
+            if ( editor )
+            {
+                editor->SetForegroundColour(vfbFg);
+                editor->SetBackgroundColour(vfbBg);

             }
         }
     }
             }
         }
     }


@@ -3002,8 +2653,8 @@ void wxPropertyGrid::DoOnValidationFailureReset( wxPGProperty* property )
 
     if ( vfb & wxPG_VFB_MARK_CELL )
     {
 
     if ( vfb & wxPG_VFB_MARK_CELL )
     {

-        property->SetCell(0, NULL);
-        property->SetCell(1, NULL);
+        // Revert cells
+        property->m_cells = m_propCellsBackup;

 
         ClearInternalFlag(wxPG_FL_CELL_OVERRIDES_SEL);
 
 
         ClearInternalFlag(wxPG_FL_CELL_OVERRIDES_SEL);
 


@@ -3089,8 +2740,7 @@ bool wxPropertyGrid::DoPropertyChanged( wxPGProperty* p, unsigned int selFlags )
     // control.
     if ( selFlags & wxPG_SEL_DIALOGVAL )
     {
     // control.
     if ( selFlags & wxPG_SEL_DIALOGVAL )
     {

-        if ( editor )
-            p->GetEditorClass()->UpdateControl(p, editor);
+        RefreshEditor();

     }
     else
     {
     }
     else
     {


@@ -3146,88 +2796,48 @@ bool wxPropertyGrid::ChangePropertyValue( wxPGPropArg id, wxVariant newValue )
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 

-// Runs wxValidator for the selected property
-bool wxPropertyGrid::DoEditorValidate()
+wxVariant wxPropertyGrid::GetUncommittedPropertyValue()

 {
 {

-#if wxUSE_VALIDATORS
-    // With traditional validator style, we dont need to more
-    if ( !(GetExtraStyle() & wxPG_EX_LEGACY_VALIDATORS) )
-        return true;
+    wxPGProperty* prop = GetSelectedProperty();

 
 

-    if ( m_iFlags & wxPG_FL_VALIDATION_FAILED )
-    {
-        return false;
-    }
+    if ( !prop )
+        return wxNullVariant;

 
 

-    wxWindow* wnd = GetEditorControl();
+    wxTextCtrl* tc = GetEditorTextCtrl();
+    wxVariant value = prop->GetValue();

 
 

-    wxValidator* validator = m_selected->GetValidator();
-    if ( validator && wnd )
-    {
-        // Use TextCtrl of ODComboBox instead
-        if ( wnd->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) )
-        {
-            wnd = ((wxOwnerDrawnComboBox*)wnd)->GetTextCtrl();
+    if ( !tc || !IsEditorsValueModified() )
+        return value;

 
 

-            if ( !wnd )
-                return true;
-        }
+    if ( !prop->StringToValue(value, tc->GetValue()) )
+        return value;

 
 

-        validator->SetWindow(wnd);
+    if ( !PerformValidation(prop, value, IsStandaloneValidation) )
+        return prop->GetValue();

 
 

-        // Instead setting the flag after the failure, we set
-        // it before checking and then clear afterwards if things
-        // went fine. This trick is necessary since focus events
-        // may be triggered while in Validate.
-        m_iFlags |= wxPG_FL_VALIDATION_FAILED;
-        if ( !validator->Validate(this) )
-        {
-            // If you dpm't want to display message multiple times per change,
-            // comment the following line.
-            m_iFlags &= ~(wxPG_FL_VALIDATION_FAILED);
-            return false;
-        }
-        m_iFlags &= ~(wxPG_FL_VALIDATION_FAILED);
-    }
-#endif
-    return true;
+    return value;

 }
 
 // -----------------------------------------------------------------------
 
 }
 
 // -----------------------------------------------------------------------
 

-bool wxPropertyGrid::ProcessEvent(wxEvent& event)
+// Runs wxValidator for the selected property
+bool wxPropertyGrid::DoEditorValidate()

 {
 {

-    wxWindow* wnd = (wxWindow*) event.GetEventObject();
-    if ( wnd && wnd->IsKindOf(CLASSINFO(wxWindow)) )
-    {
-        wxWindow* parent = wnd->GetParent();
-
-        if ( parent &&
-             (parent == m_canvas ||
-              parent->GetParent() == m_canvas) )
-        {
-            OnCustomEditorEvent((wxCommandEvent&)event);
-            return true;
-        }
-    }
-    return wxPanel::ProcessEvent(event);
+    return true;

 }
 
 // -----------------------------------------------------------------------
 
 }
 
 // -----------------------------------------------------------------------
 

-// NB: It may really not be wxCommandEvent - must check if necessary
-//     (usually not).
-void wxPropertyGrid::OnCustomEditorEvent( wxCommandEvent &event )
+void wxPropertyGrid::HandleCustomEditorEvent( wxEvent &event )

 {
     wxPGProperty* selected = m_selected;
 
 {
     wxPGProperty* selected = m_selected;
 

-    //

     // Somehow, event is handled after property has been deselected.
     // Possibly, but very rare.
     if ( !selected )
         return;
 
     // Somehow, event is handled after property has been deselected.
     // Possibly, but very rare.
     if ( !selected )
         return;
 

-    if ( m_iFlags & wxPG_FL_IN_ONCUSTOMEDITOREVENT )
+    if ( m_iFlags & wxPG_FL_IN_HANDLECUSTOMEDITOREVENT )

         return;
 
     wxVariant pendingValue(selected->GetValueRef());
         return;
 
     wxVariant pendingValue(selected->GetValueRef());


@@ -3257,7 +2867,7 @@ void wxPropertyGrid::OnCustomEditorEvent( wxCommandEvent &event )
         m_prevTcValue = newTcValue;
     }
 
         m_prevTcValue = newTcValue;
     }
 

-    SetInternalFlag(wxPG_FL_IN_ONCUSTOMEDITOREVENT);
+    SetInternalFlag(wxPG_FL_IN_HANDLECUSTOMEDITOREVENT);

 
     bool validationFailure = false;
     bool buttonWasHandled = false;
 
     bool validationFailure = false;
     bool buttonWasHandled = false;


@@ -3320,7 +2930,7 @@ void wxPropertyGrid::OnCustomEditorEvent( wxCommandEvent &event )
         if ( !PerformValidation(m_selected, pendingValue) )
             validationFailure = true;
 
         if ( !PerformValidation(m_selected, pendingValue) )
             validationFailure = true;
 

-    if ( validationFailure )
+    if ( validationFailure)

     {
         OnValidationFailure(selected, pendingValue);
     }
     {
         OnValidationFailure(selected, pendingValue);
     }


@@ -3330,11 +2940,25 @@ void wxPropertyGrid::OnCustomEditorEvent( wxCommandEvent &event )
 
         DoPropertyChanged(selected, selFlags);
         EditorsValueWasNotModified();
 
         DoPropertyChanged(selected, selFlags);
         EditorsValueWasNotModified();

+
+        // Regardless of editor type, unfocus editor on
+        // text-editing related enter press.
+        if ( event.GetEventType() == wxEVT_COMMAND_TEXT_ENTER )
+        {
+            SetFocusOnCanvas();
+        }

     }
     else
     {
         // No value after all
 
     }
     else
     {
         // No value after all
 

+        // Regardless of editor type, unfocus editor on
+        // text-editing related enter press.
+        if ( event.GetEventType() == wxEVT_COMMAND_TEXT_ENTER )
+        {
+            SetFocusOnCanvas();
+        }
+

         // Let unhandled button click events go to the parent
         if ( !buttonWasHandled && event.GetEventType() == wxEVT_COMMAND_BUTTON_CLICKED )
         {
         // Let unhandled button click events go to the parent
         if ( !buttonWasHandled && event.GetEventType() == wxEVT_COMMAND_BUTTON_CLICKED )
         {


@@ -3343,7 +2967,7 @@ void wxPropertyGrid::OnCustomEditorEvent( wxCommandEvent &event )
         }
     }
 
         }
     }
 

-    ClearInternalFlag(wxPG_FL_IN_ONCUSTOMEDITOREVENT);
+    ClearInternalFlag(wxPG_FL_IN_HANDLECUSTOMEDITOREVENT);

 }
 
 // -----------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------


@@ -3468,64 +3092,117 @@ void wxPropertyGrid::CustomSetCursor( int type, bool override )
 }
 
 // -----------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------

-// wxPropertyGrid property selection
+// wxPropertyGrid property selection, editor creation

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

-#define CONNECT_CHILD(EVT,FUNCTYPE,FUNC) \
-    wnd->Connect(id, EVT, \
-        (wxObjectEventFunction) (wxEventFunction)  \
-        FUNCTYPE (&wxPropertyGrid::FUNC), \
-        NULL, this );
-
-// Setups event handling for child control
-void wxPropertyGrid::SetupEventHandling( wxWindow* argWnd, int id )
+//
+// This class forwards events from property editor controls to wxPropertyGrid.
+class wxPropertyGridEditorEventForwarder : public wxEvtHandler

 {
 {

-    wxWindow* wnd = argWnd;
+public:
+    wxPropertyGridEditorEventForwarder( wxPropertyGrid* propGrid )
+        : wxEvtHandler(), m_propGrid(propGrid)
+    {
+    }

 
 

-    if ( argWnd == m_wndEditor )
+    virtual ~wxPropertyGridEditorEventForwarder()

     {
     {

-        CONNECT_CHILD(wxEVT_MOTION,(wxMouseEventFunction),OnMouseMoveChild)
-        CONNECT_CHILD(wxEVT_LEFT_UP,(wxMouseEventFunction),OnMouseUpChild)
-        CONNECT_CHILD(wxEVT_LEFT_DOWN,(wxMouseEventFunction),OnMouseClickChild)
-        CONNECT_CHILD(wxEVT_RIGHT_UP,(wxMouseEventFunction),OnMouseRightClickChild)
-        CONNECT_CHILD(wxEVT_ENTER_WINDOW,(wxMouseEventFunction),OnMouseEntry)
-        CONNECT_CHILD(wxEVT_LEAVE_WINDOW,(wxMouseEventFunction),OnMouseEntry)

     }
     }

-    else
+
+private:
+    bool ProcessEvent( wxEvent& event )

     {
     {

-        CONNECT_CHILD(wxEVT_NAVIGATION_KEY,(wxNavigationKeyEventFunction),OnNavigationKey)
+        // Always skip
+        event.Skip();
+
+        m_propGrid->HandleCustomEditorEvent(event);
+
+        return wxEvtHandler::ProcessEvent(event);

     }
     }

-    CONNECT_CHILD(wxEVT_KEY_DOWN,(wxCharEventFunction),OnChildKeyDown)
-    CONNECT_CHILD(wxEVT_KEY_UP,(wxCharEventFunction),OnChildKeyUp)
-    CONNECT_CHILD(wxEVT_KILL_FOCUS,(wxFocusEventFunction),OnFocusEvent)
+
+    wxPropertyGrid*         m_propGrid;
+};
+
+// Setups event handling for child control
+void wxPropertyGrid::SetupChildEventHandling( wxWindow* argWnd )
+{
+    wxWindowID id = argWnd->GetId();
+
+    if ( argWnd == m_wndEditor )
+    {
+        argWnd->Connect(id, wxEVT_MOTION,
+            wxMouseEventHandler(wxPropertyGrid::OnMouseMoveChild),
+            NULL, this);
+        argWnd->Connect(id, wxEVT_LEFT_UP,
+            wxMouseEventHandler(wxPropertyGrid::OnMouseUpChild),
+            NULL, this);
+        argWnd->Connect(id, wxEVT_LEFT_DOWN,
+            wxMouseEventHandler(wxPropertyGrid::OnMouseClickChild),
+            NULL, this);
+        argWnd->Connect(id, wxEVT_RIGHT_UP,
+            wxMouseEventHandler(wxPropertyGrid::OnMouseRightClickChild),
+            NULL, this);
+        argWnd->Connect(id, wxEVT_ENTER_WINDOW,
+            wxMouseEventHandler(wxPropertyGrid::OnMouseEntry),
+            NULL, this);
+        argWnd->Connect(id, wxEVT_LEAVE_WINDOW,
+            wxMouseEventHandler(wxPropertyGrid::OnMouseEntry),
+            NULL, this);
+    }
+
+    wxPropertyGridEditorEventForwarder* forwarder;
+    forwarder = new wxPropertyGridEditorEventForwarder(this);
+    argWnd->PushEventHandler(forwarder);
+
+    argWnd->Connect(id, wxEVT_KEY_DOWN,
+        wxCharEventHandler(wxPropertyGrid::OnChildKeyDown),
+        NULL, this);

 }
 
 void wxPropertyGrid::FreeEditors()
 {
 }
 
 void wxPropertyGrid::FreeEditors()
 {

-    // Do not free editors immediately if processing events
-    if ( !m_windowsToDelete )
-        m_windowsToDelete = new wxArrayPtrVoid;
+    //
+    // Return focus back to canvas from children (this is required at least for
+    // GTK+, which, unlike Windows, clears focus when control is destroyed
+    // instead of moving it to closest parent).
+    wxWindow* focus = wxWindow::FindFocus();
+    if ( focus )
+    {
+        wxWindow* parent = focus->GetParent();
+        while ( parent )
+        {
+            if ( parent == m_canvas )
+            {
+                SetFocusOnCanvas();
+                break;
+            }
+            parent = parent->GetParent();
+        }
+    }

 
 

+    // Do not free editors immediately if processing events

     if ( m_wndEditor2 )
     {
     if ( m_wndEditor2 )
     {

-        m_windowsToDelete->push_back(m_wndEditor2);
+        wxEvtHandler* handler = m_wndEditor2->PopEventHandler(false);

         m_wndEditor2->Hide();
         m_wndEditor2->Hide();

-        m_wndEditor2 = (wxWindow*) NULL;
+        wxPendingDelete.Append( handler );
+        wxPendingDelete.Append( m_wndEditor2 );
+        m_wndEditor2 = NULL;

     }
 
     if ( m_wndEditor )
     {
     }
 
     if ( m_wndEditor )
     {

-        m_windowsToDelete->push_back(m_wndEditor);
+        wxEvtHandler* handler = m_wndEditor->PopEventHandler(false);

         m_wndEditor->Hide();
         m_wndEditor->Hide();

-        m_wndEditor = (wxWindow*) NULL;
+        wxPendingDelete.Append( handler );
+        wxPendingDelete.Append( m_wndEditor );
+        m_wndEditor = NULL;

     }
 }
 
 // Call with NULL to de-select property
 bool wxPropertyGrid::DoSelectProperty( wxPGProperty* p, unsigned int flags )
 {
     }
 }
 
 // Call with NULL to de-select property
 bool wxPropertyGrid::DoSelectProperty( wxPGProperty* p, unsigned int flags )
 {

-    wxPanel* canvas = GetPanel();
-

     /*
     if (p)
         wxLogDebug(wxT("SelectProperty( %s (%s[%i]) )"),p->m_label.c_str(),
     /*
     if (p)
         wxLogDebug(wxT("SelectProperty( %s (%s[%i]) )"),p->m_label.c_str(),


@@ -3541,25 +3218,24 @@ bool wxPropertyGrid::DoSelectProperty( wxPGProperty* p, unsigned int flags )
 
     wxPGProperty* prev = m_selected;
 
 
     wxPGProperty* prev = m_selected;
 

-    //
-    // Delete windows pending for deletion
-    if ( m_windowsToDelete && !m_inDoPropertyChanged && m_windowsToDelete->size() )
-    {
-        unsigned int i;
-
-        for ( i=0; i<m_windowsToDelete->size(); i++ )
-            delete ((wxWindow*)((*m_windowsToDelete)[i]));
-
-        m_windowsToDelete->clear();
-    }
-

     if ( !m_pState )
     {
         m_inDoSelectProperty = 0;
         return false;
     }
 
     if ( !m_pState )
     {
         m_inDoSelectProperty = 0;
         return false;
     }
 

-    //
+/*
+    if (m_selected)
+        wxPrintf( "Selected %s\n", m_selected->GetClassInfo()->GetClassName() );
+    else
+        wxPrintf( "None selected\n" );
+
+    if (p)
+        wxPrintf( "P =  %s\n", p->GetClassInfo()->GetClassName() );
+    else
+        wxPrintf( "P = NULL\n" );
+*/
+

     // If we are frozen, then just set the values.
     if ( m_frozen )
     {
     // If we are frozen, then just set the values.
     if ( m_frozen )
     {


@@ -3574,7 +3250,7 @@ bool wxPropertyGrid::DoSelectProperty( wxPGProperty* p, unsigned int flags )
         FreeEditors();
 
         // Prevent any further selection measures in this call
         FreeEditors();
 
         // Prevent any further selection measures in this call

-        p = (wxPGProperty*) NULL;
+        p = NULL;

     }
     else
     {
     }
     else
     {


@@ -3625,8 +3301,8 @@ bool wxPropertyGrid::DoSelectProperty( wxPGProperty* p, unsigned int flags )
             FreeEditors();
             m_selColumn = -1;
 
             FreeEditors();
             m_selColumn = -1;
 

-            m_selected = (wxPGProperty*) NULL;
-            m_pState->m_selected = (wxPGProperty*) NULL;
+            m_selected = NULL;
+            m_pState->m_selected = NULL;

 
             // We need to always fully refresh the grid here
             Refresh(false);
 
             // We need to always fully refresh the grid here
             Refresh(false);


@@ -3651,10 +3327,7 @@ bool wxPropertyGrid::DoSelectProperty( wxPGProperty* p, unsigned int flags )
             if ( p != prev )
                 m_iFlags &= ~(wxPG_FL_VALIDATION_FAILED);
 
             if ( p != prev )
                 m_iFlags &= ~(wxPG_FL_VALIDATION_FAILED);
 

-            wxASSERT( m_wndEditor == (wxWindow*) NULL );
-
-            // Do we need OnMeasureCalls?
-            wxSize imsz = p->OnMeasureImage();
+            wxASSERT( m_wndEditor == NULL );

 
             //
             // Only create editor for non-disabled non-caption
 
             //
             // Only create editor for non-disabled non-caption


@@ -3691,25 +3364,27 @@ bool wxPropertyGrid::DoSelectProperty( wxPGProperty* p, unsigned int flags )
 
                 m_wndEditor = wndList.m_primary;
                 m_wndEditor2 = wndList.m_secondary;
 
                 m_wndEditor = wndList.m_primary;
                 m_wndEditor2 = wndList.m_secondary;

+                wxWindow* primaryCtrl = GetEditorControl();
+
+                //
+                // Essentially, primaryCtrl == m_wndEditor
+                //

 
                 // NOTE: It is allowed for m_wndEditor to be NULL - in this case
                 //       value is drawn as normal, and m_wndEditor2 is assumed
 
                 // NOTE: It is allowed for m_wndEditor to be NULL - in this case
                 //       value is drawn as normal, and m_wndEditor2 is assumed

-                //       to be a right-aligned button that triggers a separate editor
+                //       to be a right-aligned button that triggers a separate editorCtrl

                 //       window.
 
                 if ( m_wndEditor )
                 {
                 //       window.
 
                 if ( m_wndEditor )
                 {

-                    wxASSERT_MSG( m_wndEditor->GetParent() == canvas,
+                    wxASSERT_MSG( m_wndEditor->GetParent() == GetPanel(),

                                   wxT("CreateControls must use result of wxPropertyGrid::GetPanel() as parent of controls.") );
 
                     // Set validator, if any
                 #if wxUSE_VALIDATORS
                                   wxT("CreateControls must use result of wxPropertyGrid::GetPanel() as parent of controls.") );
 
                     // Set validator, if any
                 #if wxUSE_VALIDATORS

-                    if ( !(GetExtraStyle() & wxPG_EX_LEGACY_VALIDATORS) )
-                    {
-                        wxValidator* validator = p->GetValidator();
-                        if ( validator )
-                            m_wndEditor->SetValidator(*validator);
-                    }
+                    wxValidator* validator = p->GetValidator();
+                    if ( validator )
+                        primaryCtrl->SetValidator(*validator);

                 #endif
 
                     if ( m_wndEditor->GetSize().y > (m_lineHeight+6) )
                 #endif
 
                     if ( m_wndEditor->GetSize().y > (m_lineHeight+6) )


@@ -3724,10 +3399,10 @@ bool wxPropertyGrid::DoSelectProperty( wxPGProperty* p, unsigned int flags )
                     // Fix TextCtrl indentation
                 #if defined(__WXMSW__) && !defined(__WXWINCE__)
                     wxTextCtrl* tc = NULL;
                     // Fix TextCtrl indentation
                 #if defined(__WXMSW__) && !defined(__WXWINCE__)
                     wxTextCtrl* tc = NULL;

-                    if ( m_wndEditor->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) )
-                        tc = ((wxOwnerDrawnComboBox*)m_wndEditor)->GetTextCtrl();
+                    if ( primaryCtrl->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) )
+                        tc = ((wxOwnerDrawnComboBox*)primaryCtrl)->GetTextCtrl();

                     else
                     else

-                        tc = wxDynamicCast(m_wndEditor, wxTextCtrl);
+                        tc = wxDynamicCast(primaryCtrl, wxTextCtrl);

                     if ( tc )
                         ::SendMessage(GetHwndOf(tc), EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(0, 0));
                 #endif
                     if ( tc )
                         ::SendMessage(GetHwndOf(tc), EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(0, 0));
                 #endif


@@ -3753,8 +3428,7 @@ bool wxPropertyGrid::DoSelectProperty( wxPGProperty* p, unsigned int flags )
                     m_wndEditor->Move( goodPos );
                 #endif
 
                     m_wndEditor->Move( goodPos );
                 #endif
 

-                    wxWindow* primaryCtrl = GetEditorControl();
-                    SetupEventHandling(primaryCtrl, wxPG_SUBID1);
+                    SetupChildEventHandling(primaryCtrl);

 
                     // Focus and select all (wxTextCtrl, wxComboBox etc)
                     if ( flags & wxPG_SEL_FOCUS )
 
                     // Focus and select all (wxTextCtrl, wxComboBox etc)
                     if ( flags & wxPG_SEL_FOCUS )


@@ -3767,7 +3441,7 @@ bool wxPropertyGrid::DoSelectProperty( wxPGProperty* p, unsigned int flags )
 
                 if ( m_wndEditor2 )
                 {
 
                 if ( m_wndEditor2 )
                 {

-                    wxASSERT_MSG( m_wndEditor2->GetParent() == canvas,
+                    wxASSERT_MSG( m_wndEditor2->GetParent() == GetPanel(),

                                   wxT("CreateControls must use result of wxPropertyGrid::GetPanel() as parent of controls.") );
 
                     // Get proper id for wndSecondary
                                   wxT("CreateControls must use result of wxPropertyGrid::GetPanel() as parent of controls.") );
 
                     // Get proper id for wndSecondary


@@ -3794,7 +3468,7 @@ bool wxPropertyGrid::DoSelectProperty( wxPGProperty* p, unsigned int flags )
                 #endif
                     m_wndEditor2->Show();
 
                 #endif
                     m_wndEditor2->Show();
 

-                    SetupEventHandling(m_wndEditor2,wxPG_SUBID2);
+                    SetupChildEventHandling(m_wndEditor2);

 
                     // If no primary editor, focus to button to allow
                     // it to interprete ENTER etc.
 
                     // If no primary editor, focus to button to allow
                     // it to interprete ENTER etc.


@@ -3852,7 +3526,7 @@ bool wxPropertyGrid::DoSelectProperty( wxPGProperty* p, unsigned int flags )
 
     if ( !(GetExtraStyle() & wxPG_EX_HELP_AS_TOOLTIPS) )
     {
 
     if ( !(GetExtraStyle() & wxPG_EX_HELP_AS_TOOLTIPS) )
     {

-        wxStatusBar* statusbar = (wxStatusBar*) NULL;
+        wxStatusBar* statusbar = NULL;

         if ( !(m_iFlags & wxPG_FL_NOSTATUSBARHELP) )
         {
             wxFrame* frame = wxDynamicCast(::wxGetTopLevelParent(this),wxFrame);
         if ( !(m_iFlags & wxPG_FL_NOSTATUSBARHELP) )
         {
             wxFrame* frame = wxDynamicCast(::wxGetTopLevelParent(this),wxFrame);


@@ -3913,11 +3587,41 @@ bool wxPropertyGrid::UnfocusEditor()
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 

+void wxPropertyGrid::RefreshEditor()
+{
+    wxPGProperty* p = m_selected;
+    if ( !p ) 
+        return;
+
+    wxWindow* wnd = GetEditorControl();
+    if ( !wnd )
+        return;
+
+    // Set editor font boldness - must do this before
+    // calling UpdateControl().
+    if ( HasFlag(wxPG_BOLD_MODIFIED) )
+    {
+        if ( p->HasFlag(wxPG_PROP_MODIFIED) )
+            wnd->SetFont(GetCaptionFont());
+        else
+            wnd->SetFont(GetFont());
+    }
+
+    const wxPGEditor* editorClass = p->GetEditorClass();
+
+    editorClass->UpdateControl(p, wnd);
+
+    if ( p->IsValueUnspecified() )
+        editorClass ->SetValueToUnspecified(p, wnd);
+}
+
+// -----------------------------------------------------------------------
+

 // This method is not inline because it called dozens of times
 // (i.e. two-arg function calls create smaller code size).
 bool wxPropertyGrid::DoClearSelection()
 {
 // This method is not inline because it called dozens of times
 // (i.e. two-arg function calls create smaller code size).
 bool wxPropertyGrid::DoClearSelection()
 {

-    return DoSelectProperty((wxPGProperty*)NULL);
+    return DoSelectProperty(NULL);

 }
 
 // -----------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------


@@ -3929,10 +3633,9 @@ bool wxPropertyGrid::DoCollapse( wxPGProperty* p, bool sendEvents )
     wxPGProperty* pwc = wxStaticCast(p, wxPGProperty);
 
     // If active editor was inside collapsed section, then disable it
     wxPGProperty* pwc = wxStaticCast(p, wxPGProperty);
 
     // If active editor was inside collapsed section, then disable it

-    if ( m_selected && m_selected->IsSomeParent (p) )
+    if ( m_selected && m_selected->IsSomeParent(p) )

     {
     {

-        if ( !ClearSelection() )
-            return false;
+        ClearSelection(false);

     }
 
     // Store dont-center-splitter flag 'cause we need to temporarily set it
     }
 
     // Store dont-center-splitter flag 'cause we need to temporarily set it


@@ -4001,7 +3704,7 @@ bool wxPropertyGrid::DoExpand( wxPGProperty* p, bool sendEvents )
     }
 
     // Clear dont-center-splitter flag if it wasn't set
     }
 
     // Clear dont-center-splitter flag if it wasn't set

-    m_iFlags = m_iFlags & ~(wxPG_FL_DONT_CENTER_SPLITTER) | old_flag;
+    m_iFlags = (m_iFlags & ~wxPG_FL_DONT_CENTER_SPLITTER) | old_flag;

 
     return res;
 }
 
     return res;
 }


@@ -4017,8 +3720,7 @@ bool wxPropertyGrid::DoHideProperty( wxPGProperty* p, bool hide, int flags )
          ( m_selected == p || m_selected->IsSomeParent(p) )
        )
         {
          ( m_selected == p || m_selected->IsSomeParent(p) )
        )
         {

-            if ( !ClearSelection() )
-                return false;
+            ClearSelection(false);

         }
 
     m_pState->DoHideProperty(p, hide, flags);
         }
 
     m_pState->DoHideProperty(p, hide, flags);


@@ -4052,8 +3754,7 @@ void wxPropertyGrid::RecalculateVirtualSize( int forceXPos )
     if ( by1 != by2 )
     {
         wxString s = wxString::Format(wxT("VirtualHeight=%i, ActualVirtualHeight=%i, should match!"), by1, by2);
     if ( by1 != by2 )
     {
         wxString s = wxString::Format(wxT("VirtualHeight=%i, ActualVirtualHeight=%i, should match!"), by1, by2);

-        wxASSERT_MSG( false,
-                      s.c_str() );
+        wxFAIL_MSG(s.c_str());

         wxLogDebug(s);
     }
 #endif
         wxLogDebug(s);
     }
 #endif


@@ -4086,7 +3787,7 @@ void wxPropertyGrid::RecalculateVirtualSize( int forceXPos )
     else if ( xPos > (xAmount-(width/wxPG_PIXELS_PER_UNIT)) )
         xPos = 0;
 
     else if ( xPos > (xAmount-(width/wxPG_PIXELS_PER_UNIT)) )
         xPos = 0;
 

-    int yAmount = (y+wxPG_PIXELS_PER_UNIT+2)/wxPG_PIXELS_PER_UNIT;
+    int yAmount = y / wxPG_PIXELS_PER_UNIT;

     int yPos = GetScrollPos( wxVERTICAL );
 
     SetScrollbars( wxPG_PIXELS_PER_UNIT, wxPG_PIXELS_PER_UNIT,
     int yPos = GetScrollPos( wxVERTICAL );
 
     SetScrollbars( wxPG_PIXELS_PER_UNIT, wxPG_PIXELS_PER_UNIT,


@@ -4190,6 +3891,12 @@ void wxPropertyGrid::SetVirtualWidth( int width )
     m_pState->SetVirtualWidth( width );
 }
 
     m_pState->SetVirtualWidth( width );
 }
 

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

 // -----------------------------------------------------------------------
 // wxPropertyGrid mouse event handling
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // wxPropertyGrid mouse event handling
 // -----------------------------------------------------------------------


@@ -4493,9 +4200,9 @@ bool wxPropertyGrid::HandleMouseMove( int x, unsigned int y, wxMouseEvent &event
         int curPropHoverY = y - (y % ih);
 
         // On which item it hovers
         int curPropHoverY = y - (y % ih);
 
         // On which item it hovers

-        if ( ( !m_propHover )
+        if ( !m_propHover

              ||
              ||

-             ( m_propHover && ( sy < m_propHoverY || sy >= (m_propHoverY+ih) ) )
+             ( sy < m_propHoverY || sy >= (m_propHoverY+ih) )

            )
         {
             // Mouse moves on another property
            )
         {
             // Mouse moves on another property


@@ -4558,7 +4265,7 @@ bool wxPropertyGrid::HandleMouseMove( int x, unsigned int y, wxMouseEvent &event
                         if ( space )
                         {
                             int tw, th;
                         if ( space )
                         {
                             int tw, th;

-                           GetTextExtent( tipString, &tw, &th, 0, 0, &m_font );
+                           GetTextExtent( tipString, &tw, &th, 0, 0 );

                             if ( tw > space )
                             {
                                 SetToolTip( tipString );
                             if ( tw > space )
                             {
                                 SetToolTip( tipString );


@@ -4607,8 +4314,7 @@ bool wxPropertyGrid::HandleMouseMove( int x, unsigned int y, wxMouseEvent &event
             // (also not if we were dragging and its started
             // outside the splitter region)
 
             // (also not if we were dragging and its started
             // outside the splitter region)
 

-            if ( m_propHover &&
-                 !m_propHover->IsCategory() &&
+            if ( !m_propHover->IsCategory() &&

                  !event.Dragging() )
             {
 
                  !event.Dragging() )
             {
 


@@ -4709,19 +4415,19 @@ bool wxPropertyGrid::OnMouseCommon( wxMouseEvent& event, int* px, int* py )
     int ux = event.m_x;
     int uy = event.m_y;
 
     int ux = event.m_x;
     int uy = event.m_y;
 

-    wxWindow* wnd = m_wndEditor;
+    wxWindow* wnd = GetEditorControl();

 
     // Hide popup on clicks
     if ( event.GetEventType() != wxEVT_MOTION )
         if ( wnd && wnd->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) )
         {
 
     // Hide popup on clicks
     if ( event.GetEventType() != wxEVT_MOTION )
         if ( wnd && wnd->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) )
         {

-            ((wxOwnerDrawnComboBox*)m_wndEditor)->HidePopup();
+            ((wxOwnerDrawnComboBox*)wnd)->HidePopup();

         }
 
     wxRect r;
     if ( wnd )
         r = wnd->GetRect();
         }
 
     wxRect r;
     if ( wnd )
         r = wnd->GetRect();

-    if ( wnd == (wxWindow*) NULL || m_dragStatus ||
+    if ( wnd == NULL || m_dragStatus ||

          (
            ux <= (splitterX + wxPG_SPLITTERX_DETECTMARGIN2) ||
            ux >= (r.x+r.width) ||
          (
            ux <= (splitterX + wxPG_SPLITTERX_DETECTMARGIN2) ||
            ux >= (r.x+r.width) ||


@@ -4864,8 +4570,6 @@ bool wxPropertyGrid::OnMouseChildCommon( wxMouseEvent &event, int* px, int *py )
     int x, y;
     event.GetPosition(&x,&y);
 
     int x, y;
     event.GetPosition(&x,&y);
 

-    AdjustPosForClipperWindow( topCtrlWnd, &x, &y );
-

     int splitterX = GetSplitterPosition();
 
     wxRect r = topCtrlWnd->GetRect();
     int splitterX = GetSplitterPosition();
 
     wxRect r = topCtrlWnd->GetRect();


@@ -4934,17 +4638,6 @@ void wxPropertyGrid::OnMouseUpChild( wxMouseEvent &event )
 // wxPropertyGrid keyboard event handling
 // -----------------------------------------------------------------------
 
 // wxPropertyGrid keyboard event handling
 // -----------------------------------------------------------------------
 

-void wxPropertyGrid::SendNavigationKeyEvent( int dir )
-{
-    wxNavigationKeyEvent evt;
-    evt.SetFlags(wxNavigationKeyEvent::FromTab|
-                 (dir?wxNavigationKeyEvent::IsForward:
-                      wxNavigationKeyEvent::IsBackward));
-    evt.SetEventObject(this);
-    m_canvas->GetEventHandler()->AddPendingEvent(evt);
-}
-
-

 int wxPropertyGrid::KeyEventToActions(wxKeyEvent &event, int* pSecond) const
 {
     // Translates wxKeyEvent to wxPG_ACTION_XXX
 int wxPropertyGrid::KeyEventToActions(wxKeyEvent &event, int* pSecond) const
 {
     // Translates wxKeyEvent to wxPG_ACTION_XXX


@@ -4996,7 +4689,7 @@ void wxPropertyGrid::ClearActionTriggers( int action )
 {
     wxPGHashMapI2I::iterator it;
 
 {
     wxPGHashMapI2I::iterator it;
 

-    for ( it = m_actionTriggers.begin(); it != m_actionTriggers.end(); it++ )
+    for ( it = m_actionTriggers.begin(); it != m_actionTriggers.end(); ++it )

     {
         if ( it->second == action )
         {
     {
         if ( it->second == action )
         {


@@ -5005,138 +4698,82 @@ void wxPropertyGrid::ClearActionTriggers( int action )
     }
 }
 
     }
 }
 

-static void CopyTextToClipboard( const wxString& text )
-{
-    if ( wxTheClipboard->Open() )
-    {
-        // This data objects are held by the clipboard, 
-        // so do not delete them in the app.
-        wxTheClipboard->SetData( new wxTextDataObject(text) );
-        wxTheClipboard->Close();
-    }
-}
-
-void wxPropertyGrid::HandleKeyEvent(wxKeyEvent &event)
+void wxPropertyGrid::HandleKeyEvent( wxKeyEvent &event, bool fromChild )

 {
     //
     // Handles key event when editor control is not focused.
     //
 
 {
     //
     // Handles key event when editor control is not focused.
     //
 

-    wxASSERT( !m_frozen );
-    if ( m_frozen )
-        return;
+    wxCHECK2(!m_frozen, return);

 
     // Travelsal between items, collapsing/expanding, etc.
     int keycode = event.GetKeyCode();
 
     // Travelsal between items, collapsing/expanding, etc.
     int keycode = event.GetKeyCode();

+    bool editorFocused = IsEditorFocused();

 
     if ( keycode == WXK_TAB )
     {
 
     if ( keycode == WXK_TAB )
     {

-        SendNavigationKeyEvent( event.ShiftDown()?0:1 );
-        return;
-    }
+        wxWindow* mainControl;

 
 

-    // Ignore Alt and Control when they are down alone
-    if ( keycode == WXK_ALT ||
-         keycode == WXK_CONTROL )
-    {
-        event.Skip();
-        return;
-    }
-
-    int secondAction;
-    int action = KeyEventToActions(event, &secondAction);
-
-    if ( m_selected )
-    {
-
-        // Show dialog?
-        if ( ButtonTriggerKeyTest(event) )
-            return;
-
-        wxPGProperty* p = m_selected;
+        if ( HasInternalFlag(wxPG_FL_IN_MANAGER) )
+            mainControl = GetParent();
+        else
+            mainControl = this;

 
 

-        if ( action == wxPG_ACTION_COPY )
+        if ( !event.ShiftDown() )

         {
         {

-            CopyTextToClipboard(p->GetDisplayedString());
+            if ( !editorFocused && m_wndEditor )
+            {
+                DoSelectProperty( m_selected, wxPG_SEL_FOCUS );
+            }
+            else
+            {
+                // Tab traversal workaround for platforms on which
+                // wxWindow::Navigate() may navigate into first child
+                // instead of next sibling. Does not work perfectly
+                // in every scenario (for instance, when property grid
+                // is either first or last control).
+            #if defined(__WXGTK__)
+                wxWindow* sibling = mainControl->GetNextSibling();
+                if ( sibling )
+                    sibling->SetFocusFromKbd();
+            #else
+                Navigate(wxNavigationKeyEvent::IsForward);
+            #endif
+            }

         }
         else
         {
         }
         else
         {

-            // Travel and expand/collapse
-            int selectDir = -2;
-
-            if ( p->GetChildCount() &&
-                 !(p->m_flags & wxPG_PROP_DISABLED)
-               )
-            {
-                if ( action == wxPG_ACTION_COLLAPSE_PROPERTY || secondAction == wxPG_ACTION_COLLAPSE_PROPERTY )
-                {
-                    if ( (m_windowStyle & wxPG_HIDE_MARGIN) || Collapse(p) )
-                        keycode = 0;
-                }
-                else if ( action == wxPG_ACTION_EXPAND_PROPERTY || secondAction == wxPG_ACTION_EXPAND_PROPERTY )
-                {
-                    if ( (m_windowStyle & wxPG_HIDE_MARGIN) || Expand(p) )
-                        keycode = 0;
-                }
-            }
-
-            if ( keycode )
+            if ( editorFocused )

             {
             {

-                if ( action == wxPG_ACTION_PREV_PROPERTY || secondAction == wxPG_ACTION_PREV_PROPERTY )
-                {
-                    selectDir = -1;
-                }
-                else if ( action == wxPG_ACTION_NEXT_PROPERTY || secondAction == wxPG_ACTION_NEXT_PROPERTY )
-                {
-                    selectDir = 1;
-                }
-                else
-                {
-                    event.Skip();
-                }
-
+                UnfocusEditor();

             }
             }

-
-            if ( selectDir >= -1 )
+            else

             {
             {

-                p = wxPropertyGridIterator::OneStep( m_pState, wxPG_ITERATE_VISIBLE, p, selectDir );
-                if ( p )
-                    DoSelectProperty(p);
+            #if defined(__WXGTK__)
+                wxWindow* sibling = mainControl->GetPrevSibling();
+                if ( sibling )
+                    sibling->SetFocusFromKbd();
+            #else
+                Navigate(wxNavigationKeyEvent::IsBackward);
+            #endif

             }
         }
             }
         }

-    }
-    else
-    {
-        // If nothing was selected, select the first item now
-        // (or navigate out of tab).
-        if ( action != wxPG_ACTION_CANCEL_EDIT && secondAction != wxPG_ACTION_CANCEL_EDIT )
-        {
-            wxPGProperty* p = wxPropertyGridInterface::GetFirst();
-            if ( p ) DoSelectProperty(p);
-        }
-    }
-}

 
 

-// -----------------------------------------------------------------------
-
-// Potentially handles a keyboard event for editor controls.
-// Returns false if event should *not* be skipped (on true it can
-// be optionally skipped).
-// Basicly, false means that SelectProperty was called (or was about
-// to be called, if canDestroy was false).
-bool wxPropertyGrid::HandleChildKey( wxKeyEvent& event )
-{
-    bool res = true;
+        return;
+    }

 
 

-    if ( !m_selected || !m_wndEditor )
+    // Ignore Alt and Control when they are down alone
+    if ( keycode == WXK_ALT ||
+         keycode == WXK_CONTROL )

     {
     {

-        return true;
+        event.Skip();
+        return;

     }
 
     }
 

-    int action = KeyEventToAction(event);
+    int secondAction;
+    int action = KeyEventToActions(event, &secondAction);

 
 

-    // Unfocus?
-    if ( action == wxPG_ACTION_CANCEL_EDIT )
+    if ( editorFocused && action == wxPG_ACTION_CANCEL_EDIT )

     {
         //
         // Esc cancels any changes
     {
         //
         // Esc cancels any changes


@@ -5146,246 +4783,140 @@ bool wxPropertyGrid::HandleChildKey( wxKeyEvent& event )
 
             // Update the control as well
             m_selected->GetEditorClass()->SetControlStringValue( m_selected,
 
             // Update the control as well
             m_selected->GetEditorClass()->SetControlStringValue( m_selected,

-                                                                 m_wndEditor,
+                                                                 GetEditorControl(),

                                                                  m_selected->GetDisplayedString() );
         }
 
         OnValidationFailureReset(m_selected);
 
                                                                  m_selected->GetDisplayedString() );
         }
 
         OnValidationFailureReset(m_selected);
 

-        res = false;
-

         UnfocusEditor();
         UnfocusEditor();

+        return;

     }
     }

-    else if ( action == wxPG_ACTION_COPY )
-    {
-        // NB: There is some problem with getting native cut-copy-paste keys to go through
-        //     for embedded editor wxTextCtrl. This is why we emulate.
-        //
-        wxTextCtrl* tc = GetEditorTextCtrl();
-        if ( tc )
-        {
-            wxString sel = tc->GetStringSelection();
-            if ( sel.length() )
-                CopyTextToClipboard(sel);
-        }
-        else
-        {
-            CopyTextToClipboard(m_selected->GetDisplayedString());
-        }
-    }
-    else if ( action == wxPG_ACTION_CUT )
-    {
-        wxTextCtrl* tc = GetEditorTextCtrl();
-        if ( tc )
-        {
-            long from, to;
-            tc->GetSelection(&from, &to);
-            if ( from < to )
-            {
-                CopyTextToClipboard(tc->GetStringSelection());
-                tc->Remove(from, to);
-            }
-        }
-    }
-    else if ( action == wxPG_ACTION_PASTE )
+
+    // Except for TAB and ESC, handle child control events in child control
+    if ( fromChild )

     {
     {

-        wxTextCtrl* tc = GetEditorTextCtrl();
-        if ( tc )
+        // Only propagate event if it had modifiers
+        if ( !event.HasModifiers() )

         {
         {

-            if (wxTheClipboard->Open())
-            {
-                if (wxTheClipboard->IsSupported( wxDF_TEXT ))
-                {
-                    wxTextDataObject data;
-                    wxTheClipboard->GetData( data );
-                    long from, to;
-                    tc->GetSelection(&from, &to);
-                    if ( from < to )
-                    {
-                        tc->Remove(from, to);
-                        tc->WriteText(data.GetText());
-                    }
-                    else
-                    {
-                        tc->WriteText(data.GetText());
-                    }
-                }  
-                wxTheClipboard->Close();
-            }
+            event.StopPropagation();

         }
         }

-    }
-
-    return res;
-}
-
-// -----------------------------------------------------------------------
-
-void wxPropertyGrid::OnKey( wxKeyEvent &event )
-{
-
-    //
-    // Events to editor controls should get relayed here.
-    //
-    wxWindow* focused = wxWindow::FindFocus();
-
-    wxWindow* primaryCtrl = GetEditorControl();
-
-    if ( primaryCtrl &&
-         (focused==primaryCtrl
-          || m_editorFocused) )
-    {
-        // Child key must be processed here, since it can
-        // destroy the control which is referred by its own
-        // event handling.
-        HandleChildKey( event );
-    }
-    else
-        HandleKeyEvent( event );
-}
-
-// -----------------------------------------------------------------------
-
-void wxPropertyGrid::OnKeyUp(wxKeyEvent &event)
-{
-    m_keyComboConsumed = 0;
-
-    event.Skip();
-}
-
-// -----------------------------------------------------------------------
-
-void wxPropertyGrid::OnNavigationKey( wxNavigationKeyEvent& event )
-{
-    // Ignore events that occur very close to focus set
-    if ( m_iFlags & wxPG_FL_IGNORE_NEXT_NAVKEY )
-    {
-        m_iFlags &= ~(wxPG_FL_IGNORE_NEXT_NAVKEY);

         event.Skip();
         return;
     }
 
         event.Skip();
         return;
     }
 

-    wxPGProperty* next = (wxPGProperty*) NULL;
-
-    int dir = event.GetDirection()?1:-1;
+    bool wasHandled = false;

 
     if ( m_selected )
     {
 
     if ( m_selected )
     {

-        if ( dir == 1 && (m_wndEditor || m_wndEditor2) )
-        {
-            wxWindow* focused = wxWindow::FindFocus();
+        // Show dialog?
+        if ( ButtonTriggerKeyTest(action, event) )
+            return;

 
 

-            wxWindow* wndToCheck = GetEditorControl();
+        wxPGProperty* p = m_selected;

 
 

-            // ODComboBox focus goes to its text ctrl, so we need to use it instead
-            if ( wndToCheck && wndToCheck->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) )
-            {
-                wxTextCtrl* comboTextCtrl = ((wxOwnerDrawnComboBox*)wndToCheck)->GetTextCtrl();
-                if ( comboTextCtrl )
-                    wndToCheck = comboTextCtrl;
-            }
+        // Travel and expand/collapse
+        int selectDir = -2;

 
 

-            /*
-            // Because of problems navigating from wxButton, do not go to it.
-            if ( !wndToCheck )
+        if ( p->GetChildCount() &&
+             !(p->m_flags & wxPG_PROP_DISABLED)
+           )
+        {
+            if ( action == wxPG_ACTION_COLLAPSE_PROPERTY || secondAction == wxPG_ACTION_COLLAPSE_PROPERTY )

             {
             {

-                // No primary, use secondary
-                wndToCheck = m_wndEditor2;
+                if ( (m_windowStyle & wxPG_HIDE_MARGIN) || Collapse(p) )
+                    wasHandled = true;

             }
             }

-            // If it has editor button, focus to it after the primary editor.
-            // NB: Doesn't work since wxButton on wxMSW doesn't seem to propagate
-            //     key events (yes, I'm using wxWANTS_CHARS with it, and yes I
-            //     have somewhat debugged in window.cpp itself).
-            else if ( focused == wndToCheck &&
-                      m_wndEditor2 &&
-                      !(GetExtraStyle() & wxPG_EX_NO_TAB_TO_BUTTON) )
+            else if ( action == wxPG_ACTION_EXPAND_PROPERTY || secondAction == wxPG_ACTION_EXPAND_PROPERTY )

             {
             {

-                wndToCheck = m_wndEditor2;
-                wxLogDebug(wxT("Exp1"));
+                if ( (m_windowStyle & wxPG_HIDE_MARGIN) || Expand(p) )
+                    wasHandled = true;

             }
             }

-            */
+        }

 
 

-            if ( focused != wndToCheck &&
-                 wndToCheck )
+        if ( !wasHandled )
+        {
+            if ( action == wxPG_ACTION_PREV_PROPERTY || secondAction == wxPG_ACTION_PREV_PROPERTY )

             {
             {

-                wndToCheck->SetFocus();
-
-                // Select all text in wxTextCtrl etc.
-                if ( m_wndEditor && wndToCheck == m_wndEditor )
-                    m_selected->GetEditorClass()->OnFocus(m_selected,wndToCheck);
-
-                m_editorFocused = 1;
-                next = m_selected;
+                selectDir = -1;
+            }
+            else if ( action == wxPG_ACTION_NEXT_PROPERTY || secondAction == wxPG_ACTION_NEXT_PROPERTY )
+            {
+                selectDir = 1;

             }
         }
 
             }
         }
 

-        if ( !next )
+        if ( selectDir >= -1 )

         {
         {

-            next = wxPropertyGridIterator::OneStep(m_pState, wxPG_ITERATE_VISIBLE, m_selected, dir);
-
-            if ( next )
-            {
-                // This allows preventing NavigateOut to occur
-                DoSelectProperty( next, wxPG_SEL_FOCUS );
-            }
+            p = wxPropertyGridIterator::OneStep( m_pState, wxPG_ITERATE_VISIBLE, p, selectDir );
+            if ( p )
+                DoSelectProperty(p);
+            wasHandled = true;
+        }
+    }
+    else
+    {
+        // If nothing was selected, select the first item now
+        // (or navigate out of tab).
+        if ( action != wxPG_ACTION_CANCEL_EDIT && secondAction != wxPG_ACTION_CANCEL_EDIT )
+        {
+            wxPGProperty* p = wxPropertyGridInterface::GetFirst();
+            if ( p ) DoSelectProperty(p);
+            wasHandled = true;

         }
     }
 
         }
     }
 

-    if ( !next )
+    if ( !wasHandled )

         event.Skip();
 }
 
 // -----------------------------------------------------------------------
 
         event.Skip();
 }
 
 // -----------------------------------------------------------------------
 

-bool wxPropertyGrid::ButtonTriggerKeyTest( wxKeyEvent &event )
+void wxPropertyGrid::OnKey( wxKeyEvent &event )

 {
 {

-    int keycode = event.GetKeyCode();
-
-    // Does the keycode trigger button?
-    if ( keycode == m_pushButKeyCode &&
-         m_wndEditor2 &&
-         (!m_pushButKeyCodeNeedsAlt || event.AltDown()) &&
-         (!m_pushButKeyCodeNeedsCtrl || event.ControlDown()) )
+    // If there was editor open and focused, then this event should not
+    // really be processed here.
+    if ( IsEditorFocused() )

     {
     {

-        m_keyComboConsumed = 1;
-
-        wxCommandEvent evt(wxEVT_COMMAND_BUTTON_CLICKED,m_wndEditor2->GetId());
-        GetEventHandler()->AddPendingEvent(evt);
-        return true;
+        // However, if event had modifiers, it is probably still best
+        // to skip it.
+        if ( event.HasModifiers() )
+            event.Skip();
+        else
+            event.StopPropagation();
+        return;

     }
 
     }
 

-    return false;
+    HandleKeyEvent(event, false);

 }
 
 // -----------------------------------------------------------------------
 
 }
 
 // -----------------------------------------------------------------------
 

-void wxPropertyGrid::OnChildKeyDown( wxKeyEvent &event )
+bool wxPropertyGrid::ButtonTriggerKeyTest( int action, wxKeyEvent& event )

 {
 {

-    int keycode = event.GetKeyCode();
-
-    // Ignore Alt and Control when they are down alone
-    if ( keycode == WXK_ALT ||
-         keycode == WXK_CONTROL )
+    if ( action == -1 )

     {
     {

-        event.Skip();
-        return;
+        int secondAction;
+        action = KeyEventToActions(event, &secondAction);

     }
 
     }
 

-    if ( ButtonTriggerKeyTest(event) )
-        return;
-
-    if ( HandleChildKey(event) == true )
-        event.Skip();
+    // Does the keycode trigger button?
+    if ( action == wxPG_ACTION_PRESS_BUTTON &&
+         m_wndEditor2 )
+    {
+        wxCommandEvent evt(wxEVT_COMMAND_BUTTON_CLICKED, m_wndEditor2->GetId());
+        GetEventHandler()->AddPendingEvent(evt);
+        return true;
+    }

 
 

-    GetEventHandler()->AddPendingEvent(event);
+    return false;

 }
 
 }
 

-void wxPropertyGrid::OnChildKeyUp( wxKeyEvent &event )
-{
-    m_keyComboConsumed = 0;
-
-    GetEventHandler()->AddPendingEvent(event);
+// -----------------------------------------------------------------------

 
 

-    event.Skip();
+void wxPropertyGrid::OnChildKeyDown( wxKeyEvent &event )
+{
+    HandleKeyEvent(event, true);

 }
 
 // -----------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------


@@ -5402,6 +4933,17 @@ void wxPropertyGrid::OnIdle( wxIdleEvent& WXUNUSED(event) )
         HandleFocusChange( newFocused );
 }
 
         HandleFocusChange( newFocused );
 }
 

+bool wxPropertyGrid::IsEditorFocused() const
+{
+    wxWindow* focus = wxWindow::FindFocus();
+
+    if ( focus == m_wndEditor || focus == m_wndEditor2 ||
+         focus == GetEditorControl() )
+         return true;
+
+    return false;
+}
+

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


@@ -5429,13 +4971,8 @@ void wxPropertyGrid::HandleFocusChange( wxWindow* newFocused )
     if ( (m_iFlags & wxPG_FL_FOCUSED) !=
          (oldFlags & wxPG_FL_FOCUSED) )
     {
     if ( (m_iFlags & wxPG_FL_FOCUSED) !=
          (oldFlags & wxPG_FL_FOCUSED) )
     {

-        // On each focus kill, mark the next nav key event
-        // to be ignored (can't do on set focus since the
-        // event would occur before it).

         if ( !(m_iFlags & wxPG_FL_FOCUSED) )
         {
         if ( !(m_iFlags & wxPG_FL_FOCUSED) )
         {

-            m_iFlags |= wxPG_FL_IGNORE_NEXT_NAVKEY;
-

             // Need to store changed value
             CommitChangesFromEditor();
         }
             // Need to store changed value
             CommitChangesFromEditor();
         }


@@ -5468,8 +5005,6 @@ void wxPropertyGrid::HandleFocusChange( wxWindow* newFocused )
 
             }
             */
 
             }
             */

-
-            m_iFlags &= ~(wxPG_FL_IGNORE_NEXT_NAVKEY);

         }
 
         // Redraw selected
         }
 
         // Redraw selected


@@ -5526,20 +5061,43 @@ void wxPropertyGrid::OnCaptureChange( wxMouseCaptureChangedEvent& WXUNUSED(event
 // -----------------------------------------------------------------------
 
 // noDefCheck = true prevents infinite recursion.
 // -----------------------------------------------------------------------
 
 // noDefCheck = true prevents infinite recursion.

-wxPGEditor* wxPropertyGrid::RegisterEditorClass( wxPGEditor* editorclass,
-                                                 const wxString& name,
+wxPGEditor* wxPropertyGrid::RegisterEditorClass( wxPGEditor* editorClass,

                                                  bool noDefCheck )
 {
                                                  bool noDefCheck )
 {

-    wxASSERT( editorclass );
+    wxASSERT( editorClass );

 
     if ( !noDefCheck && wxPGGlobalVars->m_mapEditorClasses.empty() )
         RegisterDefaultEditors();
 
 
     if ( !noDefCheck && wxPGGlobalVars->m_mapEditorClasses.empty() )
         RegisterDefaultEditors();
 

-    wxPGGlobalVars->m_mapEditorClasses[name] = (void*)editorclass;
+    wxString name = editorClass->GetName();
+
+    // Existing editor under this name?
+    wxPGHashMapS2P::iterator vt_it = wxPGGlobalVars->m_mapEditorClasses.find(name);
+
+    if ( vt_it != wxPGGlobalVars->m_mapEditorClasses.end() )
+    {
+        // If this name was already used, try class name.
+        name = editorClass->GetClassInfo()->GetClassName();
+        vt_it = wxPGGlobalVars->m_mapEditorClasses.find(name);
+    }

 
 

-    return editorclass;
+    wxCHECK_MSG( vt_it == wxPGGlobalVars->m_mapEditorClasses.end(),
+                 (wxPGEditor*) vt_it->second,
+                 "Editor with given name was already registered" );
+
+    wxPGGlobalVars->m_mapEditorClasses[name] = (void*)editorClass;
+
+    return editorClass;

 }
 
 }
 

+// Use this in RegisterDefaultEditors.
+#define wxPGRegisterDefaultEditorClass(EDITOR) \
+    if ( wxPGEditor_##EDITOR == NULL ) \
+    { \
+        wxPGEditor_##EDITOR = wxPropertyGrid::RegisterEditorClass( \
+            new wxPG##EDITOR##Editor, true ); \
+    }
+

 // Registers all default editor classes
 void wxPropertyGrid::RegisterDefaultEditors()
 {
 // Registers all default editor classes
 void wxPropertyGrid::RegisterDefaultEditors()
 {


@@ -5605,7 +5163,7 @@ bool wxPGStringTokenizer::HasMoreTokens()
                 }
                 else
                 {
                 }
                 else
                 {

-                    i++;
+                    ++i;

                     m_curPos = i;
                     return true;
                 }
                     m_curPos = i;
                     return true;
                 }


@@ -5617,7 +5175,7 @@ bool wxPGStringTokenizer::HasMoreTokens()
                 prev_a = wxT('\0');
             }
         }
                 prev_a = wxT('\0');
             }
         }

-        i++;
+        ++i;

     }
 
     m_curPos = str.end();
     }
 
     m_curPos = str.end();


@@ -5642,12 +5200,6 @@ wxPGChoiceEntry::wxPGChoiceEntry()
 {
 }
 
 {
 }
 

-wxPGChoiceEntry::wxPGChoiceEntry( const wxPGChoiceEntry& entry )
-    : wxPGCell( entry.GetText(), entry.GetBitmap(),
-        entry.GetFgCol(), entry.GetBgCol() ), m_value(entry.GetValue())
-{
-}
-

 // -----------------------------------------------------------------------
 // wxPGChoicesData
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // wxPGChoicesData
 // -----------------------------------------------------------------------


@@ -5664,293 +5216,39 @@ wxPGChoicesData::~wxPGChoicesData()
 
 void wxPGChoicesData::Clear()
 {
 
 void wxPGChoicesData::Clear()
 {

-    unsigned int i;
-
-    for ( i=0; i<m_items.size(); i++ )
-    {
-        delete Item(i);
-    }
-
-#if wxUSE_STL
-    m_items.resize(0);
-#else
-    m_items.Empty();
-#endif
+    m_items.clear();

 }
 
 void wxPGChoicesData::CopyDataFrom( wxPGChoicesData* data )
 {
     wxASSERT( m_items.size() == 0 );
 
 }
 
 void wxPGChoicesData::CopyDataFrom( wxPGChoicesData* data )
 {
     wxASSERT( m_items.size() == 0 );
 

-    unsigned int i;
-
-    for ( i=0; i<data->GetCount(); i++ )
-        m_items.push_back( new wxPGChoiceEntry(*data->Item(i)) );
-}
-
-// -----------------------------------------------------------------------
-// wxPGChoices
-// -----------------------------------------------------------------------
-
-wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, int value )
-{
-    EnsureData();
-
-    wxPGChoiceEntry* p = new wxPGChoiceEntry(label, value);
-    m_data->Insert( -1, p );
-    return *p;
-}
-
-// -----------------------------------------------------------------------
-
-wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, const wxBitmap& bitmap, int value )
-{
-    EnsureData();
-
-    wxPGChoiceEntry* p = new wxPGChoiceEntry(label, value);
-    p->SetBitmap(bitmap);
-    m_data->Insert( -1, p );
-    return *p;
-}
-
-// -----------------------------------------------------------------------
-
-wxPGChoiceEntry& wxPGChoices::Insert( const wxPGChoiceEntry& entry, int index )
-{
-    EnsureData();
-
-    wxPGChoiceEntry* p = new wxPGChoiceEntry(entry);
-    m_data->Insert(index, p);
-    return *p;
-}
-
-// -----------------------------------------------------------------------
-
-wxPGChoiceEntry& wxPGChoices::Insert( const wxString& label, int index, int value )
-{
-    EnsureData();
-
-    wxPGChoiceEntry* p = new wxPGChoiceEntry(label, value);
-    m_data->Insert( index, p );
-    return *p;
-}
-
-// -----------------------------------------------------------------------
-
-wxPGChoiceEntry& wxPGChoices::AddAsSorted( const wxString& label, int value )
-{
-    EnsureData();
-
-    size_t index = 0;
-
-    while ( index < GetCount() )
-    {
-        int cmpRes = GetLabel(index).Cmp(label);
-        if ( cmpRes > 0 )
-            break;
-        index++;
-    }
-
-    wxPGChoiceEntry* p = new wxPGChoiceEntry(label, value);
-    m_data->Insert( index, p );
-    return *p;
-}
-
-// -----------------------------------------------------------------------
-
-void wxPGChoices::Add( const wxChar** labels, const ValArrItem* values )
-{
-    EnsureData();
-
-    unsigned int itemcount = 0;
-    const wxChar** p = &labels[0];
-    while ( *p ) { p++; itemcount++; }
-
-    unsigned int i;
-    for ( i = 0; i < itemcount; i++ )
-    {
-        int value = wxPG_INVALID_VALUE;
-        if ( values )
-            value = values[i];
-        m_data->Insert( -1, new wxPGChoiceEntry(labels[i], value) );
-    }
-}
-
-// -----------------------------------------------------------------------
-
-void wxPGChoices::Add( const wxArrayString& arr, const ValArrItem* values )
-{
-    EnsureData();
-
-    unsigned int i;
-    unsigned int itemcount = arr.size();
-
-    for ( i = 0; i < itemcount; i++ )
-    {
-        int value = wxPG_INVALID_VALUE;
-        if ( values )
-            value = values[i];
-        m_data->Insert( -1, new wxPGChoiceEntry(arr[i], value) );
-    }
-}
-
-// -----------------------------------------------------------------------
-
-void wxPGChoices::Add( const wxArrayString& arr, const wxArrayInt& arrint )
-{
-    EnsureData();
-
-    unsigned int i;
-    unsigned int itemcount = arr.size();
-
-    for ( i = 0; i < itemcount; i++ )
-    {
-        int value = wxPG_INVALID_VALUE;
-        if ( &arrint && arrint.size() )
-            value = arrint[i];
-        m_data->Insert( -1, new wxPGChoiceEntry(arr[i], value) );
-    }
-}
-
-// -----------------------------------------------------------------------
-
-void wxPGChoices::RemoveAt(size_t nIndex, size_t count)
-{
-    wxASSERT( m_data->m_refCount != 0xFFFFFFF );
-    unsigned int i;
-    for ( i=nIndex; i<(nIndex+count); i++)
-        delete m_data->Item(i);
-    m_data->m_items.RemoveAt(nIndex, count);
+    m_items = data->m_items;

 }
 
 }
 

-// -----------------------------------------------------------------------
-
-int wxPGChoices::Index( const wxString& str ) const
-{
-    if ( IsOk() )
-    {
-        unsigned int i;
-        for ( i=0; i< m_data->GetCount(); i++ )
-        {
-            if ( m_data->Item(i)->GetText() == str )
-                return i;
-        }
-    }
-    return -1;
-}
-
-// -----------------------------------------------------------------------
-
-int wxPGChoices::Index( int val ) const
+wxPGChoiceEntry& wxPGChoicesData::Insert( int index,
+                                          const wxPGChoiceEntry& item )

 {
 {

-    if ( IsOk() )
+    wxVector<wxPGChoiceEntry>::iterator it;
+    if ( index == -1 )

     {
     {

-        unsigned int i;
-        for ( i=0; i< m_data->GetCount(); i++ )
-        {
-            if ( m_data->Item(i)->GetValue() == val )
-                return i;
-        }
+        it = m_items.end();
+        index = (int) m_items.size();

     }
     }

-    return -1;
-}
-
-// -----------------------------------------------------------------------
-
-wxArrayString wxPGChoices::GetLabels() const
-{
-    wxArrayString arr;
-    unsigned int i;
-
-    if ( this && IsOk() )
-        for ( i=0; i<GetCount(); i++ )
-            arr.push_back(GetLabel(i));
-
-    return arr;
-}
-
-// -----------------------------------------------------------------------
-
-bool wxPGChoices::HasValues() const
-{
-    return true;
-}
-
-// -----------------------------------------------------------------------
-
-wxArrayInt wxPGChoices::GetValuesForStrings( const wxArrayString& strings ) const
-{
-    wxArrayInt arr;
-
-    if ( IsOk() )
-    {
-        unsigned int i;
-        for ( i=0; i< strings.size(); i++ )
-        {
-            int index = Index(strings[i]);
-            if ( index >= 0 )
-                arr.Add(GetValue(index));
-            else
-                arr.Add(wxPG_INVALID_VALUE);
-        }
-    }
-
-    return arr;
-}
-
-// -----------------------------------------------------------------------
-
-wxArrayInt wxPGChoices::GetIndicesForStrings( const wxArrayString& strings, 
-                                              wxArrayString* unmatched ) const
-{
-    wxArrayInt arr;
-
-    if ( IsOk() )
-    {
-        unsigned int i;
-        for ( i=0; i< strings.size(); i++ )
-        {
-            const wxString& str = strings[i];
-            int index = Index(str);
-            if ( index >= 0 )
-                arr.Add(index);
-            else if ( unmatched )
-                unmatched->Add(str);
-        }
-    }
-
-    return arr;
-}
-
-// -----------------------------------------------------------------------
-
-void wxPGChoices::AssignData( wxPGChoicesData* data )
-{
-    Free();
-
-    if ( data != wxPGChoicesEmptyData )
+    else

     {
     {

-        m_data = data;
-        data->m_refCount++;
+        it = m_items.begin() + index;

     }
     }

-}

 
 

-// -----------------------------------------------------------------------
+    m_items.insert(it, item);

 
 

-void wxPGChoices::Init()
-{
-    m_data = wxPGChoicesEmptyData;
-}
+    wxPGChoiceEntry& ownEntry = m_items[index];

 
 

-// -----------------------------------------------------------------------
+    // Need to fix value?
+    if ( ownEntry.GetValue() == wxPG_INVALID_VALUE )
+        ownEntry.SetValue(index);

 
 

-void wxPGChoices::Free()
-{
-    if ( m_data != wxPGChoicesEmptyData )
-    {
-        m_data->DecRef();
-        m_data = wxPGChoicesEmptyData;
-    }
+    return ownEntry;

 }
 
 // -----------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------


@@ -5960,15 +5258,15 @@ void wxPGChoices::Free()
 IMPLEMENT_DYNAMIC_CLASS(wxPropertyGridEvent, wxCommandEvent)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxPropertyGridEvent, wxCommandEvent)
 
 

-DEFINE_EVENT_TYPE( wxEVT_PG_SELECTED )
-DEFINE_EVENT_TYPE( wxEVT_PG_CHANGING )
-DEFINE_EVENT_TYPE( wxEVT_PG_CHANGED )
-DEFINE_EVENT_TYPE( wxEVT_PG_HIGHLIGHTED )
-DEFINE_EVENT_TYPE( wxEVT_PG_RIGHT_CLICK )
-DEFINE_EVENT_TYPE( wxEVT_PG_PAGE_CHANGED )
-DEFINE_EVENT_TYPE( wxEVT_PG_ITEM_EXPANDED )
-DEFINE_EVENT_TYPE( wxEVT_PG_ITEM_COLLAPSED )
-DEFINE_EVENT_TYPE( wxEVT_PG_DOUBLE_CLICK )
+wxDEFINE_EVENT( wxEVT_PG_SELECTED, wxPropertyGridEvent );
+wxDEFINE_EVENT( wxEVT_PG_CHANGING, wxPropertyGridEvent );
+wxDEFINE_EVENT( wxEVT_PG_CHANGED, wxPropertyGridEvent );
+wxDEFINE_EVENT( wxEVT_PG_HIGHLIGHTED, wxPropertyGridEvent );
+wxDEFINE_EVENT( wxEVT_PG_RIGHT_CLICK, wxPropertyGridEvent );
+wxDEFINE_EVENT( wxEVT_PG_PAGE_CHANGED, wxPropertyGridEvent );
+wxDEFINE_EVENT( wxEVT_PG_ITEM_EXPANDED, wxPropertyGridEvent );
+wxDEFINE_EVENT( wxEVT_PG_ITEM_COLLAPSED, wxPropertyGridEvent );
+wxDEFINE_EVENT( wxEVT_PG_DOUBLE_CLICK, wxPropertyGridEvent );

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


@@ -6099,7 +5397,8 @@ wxPGProperty* wxPropertyGridPopulator::Add( const wxString& propClass,
     m_state->DoInsert(parent, -1, property);
 
     if ( propValue )
     m_state->DoInsert(parent, -1, property);
 
     if ( propValue )

-        property->SetValueFromString( *propValue, wxPG_FULL_VALUE );
+        property->SetValueFromString( *propValue, wxPG_FULL_VALUE|
+                                                  wxPG_PROGRAMMATIC_VALUE );

 
     return property;
 }
 
     return property;
 }


@@ -6152,7 +5451,7 @@ wxPGChoices wxPropertyGridPopulator::ParseChoices( const wxString& choicesString
             int state = 0;
             bool labelValid = false;
 
             int state = 0;
             bool labelValid = false;
 

-            for ( ; it != choicesString.end(); it++ )
+            for ( ; it != choicesString.end(); ++it )

             {
                 wxChar c = *it;
 
             {
                 wxChar c = *it;