Use the data scheme to load resources in the WebKitGTK+ implementation, rather than...

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

diff --git a/src/propgrid/editors.cpp b/src/propgrid/editors.cpp
index ca85c51a29c16bda056c9ed24cae3c2b93955dd2..97647f7e3093ea0312ca7c0e76a0d82b8cc06ae4 100644 (file)
--- a/src/propgrid/editors.cpp
+++ b/src/propgrid/editors.cpp
@@ -4,9 +4,9 @@
 // Author:      Jaakko Salli
 // Modified by:
 // Created:     2007-04-14
 // Author:      Jaakko Salli
 // Modified by:
 // Created:     2007-04-14

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

 // Copyright:   (c) Jaakko Salli
 // Copyright:   (c) Jaakko Salli

-// Licence:     wxWindows license
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 // For compilers that support precompilation, includes "wx/wx.h".
 /////////////////////////////////////////////////////////////////////////////
 
 // For compilers that support precompilation, includes "wx/wx.h".


@@ -58,36 +58,29 @@
 // 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/props.h>
+#include "wx/propgrid/propgrid.h"
+#include "wx/propgrid/editors.h"
+#include "wx/propgrid/props.h"

 
 #if wxPG_USE_RENDERER_NATIVE
 
 #if wxPG_USE_RENDERER_NATIVE

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

 #endif
 
 // How many pixels between textctrl and button
 #ifdef __WXMAC__
 #endif
 
 // How many pixels between textctrl and button
 #ifdef __WXMAC__

-    #define wxPG_TEXTCTRL_AND_BUTTON_SPACING        8
+    #define wxPG_TEXTCTRL_AND_BUTTON_SPACING        4

 #else
     #define wxPG_TEXTCTRL_AND_BUTTON_SPACING        2
 #else
     #define wxPG_TEXTCTRL_AND_BUTTON_SPACING        2

-#endif 
+#endif

 
 #define wxPG_BUTTON_SIZEDEC                         0
 
 
 #define wxPG_BUTTON_SIZEDEC                         0
 

-#include <wx/odcombo.h>
-
-#ifdef __WXMSW__
-    #include <wx/msw/private.h>
-#endif
+#include "wx/odcombo.h"

 
 // -----------------------------------------------------------------------
 
 #if defined(__WXMSW__)
     // tested
 
 // -----------------------------------------------------------------------
 
 #if defined(__WXMSW__)
     // tested

-    #define wxPG_NAT_TEXTCTRL_BORDER_X          0 // Unremovable border of native textctrl.
-    #define wxPG_NAT_TEXTCTRL_BORDER_Y          0 // Unremovable border of native textctrl.
-

     #define wxPG_NAT_BUTTON_BORDER_ANY          1
     #define wxPG_NAT_BUTTON_BORDER_X            1
     #define wxPG_NAT_BUTTON_BORDER_Y            1
     #define wxPG_NAT_BUTTON_BORDER_ANY          1
     #define wxPG_NAT_BUTTON_BORDER_X            1
     #define wxPG_NAT_BUTTON_BORDER_Y            1


@@ -108,9 +101,6 @@
     #define wxPG_CHECKMARK_HADJ                 (-1)
     #define wxPG_CHECKMARK_DEFLATE              3
 
     #define wxPG_CHECKMARK_HADJ                 (-1)
     #define wxPG_CHECKMARK_DEFLATE              3
 

-    #define wxPG_NAT_TEXTCTRL_BORDER_X      3 // Unremovable border of native textctrl.
-    #define wxPG_NAT_TEXTCTRL_BORDER_Y      3 // Unremovable border of native textctrl.
-

     #define wxPG_NAT_BUTTON_BORDER_ANY      1
     #define wxPG_NAT_BUTTON_BORDER_X        1
     #define wxPG_NAT_BUTTON_BORDER_Y        1
     #define wxPG_NAT_BUTTON_BORDER_ANY      1
     #define wxPG_NAT_BUTTON_BORDER_X        1
     #define wxPG_NAT_BUTTON_BORDER_Y        1


@@ -125,14 +115,11 @@
     #define wxPG_CHECKMARK_HADJ                 0
     #define wxPG_CHECKMARK_DEFLATE              0
 
     #define wxPG_CHECKMARK_HADJ                 0
     #define wxPG_CHECKMARK_DEFLATE              0
 

-    #define wxPG_NAT_TEXTCTRL_BORDER_X      0 // Unremovable border of native textctrl.
-    #define wxPG_NAT_TEXTCTRL_BORDER_Y      0 // Unremovable border of native textctrl.
-

     #define wxPG_NAT_BUTTON_BORDER_ANY      0
     #define wxPG_NAT_BUTTON_BORDER_X        0
     #define wxPG_NAT_BUTTON_BORDER_Y        0
 
     #define wxPG_NAT_BUTTON_BORDER_ANY      0
     #define wxPG_NAT_BUTTON_BORDER_X        0
     #define wxPG_NAT_BUTTON_BORDER_Y        0
 

-    #define wxPG_TEXTCTRLYADJUST            3
+    #define wxPG_TEXTCTRLYADJUST            0

 
 #else
     // defaults
 
 #else
     // defaults


@@ -142,9 +129,6 @@
     #define wxPG_CHECKMARK_HADJ                 0
     #define wxPG_CHECKMARK_DEFLATE              0
 
     #define wxPG_CHECKMARK_HADJ                 0
     #define wxPG_CHECKMARK_DEFLATE              0
 

-    #define wxPG_NAT_TEXTCTRL_BORDER_X      0 // Unremovable border of native textctrl.
-    #define wxPG_NAT_TEXTCTRL_BORDER_Y      0 // Unremovable border of native textctrl.
-

     #define wxPG_NAT_BUTTON_BORDER_ANY      0
     #define wxPG_NAT_BUTTON_BORDER_X        0
     #define wxPG_NAT_BUTTON_BORDER_Y        0
     #define wxPG_NAT_BUTTON_BORDER_ANY      0
     #define wxPG_NAT_BUTTON_BORDER_X        0
     #define wxPG_NAT_BUTTON_BORDER_Y        0


@@ -153,20 +137,19 @@
 
 #endif
 
 
 #endif
 

-#if (!wxPG_NAT_TEXTCTRL_BORDER_X && !wxPG_NAT_TEXTCTRL_BORDER_Y)
-    #define wxPG_ENABLE_CLIPPER_WINDOW      0
-#else
-    #define wxPG_ENABLE_CLIPPER_WINDOW      1
-#endif
-
-

 // for odcombo
 // for odcombo

+#ifdef __WXMAC__
+#define wxPG_CHOICEXADJUST           -3 // required because wxComboCtrl reserves 3pixels for wxTextCtrl's focus ring
+#define wxPG_CHOICEYADJUST           -3
+#else

 #define wxPG_CHOICEXADJUST           0
 #define wxPG_CHOICEYADJUST           0
 #define wxPG_CHOICEXADJUST           0
 #define wxPG_CHOICEYADJUST           0

+#endif

 
 

-#define ODCB_CUST_PAINT_MARGIN               6  // Number added to image width for SetCustomPaintWidth
+// Number added to image width for SetCustomPaintWidth
+#define ODCB_CUST_PAINT_MARGIN               6

 
 

-// Milliseconds to wait for two mouse-ups after focus inorder
+// Milliseconds to wait for two mouse-ups after focus in order

 // to trigger a double-click.
 #define DOUBLE_CLICK_CONVERSION_TRESHOLD        500
 
 // to trigger a double-click.
 #define DOUBLE_CLICK_CONVERSION_TRESHOLD        500
 


@@ -181,10 +164,16 @@ wxPGEditor::~wxPGEditor()
 {
 }
 
 {
 }
 

-void wxPGEditor::DrawValue( wxDC& dc, const wxRect& rect, wxPGProperty* property, const wxString& text ) const
+wxString wxPGEditor::GetName() const

 {
 {

-    if ( !property->IsValueUnspecified() )
-        dc.DrawText( text, rect.x+wxPG_XBEFORETEXT, rect.y );
+    return GetClassInfo()->GetClassName();
+}
+
+void wxPGEditor::DrawValue( wxDC& dc, const wxRect& rect,
+                            wxPGProperty* WXUNUSED(property),
+                            const wxString& text ) const
+{
+    dc.DrawText( text, rect.x+wxPG_XBEFORETEXT, rect.y );

 }
 
 bool wxPGEditor::GetValueFromControl( wxVariant&, wxPGProperty*, wxWindow* ) const
 }
 
 bool wxPGEditor::GetValueFromControl( wxVariant&, wxPGProperty*, wxWindow* ) const


@@ -218,206 +207,119 @@ void wxPGEditor::OnFocus( wxPGProperty*, wxWindow* ) const
 {
 }
 
 {
 }
 

-
-bool wxPGEditor::CanContainCustomImage() const
-{
-    return false;
-}
-
-// -----------------------------------------------------------------------
-// wxPGClipperWindow
-// -----------------------------------------------------------------------
-
-
-#if wxPG_ENABLE_CLIPPER_WINDOW
-
-//
-// Clipper window is used to "remove" borders from controls
-// which otherwise insist on having them despite of supplied
-// wxNO_BORDER window style.
-//
-class wxPGClipperWindow : public wxWindow
+void wxPGEditor::SetControlAppearance( wxPropertyGrid* pg,
+                                       wxPGProperty* property,
+                                       wxWindow* ctrl,
+                                       const wxPGCell& cell,
+                                       const wxPGCell& oCell,
+                                       bool unspecified ) const

 {
 {

-    DECLARE_CLASS(wxPGClipperWindow)
-public:
-
-    wxPGClipperWindow()
-        : wxWindow()
+    // Get old editor appearance
+    wxTextCtrl* tc = NULL;
+    wxComboCtrl* cb = NULL;
+    if ( ctrl->IsKindOf(CLASSINFO(wxTextCtrl)) )

     {
     {

-        wxPGClipperWindow::Init();
+        tc = (wxTextCtrl*) ctrl;

     }
     }

-
-    wxPGClipperWindow(wxWindow* parent,
-                      wxWindowID id,
-                      const wxPoint& pos = wxDefaultPosition,
-                      const wxSize& size = wxDefaultSize)
+    else

     {
     {

-        Init();
-        Create(parent,id,pos,size);
+        if ( ctrl->IsKindOf(CLASSINFO(wxComboCtrl)) )
+        {
+            cb = (wxComboCtrl*) ctrl;
+            tc = cb->GetTextCtrl();
+        }

     }
 
     }
 

-    void Create(wxWindow* parent,
-                wxWindowID id,
-                const wxPoint& pos = wxDefaultPosition,
-                const wxSize& size = wxDefaultSize);
-
-    virtual ~wxPGClipperWindow();
-
-    virtual bool ProcessEvent(wxEvent& event);
-
-    inline wxWindow* GetControl() const { return m_ctrl; }
-
-    // This is called before wxControl is constructed.
-    void GetControlRect( int xadj, int yadj, wxPoint& pt, wxSize& sz );
-
-    // This is caleed after wxControl has been constructed.
-    void SetControl( wxWindow* ctrl );
-
-    virtual void Refresh( bool eraseBackground = true,
-                          const wxRect *rect = (const wxRect *) NULL );
-    virtual void SetFocus();
-
-    virtual bool SetFont(const wxFont& font);
-
-    inline int GetXClip() const { return m_xadj; }
-
-    inline int GetYClip() const { return m_yadj; }
+    if ( tc || cb )
+    {
+        wxString tcText;
+        bool changeText = false;

 
 

-protected:
-    wxWindow*       m_ctrl;
+        if ( cell.HasText() && !pg->IsEditorFocused() )
+        {
+            tcText = cell.GetText();
+            changeText = true;
+        }
+        else if ( oCell.HasText() )
+        {
+            tcText = property->GetValueAsString(
+                property->HasFlag(wxPG_PROP_READONLY)?0:wxPG_EDITABLE_VALUE);
+            changeText = true;
+        }

 
 

-    int             m_xadj; // Horizontal border clip.
+        if ( changeText )
+        {
+            // This prevents value from being modified
+            if ( tc )
+            {
+                pg->SetupTextCtrlValue(tcText);
+                tc->SetValue(tcText);
+            }
+            else
+            {
+                cb->SetText(tcText);
+            }
+        }
+    }

 
 

-    int             m_yadj; // Vertical border clip.
+    // Do not make the mistake of calling GetClassDefaultAttributes()
+    // here. It is static, while GetDefaultAttributes() is virtual
+    // and the correct one to use.
+    wxVisualAttributes vattrs = ctrl->GetDefaultAttributes();

 
 

-private:
-    void Init ()
+    // Foreground colour
+    const wxColour& fgCol = cell.GetFgCol();
+    if ( fgCol.IsOk() )

     {
     {

-        m_ctrl = (wxWindow*) NULL;
+        ctrl->SetForegroundColour(fgCol);
+    }
+    else if ( oCell.GetFgCol().IsOk() )
+    {
+        ctrl->SetForegroundColour(vattrs.colFg);

     }
     }

-};
-
-
-IMPLEMENT_CLASS(wxPGClipperWindow,wxWindow)
-
-
-// This is called before wxControl is constructed.
-void wxPGClipperWindow::GetControlRect( int xadj, int yadj, wxPoint& pt, wxSize& sz )
-{
-    m_xadj = xadj;
-    m_yadj = yadj;
-    pt.x = -xadj;
-    pt.y = -yadj;
-    wxSize own_size = GetSize();
-    sz.x = own_size.x+(xadj*2);
-    sz.y = own_size.y+(yadj*2);
-}
-
-
-// This is caleed after wxControl has been constructed.
-void wxPGClipperWindow::SetControl( wxWindow* ctrl )
-{
-    m_ctrl = ctrl;
-
-    // GTK requires this.
-    ctrl->SetSizeHints(3,3);
-
-    // Correct size of this window to match the child.
-    wxSize sz = GetSize();
-    wxSize chsz = ctrl->GetSize();
-
-    int hei_adj = chsz.y - (sz.y+(m_yadj*2));
-    if ( hei_adj )
-        SetSize(sz.x,chsz.y-(m_yadj*2));
-
-}
-
-
-void wxPGClipperWindow::Refresh( bool eraseBackground, const wxRect *rect )
-{
-    wxWindow::Refresh(false,rect);
-    if ( m_ctrl )
-        m_ctrl->Refresh(eraseBackground);
-}
-
-
-// Pass focus to control
-void wxPGClipperWindow::SetFocus()
-{
-    if ( m_ctrl )
-        m_ctrl->SetFocus();
-    else
-        wxWindow::SetFocus();
-}
-

 
 

-bool wxPGClipperWindow::SetFont(const wxFont& font)
-{
-    bool res = wxWindow::SetFont(font);
-    if ( m_ctrl )
-        return m_ctrl->SetFont(font);
-    return res;
-}
+    // Background colour
+    const wxColour& bgCol = cell.GetBgCol();
+    if ( bgCol.IsOk() )
+    {
+        ctrl->SetBackgroundColour(bgCol);
+    }
+    else if ( oCell.GetBgCol().IsOk() )
+    {
+        ctrl->SetBackgroundColour(vattrs.colBg);
+    }

 
 

+    // Font
+    const wxFont& font = cell.GetFont();
+    if ( font.IsOk() )
+    {
+        ctrl->SetFont(font);
+    }
+    else if ( oCell.GetFont().IsOk() )
+    {
+        ctrl->SetFont(vattrs.font);
+    }

 
 

-void wxPGClipperWindow::Create(wxWindow* parent,
-                               wxWindowID id,
-                               const wxPoint& pos,
-                               const wxSize& size )
-{
-    wxWindow::Create(parent,id,pos,size);
+    // Also call the old SetValueToUnspecified()
+    if ( unspecified )
+        SetValueToUnspecified(property, ctrl);

 }
 
 }
 

-
-wxPGClipperWindow::~wxPGClipperWindow()
+void wxPGEditor::SetValueToUnspecified( wxPGProperty* WXUNUSED(property),
+                                        wxWindow* WXUNUSED(ctrl) ) const

 {
 }
 
 {
 }
 

-
-bool wxPGClipperWindow::ProcessEvent(wxEvent& event)
+bool wxPGEditor::CanContainCustomImage() const

 {
 {

-    if ( event.GetEventType() == wxEVT_SIZE )
-    {
-        if ( m_ctrl )
-        {
-            // Maintain correct size relationship.
-            wxSize sz = GetSize();
-            m_ctrl->SetSize(sz.x+(m_xadj*2),sz.y+(m_yadj*2));
-            event.Skip();
-            return false;
-        }
-    }
-    return wxWindow::ProcessEvent(event);
+    return false;

 }
 
 }
 

-#endif // wxPG_ENABLE_CLIPPER_WINDOW
-
-/*wxWindow* wxPropertyGrid::GetActualEditorControl( wxWindow* ctrl )
-{
-#if wxPG_ENABLE_CLIPPER_WINDOW
-    // Pass real control instead of clipper window
-    if ( ctrl->IsKindOf(CLASSINFO(wxPGClipperWindow)) )
-    {
-        return ((wxPGClipperWindow*)ctrl)->GetControl();
-    }
-#else
-    return ctrl;
-#endif
-}*/
-

 // -----------------------------------------------------------------------
 // wxPGTextCtrlEditor
 // -----------------------------------------------------------------------
 
 // -----------------------------------------------------------------------
 // wxPGTextCtrlEditor
 // -----------------------------------------------------------------------
 

-// Clipper window support macro (depending on whether it is used
-// for this editor or not)
-#if wxPG_NAT_TEXTCTRL_BORDER_X || wxPG_NAT_TEXTCTRL_BORDER_Y
-    #define wxPG_NAT_TEXTCTRL_BORDER_ANY    1
-#else
-    #define wxPG_NAT_TEXTCTRL_BORDER_ANY    0
-#endif
-
-WX_PG_IMPLEMENT_EDITOR_CLASS(TextCtrl,wxPGTextCtrlEditor,wxPGEditor)
+WX_PG_IMPLEMENT_INTERNAL_EDITOR_CLASS(TextCtrl,wxPGTextCtrlEditor,wxPGEditor)

 
 
 wxPGWindowList wxPGTextCtrlEditor::CreateControls( wxPropertyGrid* propGrid,
 
 
 wxPGWindowList wxPGTextCtrlEditor::CreateControls( wxPropertyGrid* propGrid,


@@ -431,17 +333,20 @@ wxPGWindowList wxPGTextCtrlEditor::CreateControls( wxPropertyGrid* propGrid,
     // If has children, and limited editing is specified, then don't create.
     if ( (property->GetFlags() & wxPG_PROP_NOEDITOR) &&
          property->GetChildCount() )
     // If has children, and limited editing is specified, then don't create.
     if ( (property->GetFlags() & wxPG_PROP_NOEDITOR) &&
          property->GetChildCount() )

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

 
 

-    if ( !property->IsValueUnspecified() )
-        text = property->GetValueString(property->HasFlag(wxPG_PROP_READONLY)?0:wxPG_EDITABLE_VALUE);
+    int argFlags = 0;
+    if ( !property->HasFlag(wxPG_PROP_READONLY) &&
+         !property->IsValueUnspecified() )
+        argFlags |= wxPG_EDITABLE_VALUE;
+    text = property->GetValueAsString(argFlags);

 
     int flags = 0;
     if ( (property->GetFlags() & wxPG_PROP_PASSWORD) &&
          property->IsKindOf(CLASSINFO(wxStringProperty)) )
         flags |= wxTE_PASSWORD;
 
 
     int flags = 0;
     if ( (property->GetFlags() & wxPG_PROP_PASSWORD) &&
          property->IsKindOf(CLASSINFO(wxStringProperty)) )
         flags |= wxTE_PASSWORD;
 

-    wxWindow* wnd = propGrid->GenerateEditorTextCtrl(pos,sz,text,(wxWindow*)NULL,flags,
+    wxWindow* wnd = propGrid->GenerateEditorTextCtrl(pos,sz,text,NULL,flags,

                                                      property->GetMaxLength());
 
     return wnd;
                                                      property->GetMaxLength());
 
     return wnd;


@@ -480,9 +385,16 @@ void wxPGTextCtrlEditor::UpdateControl( wxPGProperty* property, wxWindow* ctrl )
     else
         s = property->GetDisplayedString();
 
     else
         s = property->GetDisplayedString();
 

-    tc->SetValue(s);    
-}
+    wxPropertyGrid* pg = property->GetGrid();
+
+    pg->SetupTextCtrlValue(s);
+    tc->SetValue(s);

 
 

+    //
+    // Fix indentation, just in case (change in font boldness is one good
+    // reason).
+    tc->SetMargins(0);
+}

 
 // Provided so that, for example, ComboBox editor can use the same code
 // (multiple inheritance would get way too messy).
 
 // Provided so that, for example, ComboBox editor can use the same code
 // (multiple inheritance would get way too messy).


@@ -532,7 +444,7 @@ bool wxPGTextCtrlEditor::GetTextCtrlValueFromControl( wxVariant& variant, wxPGPr
     wxTextCtrl* tc = wxStaticCast(ctrl, wxTextCtrl);
     wxString textVal = tc->GetValue();
 
     wxTextCtrl* tc = wxStaticCast(ctrl, wxTextCtrl);
     wxString textVal = tc->GetValue();
 

-    if ( property->UsesAutoUnspecified() && !textVal.length() )
+    if ( property->UsesAutoUnspecified() && textVal.empty() )

     {
         variant.MakeNull();
         return true;
     {
         variant.MakeNull();
         return true;


@@ -556,17 +468,6 @@ bool wxPGTextCtrlEditor::GetValueFromControl( wxVariant& variant, wxPGProperty*
 }
 
 
 }
 
 

-void wxPGTextCtrlEditor::SetValueToUnspecified( wxPGProperty* property, wxWindow* ctrl ) const
-{
-    wxTextCtrl* tc = wxStaticCast(ctrl, wxTextCtrl);
-
-    wxPropertyGrid* pg = property->GetGrid();
-    wxASSERT(pg);  // Really, property grid should exist if editor does
-    if ( pg )
-        tc->SetValue(wxEmptyString);
-}
-
-

 void wxPGTextCtrlEditor::SetControlStringValue( wxPGProperty* property, wxWindow* ctrl, const wxString& txt ) const
 {
     wxTextCtrl* tc = wxStaticCast(ctrl, wxTextCtrl);
 void wxPGTextCtrlEditor::SetControlStringValue( wxPGProperty* property, wxWindow* ctrl, const wxString& txt ) const
 {
     wxTextCtrl* tc = wxStaticCast(ctrl, wxTextCtrl);


@@ -574,19 +475,44 @@ void wxPGTextCtrlEditor::SetControlStringValue( wxPGProperty* property, wxWindow
     wxPropertyGrid* pg = property->GetGrid();
     wxASSERT(pg);  // Really, property grid should exist if editor does
     if ( pg )
     wxPropertyGrid* pg = property->GetGrid();
     wxASSERT(pg);  // Really, property grid should exist if editor does
     if ( pg )

+    {
+        pg->SetupTextCtrlValue(txt);

         tc->SetValue(txt);
         tc->SetValue(txt);

+    }

 }
 
 
 }
 
 

-void wxPGTextCtrlEditor::OnFocus( wxPGProperty*, wxWindow* wnd ) const
+void wxPGTextCtrlEditor_OnFocus( wxPGProperty* property,
+                                 wxTextCtrl* tc )

 {
 {

-    wxTextCtrl* tc = wxStaticCast(wnd, wxTextCtrl);
+    // Make sure there is correct text (instead of unspecified value
+    // indicator or hint text)
+    int flags = property->HasFlag(wxPG_PROP_READONLY) ?
+        0 : wxPG_EDITABLE_VALUE;
+    wxString correctText = property->GetValueAsString(flags);
+
+    if ( tc->GetValue() != correctText )
+    {
+        property->GetGrid()->SetupTextCtrlValue(correctText);
+        tc->SetValue(correctText);
+    }

 
     tc->SetSelection(-1,-1);
 }
 
 
     tc->SetSelection(-1,-1);
 }
 

+void wxPGTextCtrlEditor::OnFocus( wxPGProperty* property,
+                                  wxWindow* wnd ) const
+{
+    wxTextCtrl* tc = wxStaticCast(wnd, wxTextCtrl);
+    wxPGTextCtrlEditor_OnFocus(property, tc);
+}

 
 

-wxPGTextCtrlEditor::~wxPGTextCtrlEditor() { }
+wxPGTextCtrlEditor::~wxPGTextCtrlEditor()
+{
+    // Reset the global pointer. Useful when wxPropertyGrid is accessed
+    // from an external main loop.
+    wxPG_EDITOR(TextCtrl) = NULL;
+}

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


@@ -594,7 +520,7 @@ wxPGTextCtrlEditor::~wxPGTextCtrlEditor() { }
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 
 

-WX_PG_IMPLEMENT_EDITOR_CLASS(Choice,wxPGChoiceEditor,wxPGEditor)
+WX_PG_IMPLEMENT_INTERNAL_EDITOR_CLASS(Choice,wxPGChoiceEditor,wxPGEditor)

 
 
 // This is a special enhanced double-click processor class.
 
 
 // This is a special enhanced double-click processor class.


@@ -691,7 +617,7 @@ public:
     wxPGComboBox()
         : wxOwnerDrawnComboBox()
     {
     wxPGComboBox()
         : wxOwnerDrawnComboBox()
     {

-        m_dclickProcessor = (wxPGDoubleClickProcessor*) NULL;
+        m_dclickProcessor = NULL;

         m_sizeEventCalled = false;
     }
 
         m_sizeEventCalled = false;
     }
 


@@ -725,31 +651,47 @@ public:
                                             name ) )
             return false;
 
                                             name ) )
             return false;
 

-        m_dclickProcessor = new wxPGDoubleClickProcessor(this, GetGrid()->GetSelection() );
+        m_dclickProcessor = new
+            wxPGDoubleClickProcessor( this, GetGrid()->GetSelection() );

 
         PushEventHandler(m_dclickProcessor);
 
         return true;
     }
 
 
         PushEventHandler(m_dclickProcessor);
 
         return true;
     }
 

-    virtual void OnDrawItem( wxDC& dc, const wxRect& rect, int item, int flags ) const
+    virtual void OnDrawItem( wxDC& dc,
+                             const wxRect& rect,
+                             int item,
+                             int flags ) const

     {
         wxPropertyGrid* pg = GetGrid();
     {
         wxPropertyGrid* pg = GetGrid();

-        pg->OnComboItemPaint((wxPGCustomComboControl*)this,item,dc,(wxRect&)rect,flags);
+
+        // Handle hint text via super class
+        if ( (flags & wxODCB_PAINTING_CONTROL) &&
+             ShouldUseHintText(flags) )
+        {
+            wxOwnerDrawnComboBox::OnDrawItem(dc, rect, item, flags);
+        }
+        else
+        {
+            pg->OnComboItemPaint( this, item, &dc, (wxRect&)rect, flags );
+        }

     }
     }

+

     virtual wxCoord OnMeasureItem( size_t item ) const
     {
         wxPropertyGrid* pg = GetGrid();
         wxRect rect;
         rect.x = -1;
         rect.width = 0;
     virtual wxCoord OnMeasureItem( size_t item ) const
     {
         wxPropertyGrid* pg = GetGrid();
         wxRect rect;
         rect.x = -1;
         rect.width = 0;

-        pg->OnComboItemPaint((wxPGCustomComboControl*)this,item,*((wxDC*)NULL),rect,0);
+        pg->OnComboItemPaint( this, item, NULL, rect, 0 );

         return rect.height;
     }
 
     wxPropertyGrid* GetGrid() const
     {
         return rect.height;
     }
 
     wxPropertyGrid* GetGrid() const
     {

-        wxPropertyGrid* pg = wxDynamicCast(GetParent()->GetParent(),wxPropertyGrid);
+        wxPropertyGrid* pg = wxDynamicCast(GetParent(),
+                                           wxPropertyGrid);

         wxASSERT(pg);
         return pg;
     }
         wxASSERT(pg);
         return pg;
     }


@@ -760,15 +702,20 @@ public:
         wxRect rect;
         rect.x = -1;
         rect.width = -1;
         wxRect rect;
         rect.x = -1;
         rect.width = -1;

-        pg->OnComboItemPaint((wxPGCustomComboControl*)this,item,*((wxDC*)NULL),rect,0);
+        pg->OnComboItemPaint( this, item, NULL, rect, 0 );

         return rect.width;
     }
 
         return rect.width;
     }
 

-    virtual void PositionTextCtrl( int WXUNUSED(textCtrlXAdjust), int WXUNUSED(textCtrlYAdjust) )
+    virtual void PositionTextCtrl( int textCtrlXAdjust,
+                                   int WXUNUSED(textCtrlYAdjust) )

     {
         wxPropertyGrid* pg = GetGrid();
     {
         wxPropertyGrid* pg = GetGrid();

+    #ifdef wxPG_TEXTCTRLXADJUST
+        textCtrlXAdjust = wxPG_TEXTCTRLXADJUST -
+                          (wxPG_XBEFOREWIDGET+wxPG_CONTROL_MARGIN+1) - 1,
+    #endif

         wxOwnerDrawnComboBox::PositionTextCtrl(
         wxOwnerDrawnComboBox::PositionTextCtrl(

-            wxPG_TEXTCTRLXADJUST - (wxPG_XBEFOREWIDGET+wxPG_CONTROL_MARGIN+1) - 1,
+            textCtrlXAdjust,

             pg->GetSpacingY() + 2
         );
     }
             pg->GetSpacingY() + 2
         );
     }


@@ -779,18 +726,16 @@ private:
 };
 
 
 };
 
 

-void wxPropertyGrid::OnComboItemPaint( wxPGCustomComboControl* pCc,
+void wxPropertyGrid::OnComboItemPaint( const wxPGComboBox* pCb,

                                        int item,
                                        int item,

-                                       wxDC& dc,
+                                       wxDC* pDc,

                                        wxRect& rect,
                                        int flags )
 {
                                        wxRect& rect,
                                        int flags )
 {

-    wxPGComboBox* pCb = (wxPGComboBox*)pCc;
-

     // Sanity check
     wxASSERT( IsKindOf(CLASSINFO(wxPropertyGrid)) );
 
     // Sanity check
     wxASSERT( IsKindOf(CLASSINFO(wxPropertyGrid)) );
 

-    wxPGProperty* p = m_selected;
+    wxPGProperty* p = GetSelection();

     wxString text;
 
     const wxPGChoices& choices = p->GetChoices();
     wxString text;
 
     const wxPGChoices& choices = p->GetChoices();


@@ -818,7 +763,7 @@ void wxPropertyGrid::OnComboItemPaint( wxPGCustomComboControl* pCc,
         else
         {
             if ( !p->IsValueUnspecified() )
         else
         {
             if ( !p->IsValueUnspecified() )

-                text = p->GetValueString(0);
+                text = p->GetValueAsString(0);

         }
     }
 
         }
     }
 


@@ -829,7 +774,7 @@ void wxPropertyGrid::OnComboItemPaint( wxPGCustomComboControl* pCc,
 
     const wxBitmap* itemBitmap = NULL;
 
 
     const wxBitmap* itemBitmap = NULL;
 

-    if ( item >= 0 && choices.IsOk() && choices.Item(item).GetBitmap().Ok() && comValIndex == -1 )
+    if ( item >= 0 && choices.IsOk() && choices.Item(item).GetBitmap().IsOk() && comValIndex == -1 )

         itemBitmap = &choices.Item(item).GetBitmap();
 
     //
         itemBitmap = &choices.Item(item).GetBitmap();
 
     //


@@ -850,7 +795,7 @@ void wxPropertyGrid::OnComboItemPaint( wxPGCustomComboControl* pCc,
         if ( rect.width < 0 )
         {
             wxCoord x, y;
         if ( rect.width < 0 )
         {
             wxCoord x, y;

-            GetTextExtent(text, &x, &y, 0, 0, &m_font);
+            pCb->GetTextExtent(text, &x, &y, 0, 0);

             rect.width = cis.x + wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2 + 9 + x;
         }
 
             rect.width = cis.x + wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2 + 9 + x;
         }
 


@@ -866,30 +811,64 @@ void wxPropertyGrid::OnComboItemPaint( wxPGCustomComboControl* pCc,
     if ( (flags & wxODCB_PAINTING_CONTROL) )
         paintdata.m_choiceItem = -1;
 
     if ( (flags & wxODCB_PAINTING_CONTROL) )
         paintdata.m_choiceItem = -1;
 

-    if ( &dc )
-        dc.SetBrush(*wxWHITE_BRUSH);
+    if ( pDc )
+        pDc->SetBrush(*wxWHITE_BRUSH);
+
+    wxPGCellRenderer* renderer = NULL;
+    const wxPGChoiceEntry* cell = NULL;

 
     if ( rect.x >= 0 )
     {
         //
         // DrawItem call
 
     if ( rect.x >= 0 )
     {
         //
         // DrawItem call

+        wxDC& dc = *pDc;

 
         wxPoint pt(rect.x + wxPG_CONTROL_MARGIN - wxPG_CHOICEXADJUST - 1,
                    rect.y + 1);
 
 
         wxPoint pt(rect.x + wxPG_CONTROL_MARGIN - wxPG_CHOICEXADJUST - 1,
                    rect.y + 1);
 

-        int renderFlags = 0;
+        int renderFlags = wxPGCellRenderer::DontUseCellColours;
+        bool useCustomPaintProcedure;

 
 

-        if ( flags & wxODCB_PAINTING_CONTROL )
-            renderFlags |= wxPGCellRenderer::Control;
+        // If custom image had some size, we will start from the assumption
+        // that custom paint procedure is required
+        if ( cis.x > 0 )
+            useCustomPaintProcedure = true;
+        else
+            useCustomPaintProcedure = false;

 
         if ( flags & wxODCB_PAINTING_SELECTED )
             renderFlags |= wxPGCellRenderer::Selected;
 
 
         if ( flags & wxODCB_PAINTING_SELECTED )
             renderFlags |= wxPGCellRenderer::Selected;
 

-        if ( cis.x > 0 && (p->HasFlag(wxPG_PROP_CUSTOMIMAGE) || !(flags & wxODCB_PAINTING_CONTROL)) &&
-             ( !p->m_valueBitmap || item == pCb->GetSelection() ) &&
-             ( item >= 0 || (flags & wxODCB_PAINTING_CONTROL) ) &&
-             !itemBitmap
-           )
+        if ( flags & wxODCB_PAINTING_CONTROL )
+        {
+            renderFlags |= wxPGCellRenderer::Control;
+
+            // If wxPG_PROP_CUSTOMIMAGE was set, then that means any custom
+            // image will not appear on the control row (it may be too
+            // large to fit, for instance). Also do not draw custom image
+            // if no choice was selected.
+            if ( !p->HasFlag(wxPG_PROP_CUSTOMIMAGE) || item < 0 )
+                useCustomPaintProcedure = false;
+        }
+        else
+        {
+            renderFlags |= wxPGCellRenderer::ChoicePopup;
+
+            // For consistency, always use normal font when drawing drop down
+            // items
+            dc.SetFont(GetFont());
+        }
+
+        // If not drawing a selected popup item, then give property's
+        // m_valueBitmap a chance.
+        if ( p->m_valueBitmap && item != pCb->GetSelection() )
+            useCustomPaintProcedure = false;
+        // If current choice had a bitmap set by the application, then
+        // use it instead of any custom paint procedure.
+        else if ( itemBitmap )
+            useCustomPaintProcedure = false;
+
+        if ( useCustomPaintProcedure )

         {
             pt.x += wxCC_CUSTOM_IMAGE_MARGIN1;
             wxRect r(pt.x,pt.y,cis.x,cis.y);
         {
             pt.x += wxCC_CUSTOM_IMAGE_MARGIN1;
             wxRect r(pt.x,pt.y,cis.x,cis.y);


@@ -934,11 +913,13 @@ void wxPropertyGrid::OnComboItemPaint( wxPGCustomComboControl* pCc,
 
             if ( choices.IsOk() && item >= 0 && comValIndex < 0 )
             {
 
             if ( choices.IsOk() && item >= 0 && comValIndex < 0 )
             {

-                const wxPGChoiceEntry& cell = choices.Item(item);
-                wxPGCellRenderer* renderer = wxPGGlobalVars->m_defaultRenderer;
-                int imageOffset = renderer->PreDrawCell( dc, rect, cell, renderFlags );
+                cell = &choices.Item(item);
+                renderer = wxPGGlobalVars->m_defaultRenderer;
+                int imageOffset = renderer->PreDrawCell(dc, rect, *cell,
+                                                        renderFlags );

                 if ( imageOffset )
                 if ( imageOffset )

-                    imageOffset += wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2;
+                    imageOffset += wxCC_CUSTOM_IMAGE_MARGIN1 +
+                                   wxCC_CUSTOM_IMAGE_MARGIN2;

                 pt.x += imageOffset;
             }
         }
                 pt.x += imageOffset;
             }
         }


@@ -952,11 +933,15 @@ void wxPropertyGrid::OnComboItemPaint( wxPGCustomComboControl* pCc,
         pt.x += 1;
 
         dc.DrawText( text, pt.x + wxPG_XBEFORETEXT, pt.y );
         pt.x += 1;
 
         dc.DrawText( text, pt.x + wxPG_XBEFORETEXT, pt.y );

+
+        if ( renderer )
+            renderer->PostDrawCell(dc, this, *cell, renderFlags);

     }
     else
     {
         //
         // MeasureItem call
     }
     else
     {
         //
         // MeasureItem call

+        wxDC& dc = *pDc;

 
         p->OnCustomPaint( dc, rect, paintdata );
         rect.height = paintdata.m_drawnHeight + 2;
 
         p->OnCustomPaint( dc, rect, paintdata );
         rect.height = paintdata.m_drawnHeight + 2;


@@ -969,23 +954,35 @@ bool wxPGChoiceEditor_SetCustomPaintWidth( wxPropertyGrid* propGrid, wxPGComboBo
     wxPGProperty* property = propGrid->GetSelectedProperty();
     wxASSERT( property );
 
     wxPGProperty* property = propGrid->GetSelectedProperty();
     wxASSERT( property );
 

+    wxSize imageSize;
+    bool res;
+
+    // TODO: Do this always when cell has custom text.
+    if ( property->IsValueUnspecified() )
+    {
+        cb->SetCustomPaintWidth( 0 );
+        return true;
+    }
+

     if ( cmnVal >= 0 )
     {
         // Yes, a common value is being selected
         property->SetCommonValue( cmnVal );
     if ( cmnVal >= 0 )
     {
         // Yes, a common value is being selected
         property->SetCommonValue( cmnVal );

-        wxSize imageSize = propGrid->GetCommonValue(cmnVal)->
+        imageSize = propGrid->GetCommonValue(cmnVal)->

                             GetRenderer()->GetImageSize(property, 1, cmnVal);
                             GetRenderer()->GetImageSize(property, 1, cmnVal);

-        if ( imageSize.x ) imageSize.x += ODCB_CUST_PAINT_MARGIN;
-        cb->SetCustomPaintWidth( imageSize.x );
-        return false;
+        res = false;

     }
     else
     {
     }
     else
     {

-        wxSize imageSize = propGrid->GetImageSize(property, -1);
-        if ( imageSize.x ) imageSize.x += ODCB_CUST_PAINT_MARGIN;
-        cb->SetCustomPaintWidth( imageSize.x );
-        return true;
+        imageSize = propGrid->GetImageSize(property, -1);
+        res = true;

     }
     }

+
+    if ( imageSize.x )
+        imageSize.x += ODCB_CUST_PAINT_MARGIN;
+    cb->SetCustomPaintWidth( imageSize.x );
+
+    return res;

 }
 
 // CreateControls calls this with CB_READONLY in extraStyle
 }
 
 // CreateControls calls this with CB_READONLY in extraStyle


@@ -995,14 +992,21 @@ wxWindow* wxPGChoiceEditor::CreateControlsBase( wxPropertyGrid* propGrid,
                                                 const wxSize& sz,
                                                 long extraStyle ) const
 {
                                                 const wxSize& sz,
                                                 long extraStyle ) const
 {

+    // Since it is not possible (yet) to create a read-only combo box in
+    // the same sense that wxTextCtrl is read-only, simply do not create
+    // the control in this case.
+    if ( property->HasFlag(wxPG_PROP_READONLY) )
+        return NULL;
+

     const wxPGChoices& choices = property->GetChoices();
     wxString defString;
     int index = property->GetChoiceSelection();
 
     const wxPGChoices& choices = property->GetChoices();
     wxString defString;
     int index = property->GetChoiceSelection();
 

-    bool isUnspecified = property->IsValueUnspecified();
-
-    if ( !isUnspecified )
-        defString = property->GetDisplayedString();
+    int argFlags = 0;
+    if ( !property->HasFlag(wxPG_PROP_READONLY) &&
+         !property->IsValueUnspecified() )
+        argFlags |= wxPG_EDITABLE_VALUE;
+    defString = property->GetValueAsString(argFlags);

 
     wxArrayString labels = choices.GetLabels();
 
 
     wxArrayString labels = choices.GetLabels();
 


@@ -1017,14 +1021,18 @@ wxWindow* wxPGChoiceEditor::CreateControlsBase( wxPropertyGrid* propGrid,
     si.x -= wxPG_CHOICEXADJUST;
     wxWindow* ctrlParent = propGrid->GetPanel();
 
     si.x -= wxPG_CHOICEXADJUST;
     wxWindow* ctrlParent = propGrid->GetPanel();
 

-    int odcbFlags = extraStyle | wxNO_BORDER | wxTE_PROCESS_ENTER;
+    int odcbFlags = extraStyle | wxBORDER_NONE | wxTE_PROCESS_ENTER;
+
+    if ( (property->GetFlags() & wxPG_PROP_USE_DCC) &&
+         (property->IsKindOf(CLASSINFO(wxBoolProperty)) ) )
+        odcbFlags |= wxODCB_DCLICK_CYCLES;

 
     //
     // If common value specified, use appropriate index
     unsigned int cmnVals = property->GetDisplayedCommonValueCount();
     if ( cmnVals )
     {
 
     //
     // If common value specified, use appropriate index
     unsigned int cmnVals = property->GetDisplayedCommonValueCount();
     if ( cmnVals )
     {

-        if ( !isUnspecified )
+        if ( !property->IsValueUnspecified() )

         {
             int cmnVal = property->GetCommonValue();
             if ( cmnVal >= 0 )
         {
             int cmnVal = property->GetCommonValue();
             if ( cmnVal >= 0 )


@@ -1051,29 +1059,29 @@ wxWindow* wxPGChoiceEditor::CreateControlsBase( wxPropertyGrid* propGrid,
                odcbFlags);
 
     cb->SetButtonPosition(si.y,0,wxRIGHT);
                odcbFlags);
 
     cb->SetButtonPosition(si.y,0,wxRIGHT);

-    cb->SetTextIndent(wxPG_XBEFORETEXT-1);
+    cb->SetMargins(wxPG_XBEFORETEXT-1);

 
 

-    wxPGChoiceEditor_SetCustomPaintWidth( propGrid, cb, property->GetCommonValue() );
+    // Set hint text
+    cb->SetHint(property->GetHintText());
+
+    wxPGChoiceEditor_SetCustomPaintWidth( propGrid, cb,
+                                          property->GetCommonValue() );

 
     if ( index >= 0 && index < (int)cb->GetCount() )
     {
         cb->SetSelection( index );
 
     if ( index >= 0 && index < (int)cb->GetCount() )
     {
         cb->SetSelection( index );

-        if ( defString.length() )
+        if ( !defString.empty() )

             cb->SetText( defString );
     }
             cb->SetText( defString );
     }

-    else if ( !(extraStyle & wxCB_READONLY) && defString.length() )
+    else if ( !(extraStyle & wxCB_READONLY) && !defString.empty() )
+    {
+        propGrid->SetupTextCtrlValue(defString);

         cb->SetValue( defString );
         cb->SetValue( defString );

+    }

     else
     else

+    {

         cb->SetSelection( -1 );
         cb->SetSelection( -1 );

-
-    // Connect event handling
-    wxWindowID id = cb->GetId();
-    propGrid->Connect(id, wxEVT_COMMAND_COMBOBOX_SELECTED,
-        wxCommandEventHandler(wxPropertyGrid::OnCustomEditorEvent));
-    propGrid->Connect(id, wxEVT_COMMAND_TEXT_UPDATED,
-        wxCommandEventHandler(wxPropertyGrid::OnCustomEditorEvent));
-    propGrid->Connect(id, wxEVT_COMMAND_TEXT_ENTER,
-        wxCommandEventHandler(wxPropertyGrid::OnCustomEditorEvent));
+    }

 
 #ifdef __WXMSW__
     cb->Show();
 
 #ifdef __WXMSW__
     cb->Show();


@@ -1145,11 +1153,16 @@ bool wxPGChoiceEditor::OnEvent( wxPropertyGrid* propGrid, wxPGProperty* property
                     propGrid->SetInternalFlag(wxPG_FL_VALUE_CHANGE_IN_EVENT);
                 property->SetValueToUnspecified();
                 if ( !cb->HasFlag(wxCB_READONLY) )
                     propGrid->SetInternalFlag(wxPG_FL_VALUE_CHANGE_IN_EVENT);
                 property->SetValueToUnspecified();
                 if ( !cb->HasFlag(wxCB_READONLY) )

-                    cb->GetTextCtrl()->SetValue(wxEmptyString);
+                {
+                    wxString unspecValueText;
+                    unspecValueText = propGrid->GetUnspecifiedValueText();
+                    propGrid->SetupTextCtrlValue(unspecValueText);
+                    cb->GetTextCtrl()->SetValue(unspecValueText);
+                }

                 return false;
             }
         }
                 return false;
             }
         }

-        return wxPGChoiceEditor_SetCustomPaintWidth( propGrid, cb, cmnValIndex );        
+        return wxPGChoiceEditor_SetCustomPaintWidth( propGrid, cb, cmnValIndex );

     }
     return false;
 }
     }
     return false;
 }


@@ -1173,10 +1186,13 @@ bool wxPGChoiceEditor::GetValueFromControl( wxVariant& variant, wxPGProperty* pr
 }
 
 
 }
 
 

-void wxPGChoiceEditor::SetControlStringValue( wxPGProperty* WXUNUSED(property), wxWindow* ctrl, const wxString& txt ) const
+void wxPGChoiceEditor::SetControlStringValue( wxPGProperty* property,
+                                              wxWindow* ctrl,
+                                              const wxString& txt ) const

 {
     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
     wxASSERT( cb );
 {
     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
     wxASSERT( cb );

+    property->GetGrid()->SetupTextCtrlValue(txt);

     cb->SetValue(txt);
 }
 
     cb->SetValue(txt);
 }
 


@@ -1189,10 +1205,13 @@ void wxPGChoiceEditor::SetControlIntValue( wxPGProperty* WXUNUSED(property), wxW
 }
 
 
 }
 
 

-void wxPGChoiceEditor::SetValueToUnspecified( wxPGProperty* WXUNUSED(property), wxWindow* ctrl ) const
+void wxPGChoiceEditor::SetValueToUnspecified( wxPGProperty* WXUNUSED(property),
+                                              wxWindow* ctrl ) const

 {
     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
 {
     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;

-    cb->SetSelection(-1);
+
+    if ( cb->HasFlag(wxCB_READONLY) )
+        cb->SetSelection(-1);

 }
 
 
 }
 
 


@@ -1202,7 +1221,10 @@ bool wxPGChoiceEditor::CanContainCustomImage() const
 }
 
 
 }
 
 

-wxPGChoiceEditor::~wxPGChoiceEditor() { }
+wxPGChoiceEditor::~wxPGChoiceEditor()
+{
+    wxPG_EDITOR(Choice) = NULL;
+}

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


@@ -1210,13 +1232,17 @@ wxPGChoiceEditor::~wxPGChoiceEditor() { }
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 
 

-WX_PG_IMPLEMENT_EDITOR_CLASS(ComboBox,wxPGComboBoxEditor,wxPGChoiceEditor)
+WX_PG_IMPLEMENT_INTERNAL_EDITOR_CLASS(ComboBox,
+                                      wxPGComboBoxEditor,
+                                      wxPGChoiceEditor)

 
 
 void wxPGComboBoxEditor::UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const
 {
     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
 
 
 void wxPGComboBoxEditor::UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const
 {
     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;

-    cb->SetValue(property->GetValueString(wxPG_EDITABLE_VALUE));
+    wxString s = property->GetValueAsString(wxPG_EDITABLE_VALUE);
+    property->GetGrid()->SetupTextCtrlValue(s);
+    cb->SetValue(s);

 
     // TODO: If string matches any selection, then select that.
 }
 
     // TODO: If string matches any selection, then select that.
 }


@@ -1236,8 +1262,8 @@ bool wxPGComboBoxEditor::OnEvent( wxPropertyGrid* propGrid,
                                   wxWindow* ctrl,
                                   wxEvent& event ) const
 {
                                   wxWindow* ctrl,
                                   wxEvent& event ) const
 {

-    wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*) NULL;
-    wxWindow* textCtrl = (wxWindow*) NULL;
+    wxOwnerDrawnComboBox* cb = NULL;
+    wxWindow* textCtrl = NULL;

 
     if ( ctrl )
     {
 
     if ( ctrl )
     {


@@ -1257,7 +1283,7 @@ bool wxPGComboBoxEditor::GetValueFromControl( wxVariant& variant, wxPGProperty*
     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
     wxString textVal = cb->GetValue();
 
     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
     wxString textVal = cb->GetValue();
 

-    if ( property->UsesAutoUnspecified() && !textVal.length() )
+    if ( property->UsesAutoUnspecified() && textVal.empty() )

     {
         variant.MakeNull();
         return true;
     {
         variant.MakeNull();
         return true;


@@ -1274,14 +1300,19 @@ bool wxPGComboBoxEditor::GetValueFromControl( wxVariant& variant, wxPGProperty*
 }
 
 
 }
 
 

-void wxPGComboBoxEditor::OnFocus( wxPGProperty*, wxWindow* ctrl ) const
+void wxPGComboBoxEditor::OnFocus( wxPGProperty* property,
+                                  wxWindow* ctrl ) const

 {
     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
 {
     wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;

-    cb->GetTextCtrl()->SetSelection(-1,-1);
+    wxPGTextCtrlEditor_OnFocus(property, cb->GetTextCtrl());

 }
 
 
 }
 
 

-wxPGComboBoxEditor::~wxPGComboBoxEditor() { }
+wxPGComboBoxEditor::~wxPGComboBoxEditor()
+{
+    wxPG_EDITOR(ComboBox) = NULL;
+}
+

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


@@ -1289,8 +1320,9 @@ wxPGComboBoxEditor::~wxPGComboBoxEditor() { }
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 
 

-// This simpler implement_editor macro doesn't define class body.
-WX_PG_IMPLEMENT_EDITOR_CLASS(ChoiceAndButton,wxPGChoiceAndButtonEditor,wxPGChoiceEditor)
+WX_PG_IMPLEMENT_INTERNAL_EDITOR_CLASS(ChoiceAndButton,
+                                      wxPGChoiceAndButtonEditor,
+                                      wxPGChoiceEditor)

 
 
 wxPGWindowList wxPGChoiceAndButtonEditor::CreateControls( wxPropertyGrid* propGrid,
 
 
 wxPGWindowList wxPGChoiceAndButtonEditor::CreateControls( wxPropertyGrid* propGrid,


@@ -1321,7 +1353,7 @@ wxPGWindowList wxPGChoiceAndButtonEditor::CreateControls( wxPropertyGrid* propGr
     ch_sz.x -= wxPG_TEXTCTRL_AND_BUTTON_SPACING;
 #endif
 
     ch_sz.x -= wxPG_TEXTCTRL_AND_BUTTON_SPACING;
 #endif
 

-    wxWindow* ch = wxPG_EDITOR(Choice)->CreateControls(propGrid,property,
+    wxWindow* ch = wxPGEditor_Choice->CreateControls(propGrid,property,

         pos,ch_sz).m_primary;
 
 #ifdef __WXMSW__
         pos,ch_sz).m_primary;
 
 #ifdef __WXMSW__


@@ -1332,16 +1364,18 @@ wxPGWindowList wxPGChoiceAndButtonEditor::CreateControls( wxPropertyGrid* propGr
 }
 
 
 }
 
 

-wxPGChoiceAndButtonEditor::~wxPGChoiceAndButtonEditor() { }
-
+wxPGChoiceAndButtonEditor::~wxPGChoiceAndButtonEditor()
+{
+    wxPG_EDITOR(ChoiceAndButton) = NULL;
+}

 
 // -----------------------------------------------------------------------
 // wxPGTextCtrlAndButtonEditor
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 // wxPGTextCtrlAndButtonEditor
 // -----------------------------------------------------------------------
 

-
-// This simpler implement_editor macro doesn't define class body.
-WX_PG_IMPLEMENT_EDITOR_CLASS(TextCtrlAndButton,wxPGTextCtrlAndButtonEditor,wxPGTextCtrlEditor)
+WX_PG_IMPLEMENT_INTERNAL_EDITOR_CLASS(TextCtrlAndButton,
+                                      wxPGTextCtrlAndButtonEditor,
+                                      wxPGTextCtrlEditor)

 
 
 wxPGWindowList wxPGTextCtrlAndButtonEditor::CreateControls( wxPropertyGrid* propGrid,
 
 
 wxPGWindowList wxPGTextCtrlAndButtonEditor::CreateControls( wxPropertyGrid* propGrid,


@@ -1357,8 +1391,10 @@ wxPGWindowList wxPGTextCtrlAndButtonEditor::CreateControls( wxPropertyGrid* prop
 }
 
 
 }
 
 

-wxPGTextCtrlAndButtonEditor::~wxPGTextCtrlAndButtonEditor() { }
-
+wxPGTextCtrlAndButtonEditor::~wxPGTextCtrlAndButtonEditor()
+{
+    wxPG_EDITOR(TextCtrlAndButton) = NULL;
+}

 
 // -----------------------------------------------------------------------
 // wxPGCheckBoxEditor
 
 // -----------------------------------------------------------------------
 // wxPGCheckBoxEditor


@@ -1366,20 +1402,39 @@ wxPGTextCtrlAndButtonEditor::~wxPGTextCtrlAndButtonEditor() { }
 
 #if wxPG_INCLUDE_CHECKBOX
 
 
 #if wxPG_INCLUDE_CHECKBOX
 

-WX_PG_IMPLEMENT_EDITOR_CLASS(CheckBox,wxPGCheckBoxEditor,wxPGEditor)
+WX_PG_IMPLEMENT_INTERNAL_EDITOR_CLASS(CheckBox,
+                                      wxPGCheckBoxEditor,
+                                      wxPGEditor)

 
 
 
 

-// state argument: 0x01 = set if checked
-//                 0x02 = set if rectangle should be bold
-static void DrawSimpleCheckBox( wxDC& dc, const wxRect& rect, int box_hei, int state, const wxColour& linecol )
+// Check box state flags
+enum

 {
 {

+    wxSCB_STATE_UNCHECKED   = 0,
+    wxSCB_STATE_CHECKED     = 1,
+    wxSCB_STATE_BOLD        = 2,
+    wxSCB_STATE_UNSPECIFIED = 4
+};

 
 

+const int wxSCB_SETVALUE_CYCLE = 2;
+
+
+static void DrawSimpleCheckBox( wxDC& dc, const wxRect& rect, int box_hei,
+                                int state )
+{

     // Box rectangle.
     // Box rectangle.

-    wxRect r(rect.x+wxPG_XBEFORETEXT,rect.y+((rect.height-box_hei)/2),box_hei,box_hei);
+    wxRect r(rect.x+wxPG_XBEFORETEXT,rect.y+((rect.height-box_hei)/2),
+             box_hei,box_hei);
+    wxColour useCol = dc.GetTextForeground();
+
+    if ( state & wxSCB_STATE_UNSPECIFIED )
+    {
+        useCol = wxColour(220, 220, 220);
+    }

 
     // Draw check mark first because it is likely to overdraw the
     // surrounding rectangle.
 
     // Draw check mark first because it is likely to overdraw the
     // surrounding rectangle.

-    if ( state & 1 )
+    if ( state & wxSCB_STATE_CHECKED )

     {
         wxRect r2(r.x+wxPG_CHECKMARK_XADJ,
                   r.y+wxPG_CHECKMARK_YADJ,
     {
         wxRect r2(r.x+wxPG_CHECKMARK_XADJ,
                   r.y+wxPG_CHECKMARK_YADJ,


@@ -1393,18 +1448,17 @@ static void DrawSimpleCheckBox( wxDC& dc, const wxRect& rect, int box_hei, int s
         // This would draw a simple cross check mark.
         // dc.DrawLine(r.x,r.y,r.x+r.width-1,r.y+r.height-1);
         // dc.DrawLine(r.x,r.y+r.height-1,r.x+r.width-1,r.y);
         // This would draw a simple cross check mark.
         // dc.DrawLine(r.x,r.y,r.x+r.width-1,r.y+r.height-1);
         // dc.DrawLine(r.x,r.y+r.height-1,r.x+r.width-1,r.y);

-

     }
 
     }
 

-    if ( !(state & 2) )
+    if ( !(state & wxSCB_STATE_BOLD) )

     {
         // Pen for thin rectangle.
     {
         // Pen for thin rectangle.

-        dc.SetPen(linecol);
+        dc.SetPen(useCol);

     }
     else
     {
         // Pen for bold rectangle.
     }
     else
     {
         // Pen for bold rectangle.

-        wxPen linepen(linecol,2,wxSOLID);
+        wxPen linepen(useCol,2,wxSOLID);

         linepen.SetJoin(wxJOIN_MITER); // This prevents round edges.
         dc.SetPen(linepen);
         r.x++;
         linepen.SetJoin(wxJOIN_MITER); // This prevents round edges.
         dc.SetPen(linepen);
         r.x++;


@@ -1432,198 +1486,155 @@ public:
                       wxWindowID id,
                       const wxPoint& pos = wxDefaultPosition,
                       const wxSize& size = wxDefaultSize )
                       wxWindowID id,
                       const wxPoint& pos = wxDefaultPosition,
                       const wxSize& size = wxDefaultSize )

-        : wxControl(parent,id,pos,size,wxNO_BORDER|wxWANTS_CHARS)
+        : wxControl(parent,id,pos,size,wxBORDER_NONE|wxWANTS_CHARS)

     {
         // Due to SetOwnFont stuff necessary for GTK+ 1.2, we need to have this
         SetFont( parent->GetFont() );
 
         m_state = 0;
     {
         // Due to SetOwnFont stuff necessary for GTK+ 1.2, we need to have this
         SetFont( parent->GetFont() );
 
         m_state = 0;

-        wxPropertyGrid* pg = (wxPropertyGrid*) parent->GetParent();
-        wxASSERT( pg->IsKindOf(CLASSINFO(wxPropertyGrid)) );
-        m_boxHeight = pg->GetFontHeight();
-        SetBackgroundStyle( wxBG_STYLE_COLOUR );
+        m_boxHeight = 12;
+
+        SetBackgroundStyle( wxBG_STYLE_CUSTOM );

     }
 
     virtual ~wxSimpleCheckBox();
 
     }
 
     virtual ~wxSimpleCheckBox();
 

-    virtual bool ProcessEvent(wxEvent& event);
-

     int m_state;
     int m_boxHeight;
 
     int m_state;
     int m_boxHeight;
 

+private:
+    void OnPaint( wxPaintEvent& event );
+    void OnLeftClick( wxMouseEvent& event );
+    void OnKeyDown( wxKeyEvent& event );
+
+    void OnResize( wxSizeEvent& event )
+    {
+        Refresh();
+        event.Skip();
+    }
+

     static wxBitmap* ms_doubleBuffer;
 
     static wxBitmap* ms_doubleBuffer;
 

+    DECLARE_EVENT_TABLE()

 };
 
 };
 

+BEGIN_EVENT_TABLE(wxSimpleCheckBox, wxControl)
+    EVT_PAINT(wxSimpleCheckBox::OnPaint)
+    EVT_LEFT_DOWN(wxSimpleCheckBox::OnLeftClick)
+    EVT_LEFT_DCLICK(wxSimpleCheckBox::OnLeftClick)
+    EVT_KEY_DOWN(wxSimpleCheckBox::OnKeyDown)
+    EVT_SIZE(wxSimpleCheckBox::OnResize)
+END_EVENT_TABLE()
+

 wxSimpleCheckBox::~wxSimpleCheckBox()
 {
 wxSimpleCheckBox::~wxSimpleCheckBox()
 {

-    delete ms_doubleBuffer;
-    ms_doubleBuffer = NULL;
+    wxDELETE(ms_doubleBuffer);

 }
 
 }
 

+wxBitmap* wxSimpleCheckBox::ms_doubleBuffer = NULL;

 
 

-wxBitmap* wxSimpleCheckBox::ms_doubleBuffer = (wxBitmap*) NULL;
+void wxSimpleCheckBox::OnPaint( wxPaintEvent& WXUNUSED(event) )
+{
+    wxSize clientSize = GetClientSize();
+    wxAutoBufferedPaintDC dc(this);

 
 

-// value = 2 means toggle (sorry, too lazy to do constants)
-void wxSimpleCheckBox::SetValue( int value )
+    dc.Clear();
+    wxRect rect(0,0,clientSize.x,clientSize.y);
+    rect.y += 1;
+    rect.width += 1;
+
+    wxColour bgcol = GetBackgroundColour();
+    dc.SetBrush( bgcol );
+    dc.SetPen( bgcol );
+    dc.DrawRectangle( rect );
+
+    dc.SetTextForeground(GetForegroundColour());
+
+    int state = m_state;
+    if ( !(state & wxSCB_STATE_UNSPECIFIED) &&
+         GetFont().GetWeight() == wxBOLD )
+        state |= wxSCB_STATE_BOLD;
+
+    DrawSimpleCheckBox(dc, rect, m_boxHeight, state);
+}
+
+void wxSimpleCheckBox::OnLeftClick( wxMouseEvent& event )

 {
 {

-    if ( value > 1 )
+    if ( (event.m_x > (wxPG_XBEFORETEXT-2)) &&
+         (event.m_x <= (wxPG_XBEFORETEXT-2+m_boxHeight)) )

     {
     {

-        m_state++;
-        if ( m_state > 1 ) m_state = 0;
+        SetValue(wxSCB_SETVALUE_CYCLE);

     }
     }

-    else
+}
+
+void wxSimpleCheckBox::OnKeyDown( wxKeyEvent& event )
+{
+    if ( event.GetKeyCode() == WXK_SPACE )

     {
     {

-        m_state = value;
+        SetValue(wxSCB_SETVALUE_CYCLE);

     }
     }

-    Refresh();
-
-    wxCommandEvent evt(wxEVT_COMMAND_CHECKBOX_CLICKED,GetParent()->GetId());
-
-    wxPropertyGrid* propGrid = (wxPropertyGrid*) GetParent()->GetParent();
-    wxASSERT( propGrid->IsKindOf(CLASSINFO(wxPropertyGrid)) );
-    propGrid->OnCustomEditorEvent(evt);

 }
 
 }
 

-
-bool wxSimpleCheckBox::ProcessEvent(wxEvent& event)
+void wxSimpleCheckBox::SetValue( int value )

 {
 {

-    wxPropertyGrid* propGrid = (wxPropertyGrid*) GetParent()->GetParent();
-    wxASSERT( propGrid->IsKindOf(CLASSINFO(wxPropertyGrid)) );
-
-    if ( event.GetEventType() == wxEVT_NAVIGATION_KEY )
+    if ( value == wxSCB_SETVALUE_CYCLE )

     {
     {

-        //wxLogDebug(wxT("wxEVT_NAVIGATION_KEY"));
-        //SetFocusFromKbd();
-        //event.Skip();
-        //return wxControl::ProcessEvent(event);
+        if ( m_state & wxSCB_STATE_CHECKED )
+            m_state &= ~wxSCB_STATE_CHECKED;
+        else
+            m_state |= wxSCB_STATE_CHECKED;

     }
     else
     }
     else

-    if ( ( (event.GetEventType() == wxEVT_LEFT_DOWN || event.GetEventType() == wxEVT_LEFT_DCLICK)
-          && ((wxMouseEvent&)event).m_x > (wxPG_XBEFORETEXT-2)
-          && ((wxMouseEvent&)event).m_x <= (wxPG_XBEFORETEXT-2+m_boxHeight) )
-       )

     {
     {

-        SetValue(2);
-        return true;
+        m_state = value;

     }
     }

-    else if ( event.GetEventType() == wxEVT_PAINT )
-    {
-        wxSize clientSize = GetClientSize();
-        wxPaintDC dc(this);
-
-        /*
-        // Buffered paint DC doesn't seem to do much good
-        if ( !ms_doubleBuffer ||
-             clientSize.x > ms_doubleBuffer->GetWidth() ||
-             clientSize.y > ms_doubleBuffer->GetHeight() )
-        {
-            delete ms_doubleBuffer;
-            ms_doubleBuffer = new wxBitmap(clientSize.x+25,clientSize.y+25);
-        }
-
-        wxBufferedPaintDC dc(this,*ms_doubleBuffer);
-        */
-
-        wxRect rect(0,0,clientSize.x,clientSize.y);
-        //rect.x -= 1;
-        rect.y += 1;
-        rect.width += 1;
-
-        m_boxHeight = propGrid->GetFontHeight();
-
-        wxColour bgcol = GetBackgroundColour();
-        dc.SetBrush( bgcol );
-        dc.SetPen( bgcol );
-        dc.DrawRectangle( rect );
-
-        wxColour txcol = GetForegroundColour();
-
-        int state = m_state;
-        if ( m_font.GetWeight() == wxBOLD )
-            state |= 2;
-
-        DrawSimpleCheckBox(dc,rect,m_boxHeight,state,txcol);
-
-        // If focused, indicate it somehow.
-        /*
-        if ( wxWindow::FindFocus() == this )
-        {
-            rect.x += 1;
-            rect.width -= 1;
-
-            wxPGDrawFocusRect(dc,rect);
-        }
-        */
+    Refresh();

 
 

-        return true;
-    }
-    else if ( event.GetEventType() == wxEVT_SIZE ||
-              event.GetEventType() == wxEVT_SET_FOCUS ||
-              event.GetEventType() == wxEVT_KILL_FOCUS
-            )
-    {
-        Refresh();
-    }
-    else if ( event.GetEventType() == wxEVT_KEY_DOWN )
-    {
-        wxKeyEvent& keyEv = (wxKeyEvent&) event;
+    wxCommandEvent evt(wxEVT_COMMAND_CHECKBOX_CLICKED,GetParent()->GetId());

 
 

-        if ( keyEv.GetKeyCode() == WXK_TAB )
-        {
-            propGrid->SendNavigationKeyEvent( keyEv.ShiftDown()?0:1 );
-            return true;
-        }
-        else
-        if ( keyEv.GetKeyCode() == WXK_SPACE )
-        {
-            SetValue(2);
-            return true;
-        }
-    }
-    return wxControl::ProcessEvent(event);
+    wxPropertyGrid* propGrid = (wxPropertyGrid*) GetParent();
+    wxASSERT( propGrid->IsKindOf(CLASSINFO(wxPropertyGrid)) );
+    propGrid->HandleCustomEditorEvent(evt);

 }
 
 }
 

-

 wxPGWindowList wxPGCheckBoxEditor::CreateControls( wxPropertyGrid* propGrid,
                                                    wxPGProperty* property,
                                                    const wxPoint& pos,
                                                    const wxSize& size ) const
 {
 wxPGWindowList wxPGCheckBoxEditor::CreateControls( wxPropertyGrid* propGrid,
                                                    wxPGProperty* property,
                                                    const wxPoint& pos,
                                                    const wxSize& size ) const
 {

+    if ( property->HasFlag(wxPG_PROP_READONLY) )
+        return NULL;
+

     wxPoint pt = pos;
     pt.x -= wxPG_XBEFOREWIDGET;
     wxSize sz = size;
     sz.x = propGrid->GetFontHeight() + (wxPG_XBEFOREWIDGET*2) + 4;
 
     wxPoint pt = pos;
     pt.x -= wxPG_XBEFOREWIDGET;
     wxSize sz = size;
     sz.x = propGrid->GetFontHeight() + (wxPG_XBEFOREWIDGET*2) + 4;
 

-    wxSimpleCheckBox* cb = new wxSimpleCheckBox(propGrid->GetPanel(),wxPG_SUBID1,pt,sz);
+    wxSimpleCheckBox* cb = new wxSimpleCheckBox(propGrid->GetPanel(),
+                                                wxPG_SUBID1, pt, sz);

 
     cb->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
 
 
     cb->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
 

-    cb->Connect( wxPG_SUBID1, wxEVT_LEFT_DOWN,
-            (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction)
-            &wxPropertyGrid::OnCustomEditorEvent, NULL, propGrid );
-
-    cb->Connect( wxPG_SUBID1, wxEVT_LEFT_DCLICK,
-            (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction)
-            &wxPropertyGrid::OnCustomEditorEvent, NULL, propGrid );
+    UpdateControl(property, cb);

 
 

-    if ( property->GetChoiceSelection() > 0 &&
-         !property->IsValueUnspecified() )
-        cb->m_state = 1;
-
-    // If mouse cursor was on the item, toggle the value now.
-    if ( propGrid->GetInternalFlags() & wxPG_FL_ACTIVATION_BY_CLICK )
+    if ( !property->IsValueUnspecified() )

     {
     {

-        wxPoint pt = cb->ScreenToClient(::wxGetMousePosition());
-        if ( pt.x <= (wxPG_XBEFORETEXT-2+cb->m_boxHeight) )
+        // If mouse cursor was on the item, toggle the value now.
+        if ( propGrid->GetInternalFlags() & wxPG_FL_ACTIVATION_BY_CLICK )

         {
         {

-            cb->m_state++;
-
-            if ( cb->m_state > 1 )
-                cb->m_state = 0;
-
-            // Makes sure wxPG_EVT_CHANGING etc. is sent for this initial click 
-            propGrid->ChangePropertyValue(property, wxPGVariant_Bool(cb->m_state));
+            wxPoint pt = cb->ScreenToClient(::wxGetMousePosition());
+            if ( pt.x <= (wxPG_XBEFORETEXT-2+cb->m_boxHeight) )
+            {
+                if ( cb->m_state & wxSCB_STATE_CHECKED )
+                    cb->m_state &= ~wxSCB_STATE_CHECKED;
+                else
+                    cb->m_state |= wxSCB_STATE_CHECKED;
+
+                // Makes sure wxPG_EVT_CHANGING etc. is sent for this initial
+                // click
+                propGrid->ChangePropertyValue(property,
+                                              wxPGVariant_Bool(cb->m_state));
+            }

         }
     }
 
         }
     }
 


@@ -1632,53 +1643,42 @@ wxPGWindowList wxPGCheckBoxEditor::CreateControls( wxPropertyGrid* propGrid,
     return cb;
 }
 
     return cb;
 }
 

-/*
-class wxPGCheckBoxRenderer : public wxPGDefaultRenderer
+void wxPGCheckBoxEditor::DrawValue( wxDC& dc, const wxRect& rect,
+                                    wxPGProperty* property,
+                                    const wxString& WXUNUSED(text) ) const

 {
 {

-public:
+    int state = wxSCB_STATE_UNCHECKED;

 
 

-    virtual void Render( wxDC& dc, const wxRect& rect,
-                         const wxPropertyGrid* WXUNUSED(propertyGrid), wxPGProperty* property,
-                         int WXUNUSED(column), int WXUNUSED(item), int WXUNUSED(flags) ) const
+    if ( !property->IsValueUnspecified() )

     {
     {

-        int state = 0;
-        if ( !(property->GetFlags() & wxPG_PROP_UNSPECIFIED) )
-        {
-            state = ((wxPGProperty*)property)->GetChoiceInfo((wxPGChoiceInfo*)NULL);
-            if ( dc.GetFont().GetWeight() == wxBOLD ) state |= 2;
-        }
-        DrawSimpleCheckBox(dc,rect,dc.GetCharHeight(),state,dc.GetTextForeground());
+        state = property->GetChoiceSelection();
+        if ( dc.GetFont().GetWeight() == wxBOLD )
+            state |= wxSCB_STATE_BOLD;
+    }
+    else
+    {
+        state |= wxSCB_STATE_UNSPECIFIED;

     }
 
     }
 

-protected:
-};
-
-wxPGCheckBoxRenderer g_wxPGCheckBoxRenderer;
-
-wxPGCellRenderer* wxPGCheckBoxEditor::GetCellRenderer() const
-{
-    return &g_wxPGCheckBoxRenderer;
+    DrawSimpleCheckBox(dc, rect, dc.GetCharHeight(), state);

 }
 }

-*/

 
 

-void wxPGCheckBoxEditor::DrawValue( wxDC& dc, const wxRect& rect, wxPGProperty* property, const wxString& WXUNUSED(text) ) const
+void wxPGCheckBoxEditor::UpdateControl( wxPGProperty* property,
+                                        wxWindow* ctrl ) const

 {
 {

-    int state = 0;
+    wxSimpleCheckBox* cb = (wxSimpleCheckBox*) ctrl;
+    wxASSERT( cb );
+

     if ( !property->IsValueUnspecified() )
     if ( !property->IsValueUnspecified() )

-    {
-        state = property->GetChoiceSelection();
-        if ( dc.GetFont().GetWeight() == wxBOLD ) state |= 2;
-    }
-    DrawSimpleCheckBox(dc,rect,dc.GetCharHeight(),state,dc.GetTextForeground());
-}
+        cb->m_state = property->GetChoiceSelection();
+    else
+        cb->m_state = wxSCB_STATE_UNSPECIFIED;

 
 

-void wxPGCheckBoxEditor::UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const
-{
-    wxASSERT( ctrl );
-    ((wxSimpleCheckBox*)ctrl)->m_state = property->GetChoiceSelection();
-    ctrl->Refresh();
-}
+    wxPropertyGrid* propGrid = property->GetGrid();
+    cb->m_boxHeight = propGrid->GetFontHeight();

 
 

+    cb->Refresh();
+}

 
 bool wxPGCheckBoxEditor::OnEvent( wxPropertyGrid* WXUNUSED(propGrid), wxPGProperty* WXUNUSED(property),
     wxWindow* WXUNUSED(ctrl), wxEvent& event ) const
 
 bool wxPGCheckBoxEditor::OnEvent( wxPropertyGrid* WXUNUSED(propGrid), wxPGProperty* WXUNUSED(property),
     wxWindow* WXUNUSED(ctrl), wxEvent& event ) const


@@ -1719,13 +1719,15 @@ void wxPGCheckBoxEditor::SetControlIntValue( wxPGProperty* WXUNUSED(property), w
 
 void wxPGCheckBoxEditor::SetValueToUnspecified( wxPGProperty* WXUNUSED(property), wxWindow* ctrl ) const
 {
 
 void wxPGCheckBoxEditor::SetValueToUnspecified( wxPGProperty* WXUNUSED(property), wxWindow* ctrl ) const
 {

-    ((wxSimpleCheckBox*)ctrl)->m_state = 0;
+    ((wxSimpleCheckBox*)ctrl)->m_state = wxSCB_STATE_UNSPECIFIED;

     ctrl->Refresh();
 }
 
 
     ctrl->Refresh();
 }
 
 

-wxPGCheckBoxEditor::~wxPGCheckBoxEditor() { }
-
+wxPGCheckBoxEditor::~wxPGCheckBoxEditor()
+{
+    wxPG_EDITOR(CheckBox) = NULL;
+}

 
 #endif // wxPG_INCLUDE_CHECKBOX
 
 
 #endif // wxPG_INCLUDE_CHECKBOX
 


@@ -1738,14 +1740,6 @@ wxWindow* wxPropertyGrid::GetEditorControl() const
     if ( !ctrl )
         return ctrl;
 
     if ( !ctrl )
         return ctrl;
 

-    // If it's clipper window, return its child instead
-#if wxPG_ENABLE_CLIPPER_WINDOW
-    if ( ctrl->IsKindOf(CLASSINFO(wxPGClipperWindow)) )
-    {
-        return ((wxPGClipperWindow*)ctrl)->GetControl();
-    }
-#endif
-

     return ctrl;
 }
 
     return ctrl;
 }
 


@@ -1753,12 +1747,11 @@ wxWindow* wxPropertyGrid::GetEditorControl() const
 
 void wxPropertyGrid::CorrectEditorWidgetSizeX()
 {
 
 void wxPropertyGrid::CorrectEditorWidgetSizeX()
 {

-    if ( m_selColumn == -1 )
-        return;
-

     int secWid = 0;
     int secWid = 0;

-    int newSplitterx = m_pState->DoGetSplitterPosition(m_selColumn-1);
-    int newWidth = newSplitterx + m_pState->m_colWidths[m_selColumn];
+
+    // Use fixed selColumn 1 for main editor widgets
+    int newSplitterx = m_pState->DoGetSplitterPosition(0);
+    int newWidth = newSplitterx + m_pState->m_colWidths[1];

 
     if ( m_wndEditor2 )
     {
 
     if ( m_wndEditor2 )
     {


@@ -1798,57 +1791,52 @@ void wxPropertyGrid::CorrectEditorWidgetSizeX()
 
 void wxPropertyGrid::CorrectEditorWidgetPosY()
 {
 
 void wxPropertyGrid::CorrectEditorWidgetPosY()
 {

-    if ( m_selected && (m_wndEditor || m_wndEditor2) ) 
-    {
-        wxRect r = GetEditorWidgetRect(m_selected, m_selColumn);
+    wxPGProperty* selected = GetSelection();

 
 

-        if ( m_wndEditor )
+    if ( selected )
+    {
+        if ( m_labelEditor )

         {
         {

-            wxPoint pos = m_wndEditor->GetPosition();
+            wxRect r = GetEditorWidgetRect(selected, m_selColumn);
+            wxPoint pos = m_labelEditor->GetPosition();

 
             // Calculate y offset
             int offset = pos.y % m_lineHeight;
 
 
             // Calculate y offset
             int offset = pos.y % m_lineHeight;
 

-            m_wndEditor->Move(pos.x, r.y + offset);
+            m_labelEditor->Move(pos.x, r.y + offset);

         }
 
         }
 

-        if ( m_wndEditor2 )
+        if ( m_wndEditor || m_wndEditor2 )

         {
         {

-            wxPoint pos = m_wndEditor2->GetPosition();
+            wxRect r = GetEditorWidgetRect(selected, 1);

 
 

-            m_wndEditor2->Move(pos.x, r.y);
-        }
-    }
-}
+            if ( m_wndEditor )
+            {
+                wxPoint pos = m_wndEditor->GetPosition();

 
 

-// -----------------------------------------------------------------------
+                // Calculate y offset
+                int offset = pos.y % m_lineHeight;

 
 

-bool wxPropertyGrid::AdjustPosForClipperWindow( wxWindow* topCtrlWnd, int* x, int* y )
-{
-#if wxPG_ENABLE_CLIPPER_WINDOW
-    // Take clipper window into account
-    if (topCtrlWnd->GetPosition().x < 1 &&
-        !topCtrlWnd->IsKindOf(CLASSINFO(wxPGClipperWindow)))
-    {
-        topCtrlWnd = topCtrlWnd->GetParent();
-        wxASSERT( topCtrlWnd->IsKindOf(CLASSINFO(wxPGClipperWindow)) );
-        *x -= ((wxPGClipperWindow*)topCtrlWnd)->GetXClip();
-        *y -= ((wxPGClipperWindow*)topCtrlWnd)->GetYClip();
-        return true;
+                m_wndEditor->Move(pos.x, r.y + offset);
+            }
+
+            if ( m_wndEditor2 )
+            {
+                wxPoint pos = m_wndEditor2->GetPosition();
+
+                m_wndEditor2->Move(pos.x, r.y);
+            }
+        }

     }
     }

-#else
-    wxUnusedVar(topCtrlWnd);
-    wxUnusedVar(x);
-    wxUnusedVar(y);
-#endif
-    return false;

 }
 
 // -----------------------------------------------------------------------
 
 // Fixes position of wxTextCtrl-like control (wxSpinCtrl usually
 // fits into that category as well).
 }
 
 // -----------------------------------------------------------------------
 
 // Fixes position of wxTextCtrl-like control (wxSpinCtrl usually
 // fits into that category as well).

-void wxPropertyGrid::FixPosForTextCtrl( wxWindow* ctrl, const wxPoint& offset )
+void wxPropertyGrid::FixPosForTextCtrl( wxWindow* ctrl,
+                                        unsigned int WXUNUSED(forColumn),
+                                        const wxPoint& offset )

 {
     // Center the control vertically
     wxRect finalPos = ctrl->GetRect();
 {
     // Center the control vertically
     wxRect finalPos = ctrl->GetRect();


@@ -1861,7 +1849,14 @@ void wxPropertyGrid::FixPosForTextCtrl( wxWindow* ctrl, const wxPoint& offset )
     finalPos.y += y_adj;
     finalPos.height -= (y_adj+sz_dec);
 
     finalPos.y += y_adj;
     finalPos.height -= (y_adj+sz_dec);
 

-    const int textCtrlXAdjust = wxPG_TEXTCTRLXADJUST;
+#ifndef wxPG_TEXTCTRLXADJUST
+    int textCtrlXAdjust = wxPG_XBEFORETEXT - 1;
+
+    wxTextCtrl* tc = static_cast<wxTextCtrl*>(ctrl);
+    tc->SetMargins(0);
+#else
+    int textCtrlXAdjust = wxPG_TEXTCTRLXADJUST;
+#endif

 
     finalPos.x += textCtrlXAdjust;
     finalPos.width -= textCtrlXAdjust;
 
     finalPos.x += textCtrlXAdjust;
     finalPos.width -= textCtrlXAdjust;


@@ -1879,15 +1874,16 @@ wxWindow* wxPropertyGrid::GenerateEditorTextCtrl( const wxPoint& pos,
                                                   const wxString& value,
                                                   wxWindow* secondary,
                                                   int extraStyle,
                                                   const wxString& value,
                                                   wxWindow* secondary,
                                                   int extraStyle,

-                                                  int maxLen )
+                                                  int maxLen,
+                                                  unsigned int forColumn )

 {
     wxWindowID id = wxPG_SUBID1;
 {
     wxWindowID id = wxPG_SUBID1;

-    wxPGProperty* selected = m_selected;
-    wxASSERT(selected);
+    wxPGProperty* prop = GetSelection();
+    wxASSERT(prop);

 
     int tcFlags = wxTE_PROCESS_ENTER | extraStyle;
 
 
     int tcFlags = wxTE_PROCESS_ENTER | extraStyle;
 

-    if ( selected->HasFlag(wxPG_PROP_READONLY) )
+    if ( prop->HasFlag(wxPG_PROP_READONLY) && forColumn == 1 )

         tcFlags |= wxTE_READONLY;
 
     wxPoint p(pos.x,pos.y);
         tcFlags |= wxTE_READONLY;
 
     wxPoint p(pos.x,pos.y);


@@ -1895,10 +1891,14 @@ wxWindow* wxPropertyGrid::GenerateEditorTextCtrl( const wxPoint& pos,
 
    // Need to reduce width of text control on Mac
 #if defined(__WXMAC__)
 
    // Need to reduce width of text control on Mac
 #if defined(__WXMAC__)

-   s.x -= 8;
+    s.x -= 8;

 #endif
 
 #endif
 

-     // Take button into acccount
+    // For label editors, trim the size to allow better splitter grabbing
+    if ( forColumn != 1 )
+        s.x -= 2;
+
+    // Take button into acccount

     if ( secondary )
     {
         s.x -= (secondary->GetSize().x + wxPG_TEXTCTRL_AND_BUTTON_SPACING);
     if ( secondary )
     {
         s.x -= (secondary->GetSize().x + wxPG_TEXTCTRL_AND_BUTTON_SPACING);


@@ -1911,53 +1911,50 @@ wxWindow* wxPropertyGrid::GenerateEditorTextCtrl( const wxPoint& pos,
     if ( (sz.y - m_lineHeight) > 5 )
         hasSpecialSize = true;
 
     if ( (sz.y - m_lineHeight) > 5 )
         hasSpecialSize = true;
 

-#if wxPG_NAT_TEXTCTRL_BORDER_ANY
-
-    // Create clipper window
-    wxPGClipperWindow* wnd = new wxPGClipperWindow();
-#if defined(__WXMSW__)
-    wnd->Hide();
-#endif
-    wnd->Create(GetPanel(),id,p,s);
-
-    // This generates rect of the control inside the clipper window
-    if ( !hasSpecialSize )
-        wnd->GetControlRect(wxPG_NAT_TEXTCTRL_BORDER_X, wxPG_NAT_TEXTCTRL_BORDER_Y, p, s);
-    else
-        wnd->GetControlRect(0, 0, p, s);
-
-    wxWindow* ctrlParent = wnd;
-
-#else
-

     wxWindow* ctrlParent = GetPanel();
 
     if ( !hasSpecialSize )
     wxWindow* ctrlParent = GetPanel();
 
     if ( !hasSpecialSize )

-        tcFlags |= wxNO_BORDER;
-
-#endif
+        tcFlags |= wxBORDER_NONE;

 
     wxTextCtrl* tc = new wxTextCtrl();
 
 
     wxTextCtrl* tc = new wxTextCtrl();
 

-#if defined(__WXMSW__) && !wxPG_NAT_TEXTCTRL_BORDER_ANY
+#if defined(__WXMSW__)

     tc->Hide();
 #endif
     SetupTextCtrlValue(value);
     tc->Create(ctrlParent,id,value, p, s,tcFlags);
 
     tc->Hide();
 #endif
     SetupTextCtrlValue(value);
     tc->Create(ctrlParent,id,value, p, s,tcFlags);
 

-#if wxPG_NAT_TEXTCTRL_BORDER_ANY
-    wxWindow* ed = wnd;
-    wnd->SetControl(tc);
-#else
-    wxWindow* ed = tc;
+#if defined(__WXMSW__)
+    // On Windows, we need to override read-only text ctrl's background
+    // colour to white. One problem with native 'grey' background is that
+    // tc->GetBackgroundColour() doesn't seem to return correct value
+    // for it.
+    if ( tcFlags & wxTE_READONLY )
+    {
+        wxVisualAttributes vattrs = tc->GetDefaultAttributes();
+        tc->SetBackgroundColour(vattrs.colBg);
+    }

 #endif
 
 #endif
 

+    // This code is repeated from DoSelectProperty(). However, font boldness
+    // must be set before margin is set up below in FixPosForTextCtrl().
+    if ( forColumn == 1 &&
+         prop->HasFlag(wxPG_PROP_MODIFIED) &&
+         HasFlag(wxPG_BOLD_MODIFIED) )
+         tc->SetFont( m_captionFont );
+

     // Center the control vertically
     if ( !hasSpecialSize )
     // Center the control vertically
     if ( !hasSpecialSize )

-        FixPosForTextCtrl(ed);
+        FixPosForTextCtrl(tc, forColumn);
+
+    if ( forColumn != 1 )
+    {
+        tc->SetBackgroundColour(m_colSelBack);
+        tc->SetForegroundColour(m_colSelFore);
+    }

 
 #ifdef __WXMSW__
 
 #ifdef __WXMSW__

-    ed->Show();
+    tc->Show();

     if ( secondary )
         secondary->Show();
 #endif
     if ( secondary )
         secondary->Show();
 #endif


@@ -1966,14 +1963,17 @@ wxWindow* wxPropertyGrid::GenerateEditorTextCtrl( const wxPoint& pos,
     if ( maxLen > 0 )
         tc->SetMaxLength( maxLen );
 
     if ( maxLen > 0 )
         tc->SetMaxLength( maxLen );
 

-    // Connect event handling
-    id = ed->GetId();
-    this->Connect(id, wxEVT_COMMAND_TEXT_UPDATED,
-        wxCommandEventHandler(wxPropertyGrid::OnCustomEditorEvent));
-    this->Connect(id, wxEVT_COMMAND_TEXT_ENTER,
-        wxCommandEventHandler(wxPropertyGrid::OnCustomEditorEvent));
+    wxVariant attrVal = prop->GetAttribute(wxPG_ATTR_AUTOCOMPLETE);
+    if ( !attrVal.IsNull() )
+    {
+        wxASSERT(attrVal.GetType() == wxS("arrstring"));
+        tc->AutoComplete(attrVal.GetArrayString());
+    }
+
+    // Set hint text
+    tc->SetHint(prop->GetHintText());

 
 

-    return (wxWindow*) ed;
+    return tc;

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


@@ -1981,7 +1981,7 @@ wxWindow* wxPropertyGrid::GenerateEditorTextCtrl( const wxPoint& pos,
 wxWindow* wxPropertyGrid::GenerateEditorButton( const wxPoint& pos, const wxSize& sz )
 {
     wxWindowID id = wxPG_SUBID2;
 wxWindow* wxPropertyGrid::GenerateEditorButton( const wxPoint& pos, const wxSize& sz )
 {
     wxWindowID id = wxPG_SUBID2;

-    wxPGProperty* selected = m_selected;
+    wxPGProperty* selected = GetSelection();

     wxASSERT(selected);
 
 #ifdef __WXMAC__
     wxASSERT(selected);
 
 #ifdef __WXMAC__


@@ -1999,7 +1999,7 @@ wxWindow* wxPropertyGrid::GenerateEditorButton( const wxPoint& pos, const wxSize
    p.x = pos.x + sz.x - but->GetSize().x - 2;
    but->Move(p);
 
    p.x = pos.x + sz.x - but->GetSize().x - 2;
    but->Move(p);
 

-#else 
+#else

     wxSize s(sz.y-(wxPG_BUTTON_SIZEDEC*2)+(wxPG_NAT_BUTTON_BORDER_Y*2),
         sz.y-(wxPG_BUTTON_SIZEDEC*2)+(wxPG_NAT_BUTTON_BORDER_Y*2));
 
     wxSize s(sz.y-(wxPG_BUTTON_SIZEDEC*2)+(wxPG_NAT_BUTTON_BORDER_Y*2),
         sz.y-(wxPG_BUTTON_SIZEDEC*2)+(wxPG_NAT_BUTTON_BORDER_Y*2));
 


@@ -2034,11 +2034,6 @@ wxWindow* wxPropertyGrid::GenerateEditorButton( const wxPoint& pos, const wxSize
     if ( selected->HasFlag(wxPG_PROP_READONLY) )
         but->Disable();
 
     if ( selected->HasFlag(wxPG_PROP_READONLY) )
         but->Disable();
 

-    // Connect event handling
-    id = but->GetId();
-    this->Connect(id, wxEVT_COMMAND_BUTTON_CLICKED,
-        wxCommandEventHandler(wxPropertyGrid::OnCustomEditorEvent));
-

     return but;
 }
 
     return but;
 }
 


@@ -2059,19 +2054,41 @@ wxWindow* wxPropertyGrid::GenerateEditorTextCtrlAndButton( const wxPoint& pos,
         // There is button Show in GenerateEditorTextCtrl as well
         but->Show();
     #endif
         // There is button Show in GenerateEditorTextCtrl as well
         but->Show();
     #endif

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

     }
 
     wxString text;
 
     if ( !property->IsValueUnspecified() )
     }
 
     wxString text;
 
     if ( !property->IsValueUnspecified() )

-        text = property->GetValueString(property->HasFlag(wxPG_PROP_READONLY)?0:wxPG_EDITABLE_VALUE);
+        text = property->GetValueAsString(property->HasFlag(wxPG_PROP_READONLY)?0:wxPG_EDITABLE_VALUE);

 
     return GenerateEditorTextCtrl(pos,sz,text,but,property->m_maxLen);
 }
 
 // -----------------------------------------------------------------------
 
 
     return GenerateEditorTextCtrl(pos,sz,text,but,property->m_maxLen);
 }
 
 // -----------------------------------------------------------------------
 

+void wxPropertyGrid::SetEditorAppearance( const wxPGCell& cell,
+                                          bool unspecified )
+{
+    wxPGProperty* property = GetSelection();
+    if ( !property )
+        return;
+    wxWindow* ctrl = GetEditorControl();
+    if ( !ctrl )
+        return;
+
+    property->GetEditorClass()->SetControlAppearance( this,
+                                                      property,
+                                                      ctrl,
+                                                      cell,
+                                                      m_editorAppearance,
+                                                      unspecified );
+
+    m_editorAppearance = cell;
+}
+
+// -----------------------------------------------------------------------
+

 wxTextCtrl* wxPropertyGrid::GetEditorTextCtrl() const
 {
     wxWindow* wnd = GetEditorControl();
 wxTextCtrl* wxPropertyGrid::GetEditorTextCtrl() const
 {
     wxWindow* wnd = GetEditorControl();


@@ -2136,49 +2153,48 @@ wxPGMultiButton::wxPGMultiButton( wxPropertyGrid* pg, const wxSize& sz )
     SetBackgroundColour(pg->GetCellBackgroundColour());
 }
 
     SetBackgroundColour(pg->GetCellBackgroundColour());
 }
 

-void wxPGMultiButton::Finalize( wxPropertyGrid* propGrid, const wxPoint& pos )
+void wxPGMultiButton::Finalize( wxPropertyGrid* WXUNUSED(propGrid),
+                                const wxPoint& pos )

 {
     Move( pos.x + m_fullEditorSize.x - m_buttonsWidth, pos.y );
 {
     Move( pos.x + m_fullEditorSize.x - m_buttonsWidth, pos.y );

-
-    // Connect event handling
-    for ( int i=0; i<GetCount(); i++ )
-    {
-        wxWindowID id = GetButtonId(i);
-        propGrid->Connect(id, wxEVT_COMMAND_BUTTON_CLICKED,
-            wxCommandEventHandler(wxPropertyGrid::OnCustomEditorEvent));
-    }

 }
 
 }
 

-int wxPGMultiButton::GenId( int id ) const
+int wxPGMultiButton::GenId( int itemid ) const

 {
 {

-    if ( id < -1 )
+    if ( itemid < -1 )

     {
         if ( m_buttons.size() )
     {
         if ( m_buttons.size() )

-            id = GetButton(m_buttons.size()-1)->GetId() + 1;
+            itemid = GetButton(m_buttons.size()-1)->GetId() + 1;

         else
         else

-            id = wxPG_SUBID2;
+            itemid = wxPG_SUBID2;

     }
     }

-    return id;
+    return itemid;

 }
 
 #if wxUSE_BMPBUTTON
 }
 
 #if wxUSE_BMPBUTTON

-void wxPGMultiButton::Add( const wxBitmap& bitmap, int id )
+void wxPGMultiButton::Add( const wxBitmap& bitmap, int itemid )

 {
 {

-    id = GenId(id);
+    itemid = GenId(itemid);

     wxSize sz = GetSize();
     wxSize sz = GetSize();

-    wxButton* button = new wxBitmapButton( this, id, bitmap, wxPoint(sz.x, 0), wxSize(sz.y, sz.y) );
-    m_buttons.push_back(button);
-    int bw = button->GetSize().x;
-    SetSize(wxSize(sz.x+bw,sz.y));
-    m_buttonsWidth += bw;
+    wxButton* button = new wxBitmapButton( this, itemid, bitmap,
+                                           wxPoint(sz.x, 0),
+                                           wxSize(sz.y, sz.y) );
+    DoAddButton( button, sz );

 }
 #endif
 
 }
 #endif
 

-void wxPGMultiButton::Add( const wxString& label, int id )
+void wxPGMultiButton::Add( const wxString& label, int itemid )

 {
 {

-    id = GenId(id);
+    itemid = GenId(itemid);

     wxSize sz = GetSize();
     wxSize sz = GetSize();

-    wxButton* button = new wxButton( this, id, label, wxPoint(sz.x, 0), wxSize(sz.y, sz.y) );
+    wxButton* button = new wxButton( this, itemid, label, wxPoint(sz.x, 0),
+                                     wxSize(sz.y, sz.y) );
+    DoAddButton( button, sz );
+}
+
+void wxPGMultiButton::DoAddButton( wxWindow* button,
+                                   const wxSize& sz )
+{

     m_buttons.push_back(button);
     int bw = button->GetSize().x;
     SetSize(wxSize(sz.x+bw,sz.y));
     m_buttons.push_back(button);
     int bw = button->GetSize().x;
     SetSize(wxSize(sz.x+bw,sz.y));