X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/1c4293cb91327247ad69e6ec8d589bfaa299db28..27c1f235ba00917cc3599ad8e40cdb95afef2c9e:/src/propgrid/advprops.cpp

diff --git a/src/propgrid/advprops.cpp b/src/propgrid/advprops.cpp
index 45ea5fda77..963abd0933 100644
--- a/src/propgrid/advprops.cpp
+++ b/src/propgrid/advprops.cpp
@@ -4,7 +4,7 @@
 // Author:      Jaakko Salli
 // Modified by:
 // Created:     2004-09-25
-// RCS-ID:      $Id:
+// RCS-ID:      $Id$
 // Copyright:   (c) Jaakko Salli
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
@@ -16,6 +16,8 @@
     #pragma hdrstop
 #endif
 
+#if wxUSE_PROPGRID
+
 #ifndef WX_PRECOMP
     #include "wx/defs.h"
     #include "wx/object.h"
@@ -40,24 +42,24 @@
     #include "wx/scrolwin.h"
     #include "wx/dirdlg.h"
     #include "wx/combobox.h"
-    #include "wx/layout.h"
     #include "wx/sizer.h"
     #include "wx/textdlg.h"
     #include "wx/filedlg.h"
     #include "wx/intl.h"
+    #include "wx/wxcrtvararg.h"
 #endif
 
 #define __wxPG_SOURCE_FILE__
 
-#include <wx/propgrid/propgrid.h>
+#include "wx/propgrid/propgrid.h"
 
 #if wxPG_INCLUDE_ADVPROPS
 
-#include <wx/propgrid/advprops.h>
+#include "wx/propgrid/advprops.h"
 
 #ifdef __WXMSW__
-    #include <wx/msw/private.h>
-    #include <wx/msw/dc.h>
+    #include "wx/msw/private.h"
+    #include "wx/msw/dc.h"
 #endif
 
 // -----------------------------------------------------------------------
@@ -78,11 +80,6 @@
 // -----------------------------------------------------------------------
 
 
-bool operator == (const wxFont&, const wxFont&)
-{
-    return false;
-}
-
 // Implement dynamic class for type value.
 IMPLEMENT_DYNAMIC_CLASS(wxColourPropertyValue, wxObject)
 
@@ -111,9 +108,134 @@ bool operator == (const wxArrayInt& array1, const wxArrayInt& array2)
 #if wxUSE_SPINBTN
 
 
-// This macro also defines global wxPGEditor_SpinCtrl for storing
-// the singleton class instance.
-WX_PG_IMPLEMENT_EDITOR_CLASS(SpinCtrl,wxPGSpinCtrlEditor,wxPGEditor)
+#ifdef __WXMSW__
+  #define IS_MOTION_SPIN_SUPPORTED  1
+#else
+  #define IS_MOTION_SPIN_SUPPORTED  0
+#endif
+
+#if IS_MOTION_SPIN_SUPPORTED
+
+//
+// This class implements ability to rapidly change "spin" value
+// by moving mouse when one of the spin buttons is depressed.
+class wxPGSpinButton : public wxSpinButton
+{
+public:
+    wxPGSpinButton() : wxSpinButton()
+    {
+        m_bLeftDown = false;
+        m_hasCapture = false;
+        m_spins = 1;
+
+        Connect( wxEVT_LEFT_DOWN,
+                 wxMouseEventHandler(wxPGSpinButton::OnMouseEvent) );
+        Connect( wxEVT_LEFT_UP,
+                 wxMouseEventHandler(wxPGSpinButton::OnMouseEvent) );
+        Connect( wxEVT_MOTION,
+                 wxMouseEventHandler(wxPGSpinButton::OnMouseEvent) );
+        Connect( wxEVT_MOUSE_CAPTURE_LOST,
+          wxMouseCaptureLostEventHandler(wxPGSpinButton::OnMouseCaptureLost) );
+    }
+
+    int GetSpins() const
+    {
+        return m_spins;
+    }
+
+private:
+    wxPoint m_ptPosition;
+
+    // Having a separate spins variable allows us to handle validation etc. for
+    // multiple spin events at once (with quick mouse movements there could be
+    // hundreds of 'spins' being done at once). Technically things like this
+    // should be stored in event (wxSpinEvent in this case), but there probably
+    // isn't anything there that can be reliably reused.
+    int     m_spins;
+
+    bool    m_bLeftDown;
+
+    // SpinButton seems to be a special for mouse capture, so we may need track
+    // privately whether mouse is actually captured.
+    bool    m_hasCapture;
+
+    void Capture()
+    {
+        if ( !m_hasCapture )
+        {
+            CaptureMouse();
+            m_hasCapture = true;
+        }
+
+        SetCursor(wxCURSOR_SIZENS);
+    }
+    void Release()
+    {
+        m_bLeftDown = false;
+
+        if ( m_hasCapture )
+        {
+            ReleaseMouse();
+            m_hasCapture = false;
+        }
+
+        wxWindow *parent = GetParent();
+        if ( parent )
+            SetCursor(parent->GetCursor());
+        else
+            SetCursor(wxNullCursor);
+    }
+
+    void OnMouseEvent(wxMouseEvent& event)
+    {
+        if ( event.GetEventType() == wxEVT_LEFT_DOWN )
+        {
+            m_bLeftDown = true;
+            m_ptPosition = event.GetPosition();
+        }
+        else if ( event.GetEventType() == wxEVT_LEFT_UP )
+        {
+            Release();
+            m_bLeftDown = false;
+        }
+        else if ( event.GetEventType() == wxEVT_MOTION )
+        {
+            if ( m_bLeftDown )
+            {
+                int dy = m_ptPosition.y - event.GetPosition().y;
+                if ( dy )
+                {
+                    Capture();
+                    m_ptPosition = event.GetPosition();
+
+                    wxSpinEvent evtscroll( (dy >= 0) ? wxEVT_SCROLL_LINEUP :
+                                                       wxEVT_SCROLL_LINEDOWN,
+                                           GetId() );
+                    evtscroll.SetEventObject(this);
+
+                    wxASSERT( m_spins == 1 );
+
+                    m_spins = abs(dy);
+                    GetEventHandler()->ProcessEvent(evtscroll);
+                    m_spins = 1;
+                }
+            }
+        }
+
+        event.Skip();
+    }
+    void OnMouseCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
+    {
+        Release();
+    }
+};
+
+#endif  // IS_MOTION_SPIN_SUPPORTED
+
+
+WX_PG_IMPLEMENT_INTERNAL_EDITOR_CLASS(SpinCtrl,
+                                      wxPGSpinCtrlEditor,
+                                      wxPGEditor)
 
 
 // Trivial destructor.
@@ -131,7 +253,19 @@ wxPGWindowList wxPGSpinCtrlEditor::CreateControls( wxPropertyGrid* propgrid, wxP
     wxSize tcSz(sz.x - butSz.x - margin, sz.y);
     wxPoint butPos(pos.x + tcSz.x + margin, pos.y);
 
-    wxSpinButton* wnd2 = new wxSpinButton();
+    wxSpinButton* wnd2;
+
+#if IS_MOTION_SPIN_SUPPORTED
+    if ( property->GetAttributeAsLong(wxT("MotionSpin"), 0) )
+    {
+        wnd2 = new wxPGSpinButton();
+    }
+    else
+#endif
+    {
+        wnd2 = new wxSpinButton();
+    }
+
 #ifdef __WXMSW__
     wnd2->Hide();
 #endif
@@ -140,16 +274,6 @@ wxPGWindowList wxPGSpinCtrlEditor::CreateControls( wxPropertyGrid* propgrid, wxP
     wnd2->SetRange( INT_MIN, INT_MAX );
     wnd2->SetValue( 0 );
 
-    propgrid->Connect( wxPG_SUBID2, wxEVT_SCROLL_LINEUP,
-                       (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction)
-                       &wxPropertyGrid::OnCustomEditorEvent, NULL, propgrid );
-    propgrid->Connect( wxPG_SUBID2, wxEVT_SCROLL_LINEDOWN,
-                       (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction)
-                       &wxPropertyGrid::OnCustomEditorEvent, NULL, propgrid );
-    propgrid->Connect( wxPG_SUBID1, wxEVT_KEY_DOWN,
-                       (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction)
-                       &wxPropertyGrid::OnCustomEditorEvent, NULL, propgrid );
-
     // Let's add validator to make sure only numbers can be entered
     wxTextValidator validator(wxFILTER_NUMERIC, &m_tempString);
 
@@ -165,6 +289,7 @@ bool wxPGSpinCtrlEditor::OnEvent( wxPropertyGrid* propgrid, wxPGProperty* proper
 {
     int evtType = event.GetEventType();
     int keycode = -1;
+    int spins = 1;
     bool bigStep = false;
 
     if ( evtType == wxEVT_KEY_DOWN )
@@ -190,6 +315,17 @@ bool wxPGSpinCtrlEditor::OnEvent( wxPropertyGrid* propgrid, wxPGProperty* proper
 
     if ( evtType == wxEVT_SCROLL_LINEUP || evtType == wxEVT_SCROLL_LINEDOWN )
     {
+    #if IS_MOTION_SPIN_SUPPORTED
+        if ( property->GetAttributeAsLong(wxT("MotionSpin"), 0) )
+        {
+            wxPGSpinButton* spinButton =
+                (wxPGSpinButton*) propgrid->GetEditorControlSecondary();
+
+            if ( spinButton )
+                spins = spinButton->GetSpins();
+        }
+    #endif
+
         wxString s;
         // Can't use wnd since it might be clipper window
         wxTextCtrl* tc = wxDynamicCast(propgrid->GetEditorControl(), wxTextCtrl);
@@ -215,6 +351,8 @@ bool wxPGSpinCtrlEditor::OnEvent( wxPropertyGrid* propgrid, wxPGProperty* proper
                 if ( bigStep )
                     step *= 10.0;
 
+                step *= (double) spins;
+
                 if ( evtType == wxEVT_SCROLL_LINEUP ) v_d += step;
                 else v_d -= step;
 
@@ -239,6 +377,8 @@ bool wxPGSpinCtrlEditor::OnEvent( wxPropertyGrid* propgrid, wxPGProperty* proper
                 if ( bigStep )
                     step *= 10;
 
+                step *= spins;
+
                 if ( evtType == wxEVT_SCROLL_LINEUP ) v_ll += step;
                 else v_ll -= step;
 
@@ -277,17 +417,20 @@ bool wxPGSpinCtrlEditor::OnEvent( wxPropertyGrid* propgrid, wxPGProperty* proper
 #if wxUSE_DATEPICKCTRL
 
 
-#include <wx/datectrl.h>
-#include <wx/dateevt.h>
+#include "wx/datectrl.h"
+#include "wx/dateevt.h"
 
 class wxPGDatePickerCtrlEditor : public wxPGEditor
 {
-    WX_PG_DECLARE_EDITOR_CLASS(wxPGDatePickerCtrlEditor)
+    DECLARE_DYNAMIC_CLASS(wxPGDatePickerCtrlEditor)
 public:
     virtual ~wxPGDatePickerCtrlEditor();
 
-    wxPG_DECLARE_CREATECONTROLS
-
+    wxString GetName() const;
+    virtual wxPGWindowList CreateControls(wxPropertyGrid* propgrid,
+                                          wxPGProperty* property,
+                                          const wxPoint& pos,
+                                          const wxSize& size) const;
     virtual void UpdateControl( wxPGProperty* property, wxWindow* wnd ) const;
     virtual bool OnEvent( wxPropertyGrid* propgrid, wxPGProperty* property,
         wxWindow* wnd, wxEvent& event ) const;
@@ -296,7 +439,9 @@ public:
 };
 
 
-WX_PG_IMPLEMENT_EDITOR_CLASS(DatePickerCtrl,wxPGDatePickerCtrlEditor,wxPGEditor)
+WX_PG_IMPLEMENT_INTERNAL_EDITOR_CLASS(DatePickerCtrl,
+                                      wxPGDatePickerCtrlEditor,
+                                      wxPGEditor)
 
 
 wxPGDatePickerCtrlEditor::~wxPGDatePickerCtrlEditor()
@@ -312,7 +457,7 @@ wxPGWindowList wxPGDatePickerCtrlEditor::CreateControls( wxPropertyGrid* propgri
                  NULL,
                  wxT("DatePickerCtrl editor can only be used with wxDateProperty or derivative.") );
 
-    wxDateProperty* prop = (wxDateProperty*) property;
+    wxDateProperty* prop = wxDynamicCast(property, wxDateProperty);
 
     // Use two stage creation to allow cleaner display on wxMSW
     wxDatePickerCtrl* ctrl = new wxDatePickerCtrl();
@@ -323,20 +468,20 @@ wxPGWindowList wxPGDatePickerCtrlEditor::CreateControls( wxPropertyGrid* propgri
 #else
     wxSize useSz = sz;
 #endif
+
+    wxDateTime dateValue(wxInvalidDateTime);
+
+    wxVariant value = prop->GetValue();
+    if ( value.GetType() == wxT("datetime") )
+        dateValue = value.GetDateTime();
+
     ctrl->Create(propgrid->GetPanel(),
                  wxPG_SUBID1,
-                 prop->GetDateValue(),
+                 dateValue,
                  pos,
                  useSz,
                  prop->GetDatePickerStyle() | wxNO_BORDER);
 
-    // Connect all required events to grid's OnCustomEditorEvent
-    // (all relevenat wxTextCtrl, wxComboBox and wxButton events are
-    // already connected)
-    propgrid->Connect( wxPG_SUBID1, wxEVT_DATE_CHANGED,
-                       (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction)
-                       &wxPropertyGrid::OnCustomEditorEvent );
-
 #ifdef __WXMSW__
     ctrl->Show();
 #endif
@@ -345,14 +490,18 @@ wxPGWindowList wxPGDatePickerCtrlEditor::CreateControls( wxPropertyGrid* propgri
 }
 
 // Copies value from property to control
-void wxPGDatePickerCtrlEditor::UpdateControl( wxPGProperty* property, wxWindow* wnd ) const
+void wxPGDatePickerCtrlEditor::UpdateControl( wxPGProperty* property,
+                                              wxWindow* wnd ) const
 {
     wxDatePickerCtrl* ctrl = (wxDatePickerCtrl*) wnd;
     wxASSERT( ctrl && ctrl->IsKindOf(CLASSINFO(wxDatePickerCtrl)) );
 
-    // We assume that property's data type is 'int' (or something similar),
-    // thus allowing us to get raw, unchecked value via DoGetValue.
-    ctrl->SetValue( property->GetValue().GetDateTime() );
+    wxDateTime dateValue(wxInvalidDateTime);
+    wxVariant v(property->GetValue());
+    if ( v.GetType() == wxT("datetime") )
+        dateValue = v.GetDateTime();
+
+    ctrl->SetValue( dateValue );
 }
 
 // Control's events are redirected here
@@ -377,11 +526,20 @@ bool wxPGDatePickerCtrlEditor::GetValueFromControl( wxVariant& variant, wxPGProp
     return true;
 }
 
-void wxPGDatePickerCtrlEditor::SetValueToUnspecified( wxPGProperty* WXUNUSED(property), wxWindow* WXUNUSED(wnd) ) const
+void wxPGDatePickerCtrlEditor::SetValueToUnspecified( wxPGProperty* property,
+                                                      wxWindow* wnd ) const
 {
-    // TODO?
-    //wxDateProperty* prop = (wxDateProperty*) property;
-    //ctrl->SetValue(?);
+    wxDatePickerCtrl* ctrl = (wxDatePickerCtrl*) wnd;
+    wxASSERT( ctrl && ctrl->IsKindOf(CLASSINFO(wxDatePickerCtrl)) );
+
+    wxDateProperty* prop = wxDynamicCast(property, wxDateProperty);
+
+    if ( prop )
+    {
+        int datePickerStyle = prop->GetDatePickerStyle();
+        if ( datePickerStyle & wxDP_ALLOWNONE )
+            ctrl->SetValue(wxInvalidDateTime);
+    }
 }
 
 #endif // wxUSE_DATEPICKCTRL
@@ -391,8 +549,8 @@ void wxPGDatePickerCtrlEditor::SetValueToUnspecified( wxPGProperty* WXUNUSED(pro
 // wxFontProperty
 // -----------------------------------------------------------------------
 
-#include <wx/fontdlg.h>
-#include <wx/fontenum.h>
+#include "wx/fontdlg.h"
+#include "wx/fontenum.h"
 
 static const wxChar* gs_fp_es_family_labels[] = {
     wxT("Default"), wxT("Decorative"),
@@ -444,19 +602,12 @@ wxFontProperty::wxFontProperty( const wxString& label, const wxString& name,
                                 const wxFont& value )
     : wxPGProperty(label,name)
 {
-    SetValue( wxFontToVariant(value) );
+    SetValue(WXVARIANT(value));
 
     // Initialize font family choices list
     if ( !wxPGGlobalVars->m_fontFamilyChoices )
     {
-        wxFontEnumerator enumerator;
-        enumerator.EnumerateFacenames();
-
-#if wxMINOR_VERSION > 6
-        wxArrayString faceNames = enumerator.GetFacenames();
-#else
-        wxArrayString& faceNames = *enumerator.GetFacenames();
-#endif
+        wxArrayString faceNames = wxFontEnumerator::GetFacenames();
 
         faceNames.Sort();
 
@@ -465,13 +616,15 @@ wxFontProperty::wxFontProperty( const wxString& label, const wxString& name,
 
     wxString emptyString(wxEmptyString);
 
-    wxFont& font = wxFontFromVariant(m_value);
+    wxFont font;
+    font << m_value;
 
-    AddChild( new wxIntProperty( _("Point Size"),emptyString,(long)font.GetPointSize() ) );
+    AddPrivateChild( new wxIntProperty( _("Point Size"),
+                     wxS("Point Size"),(long)font.GetPointSize() ) );
 
-    AddChild( new wxEnumProperty(_("Family"), emptyString,
-              gs_fp_es_family_labels,gs_fp_es_family_values,
-              font.GetFamily()) );
+    AddPrivateChild( new wxEnumProperty(_("Family"), wxS("PointSize"),
+                     gs_fp_es_family_labels,gs_fp_es_family_values,
+                     font.GetFamily()) );
 
     wxString faceName = font.GetFaceName();
     // If font was not in there, add it now
@@ -479,42 +632,42 @@ wxFontProperty::wxFontProperty( const wxString& label, const wxString& name,
          wxPGGlobalVars->m_fontFamilyChoices->Index(faceName) == wxNOT_FOUND )
         wxPGGlobalVars->m_fontFamilyChoices->AddAsSorted(faceName);
 
-    wxPGProperty* p = new wxEnumProperty(_("Face Name"),emptyString,
+    wxPGProperty* p = new wxEnumProperty(_("Face Name"), wxS("Face Name"),
                                          *wxPGGlobalVars->m_fontFamilyChoices);
 
     p->SetValueFromString(faceName, wxPG_FULL_VALUE);
 
-    AddChild( p );
+    AddPrivateChild( p );
 
-    AddChild( new wxEnumProperty(_("Style"),emptyString,
-              gs_fp_es_style_labels,gs_fp_es_style_values,font.GetStyle()) );
+    AddPrivateChild( new wxEnumProperty(_("Style"), wxS("Style"),
+                     gs_fp_es_style_labels,gs_fp_es_style_values,
+                     font.GetStyle()) );
 
-    AddChild( new wxEnumProperty(_("Weight"),emptyString,
-              gs_fp_es_weight_labels,gs_fp_es_weight_values,font.GetWeight()) );
+    AddPrivateChild( new wxEnumProperty(_("Weight"), wxS("Weight"),
+                     gs_fp_es_weight_labels,gs_fp_es_weight_values,
+                     font.GetWeight()) );
 
-    AddChild( new wxBoolProperty(_("Underlined"),emptyString,
-              font.GetUnderlined()) );
+    AddPrivateChild( new wxBoolProperty(_("Underlined"), wxS("Underlined"),
+                     font.GetUnderlined()) );
 }
 
 wxFontProperty::~wxFontProperty() { }
 
 void wxFontProperty::OnSetValue()
 {
-    wxFont& font = wxFontFromVariant(m_value);
-    wxASSERT(&font);
+    wxFont font;
+    font << m_value;
 
-    wxFont font2;
     if ( !font.Ok() )
-        font2 = wxFont(10,wxSWISS,wxNORMAL,wxNORMAL);
-    else
-        font2 = font;
-
-    m_value = wxFontToVariant(font2);
+    {
+        m_value << *wxNORMAL_FONT;
+    }
 }
 
-wxString wxFontProperty::GetValueAsString( int argFlags ) const
+wxString wxFontProperty::ValueToString( wxVariant& value,
+                                        int argFlags ) const
 {
-    return wxPGProperty::GetValueAsString(argFlags);
+    return wxPGProperty::ValueToString(value, argFlags);
 }
 
 bool wxFontProperty::OnEvent( wxPropertyGrid* propgrid, wxWindow* WXUNUSED(primary),
@@ -523,10 +676,12 @@ bool wxFontProperty::OnEvent( wxPropertyGrid* propgrid, wxWindow* WXUNUSED(prima
     if ( propgrid->IsMainButtonEvent(event) )
     {
         // Update value from last minute changes
-        PrepareValueForDialogEditing(propgrid);
+        wxVariant useValue = propgrid->GetUncommittedPropertyValue();
 
         wxFontData data;
-        data.SetInitialFont( wxFontFromVariant(m_value) );
+        wxFont font;
+        font << useValue;
+        data.SetInitialFont( font );
         data.SetColour(*wxBLACK);
 
         wxFontDialog dlg(propgrid, data);
@@ -534,7 +689,8 @@ bool wxFontProperty::OnEvent( wxPropertyGrid* propgrid, wxWindow* WXUNUSED(prima
         {
             propgrid->EditorsValueWasModified();
 
-            wxVariant variant = wxFontToVariant(dlg.GetFontData().GetChosenFont());
+            wxVariant variant;
+            variant << dlg.GetFontData().GetChosenFont();
             SetValueInEvent( variant );
             return true;
         }
@@ -545,7 +701,8 @@ bool wxFontProperty::OnEvent( wxPropertyGrid* propgrid, wxWindow* WXUNUSED(prima
 void wxFontProperty::RefreshChildren()
 {
     if ( !GetChildCount() ) return;
-    const wxFont& font = wxFontFromVariant(m_value);
+    wxFont font;
+    font << m_value;
     Item(0)->SetValue( (long)font.GetPointSize() );
     Item(1)->SetValue( (long)font.GetFamily() );
     Item(2)->SetValueFromString( font.GetFaceName(), wxPG_FULL_VALUE );
@@ -554,9 +711,12 @@ void wxFontProperty::RefreshChildren()
     Item(5)->SetValue( font.GetUnderlined() );
 }
 
-void wxFontProperty::ChildChanged( wxVariant& thisValue, int ind, wxVariant& childValue ) const
+wxVariant wxFontProperty::ChildChanged( wxVariant& thisValue,
+                                        int ind,
+                                        wxVariant& childValue ) const
 {
-    wxFont& font = wxFontFromVariant(thisValue);
+    wxFont font;
+    font << thisValue;
 
     if ( ind == 0 )
     {
@@ -602,6 +762,10 @@ void wxFontProperty::ChildChanged( wxVariant& thisValue, int ind, wxVariant& chi
     {
         font.SetUnderlined( childValue.GetBool() );
     }
+
+    wxVariant newVariant;
+    newVariant << font;
+    return newVariant;
 }
 
 /*
@@ -655,7 +819,7 @@ void wxFontProperty::OnCustomPaint(wxDC& dc,
 // wxEnumProperty based classes cannot use wxPG_PROP_CLASS_SPECIFIC_1
 #define wxPG_PROP_HIDE_CUSTOM_COLOUR        wxPG_PROP_CLASS_SPECIFIC_2
 
-#include <wx/colordlg.h>
+#include "wx/colordlg.h"
 
 //#define wx_cp_es_syscolours_len 25
 static const wxChar* gs_cp_es_syscolour_labels[] = {
@@ -716,7 +880,7 @@ static long gs_cp_es_syscolour_values[] = {
 };
 
 
-WX_PG_IMPLEMENT_WXOBJECT_VARIANT_DATA(wxPGVariantDataColourPropertyValue, wxColourPropertyValue)
+IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(wxColourPropertyValue, WXDLLIMPEXP_PROPGRID)
 
 
 // Class body is in advprops.h
@@ -736,7 +900,7 @@ void wxSystemColourProperty::Init( int type, const wxColour& colour )
 
     m_flags |= wxPG_PROP_STATIC_CHOICES; // Colour selection cannot be changed.
 
-    m_value = wxColourPropertyValueToVariant(cpv);
+    m_value << cpv;
 
     OnSetValue();
 }
@@ -795,20 +959,29 @@ wxColourPropertyValue wxSystemColourProperty::GetVal( const wxVariant* pVariant
     if ( pVariant->IsNull() )
         return wxColourPropertyValue(wxPG_COLOUR_UNSPECIFIED, wxColour());
 
-    wxColourPropertyValue* v1 = &wxColourPropertyValueFromVariant(*pVariant);
-    if ( v1 )
-        return *v1;
+    if ( pVariant->GetType() == wxS("wxColourPropertyValue") )
+    {
+        wxColourPropertyValue v;
+        v << *pVariant;
+        return v;
+    }
 
-    wxColour* pCol = wxGetVariantCast(*pVariant, wxColour);
     wxColour col;
     bool variantProcessed = true;
 
-    if ( pCol )
+    if ( pVariant->GetType() == wxS("wxColour*") )
     {
+        wxColour* pCol = wxStaticCast(pVariant->GetWxObjectPtr(), wxColour);
         col = *pCol;
     }
-    else if ( pVariant->GetType() == wxT("wxArrayInt") )
+    else if ( pVariant->GetType() == wxS("wxColour") )
     {
+        col << *pVariant;
+    }
+    else if ( pVariant->GetType() == wxArrayInt_VariantType )
+    {
+        // This code is mostly needed for wxPython bindings, which
+        // may offer tuple of integers as colour value.
         wxArrayInt arr;
         arr << *pVariant;
 
@@ -830,10 +1003,6 @@ wxColourPropertyValue wxSystemColourProperty::GetVal( const wxVariant* pVariant
             variantProcessed = false;
         }
     }
-    else if ( pVariant->GetType() == wxT("wxColour") )
-    {
-        col << *pVariant;
-    }
     else
     {
         variantProcessed = false;
@@ -853,7 +1022,9 @@ wxColourPropertyValue wxSystemColourProperty::GetVal( const wxVariant* pVariant
 
 wxVariant wxSystemColourProperty::DoTranslateVal( wxColourPropertyValue& v ) const
 {
-    return wxColourPropertyValueToVariant(v);
+    wxVariant variant;
+    variant << v;
+    return variant;
 }
 
 int wxSystemColourProperty::ColToInd( const wxColour& colour ) const
@@ -877,20 +1048,12 @@ int wxSystemColourProperty::ColToInd( const wxColour& colour ) const
     return wxNOT_FOUND;
 }
 
-
-static inline wxColour wxColourFromPGLong( long col )
-{
-    return wxColour((col&0xFF),((col>>8)&0xFF),((col>>16)&0xFF));
-}
-
-
 void wxSystemColourProperty::OnSetValue()
 {
     // Convert from generic wxobject ptr to wxPGVariantDataColour
-    if ( wxPGIsVariantType(m_value, wxobject) )
+    if ( m_value.GetType() == wxS("wxColour*") )
     {
-        wxASSERT( m_value.IsValueKindOf(CLASSINFO(wxColour)) );
-        wxColour* pCol = (wxColour*) m_value.GetWxObjectPtr();
+        wxColour* pCol = wxStaticCast(m_value.GetWxObjectPtr(), wxColour);
         m_value << *pCol;
     }
 
@@ -910,39 +1073,43 @@ void wxSystemColourProperty::OnSetValue()
         m_value = TranslateVal(val);
     }
 
-    wxColourPropertyValue* pCpv = &wxColourPropertyValueFromVariant(m_value);
-    wxColour col;
-    if ( pCpv )
-        col = pCpv->m_colour;
-    else
-        col << m_value;
+    int ind = wxNOT_FOUND;
 
-    if ( !col.Ok() )
+    if ( m_value.GetType() == wxS("wxColourPropertyValue") )
     {
-        SetValueToUnspecified();
-        SetIndex(wxNOT_FOUND);
-        return;
-    }
+        wxColourPropertyValue cpv;
+        cpv << m_value;
+        wxColour col = cpv.m_colour;
 
-    int ind;
+        if ( !col.Ok() )
+        {
+            SetValueToUnspecified();
+            SetIndex(wxNOT_FOUND);
+            return;
+        }
 
-    if ( pCpv )
-    {
-        if ( pCpv->m_type < wxPG_COLOUR_WEB_BASE )
+        if ( cpv.m_type < wxPG_COLOUR_WEB_BASE )
         {
-            if ( m_choices.HasValues() )
-                ind = GetIndexForValue(pCpv->m_type);
-            else
-                ind = ColToInd(col);
+            ind = GetIndexForValue(cpv.m_type);
         }
         else
         {
-            pCpv->m_type = wxPG_COLOUR_CUSTOM;
+            cpv.m_type = wxPG_COLOUR_CUSTOM;
             ind = GetCustomColourIndex();
         }
     }
     else
     {
+        wxColour col;
+        col << m_value;
+
+        if ( !col.Ok() )
+        {
+            SetValueToUnspecified();
+            SetIndex(wxNOT_FOUND);
+            return;
+        }
+
         ind = ColToInd(col);
 
         if ( ind == wxNOT_FOUND )
@@ -969,24 +1136,30 @@ wxString wxSystemColourProperty::ColourToString( const wxColour& col, int index
         return m_choices.GetLabel(index);
 }
 
-wxString wxSystemColourProperty::GetValueAsString( int argFlags ) const
+wxString wxSystemColourProperty::ValueToString( wxVariant& value,
+                                                int argFlags ) const
 {
-    wxColourPropertyValue val = GetVal();
+    wxColourPropertyValue val = GetVal(&value);
 
-    int ind = GetIndex();
+    int index;
 
-    // Always show custom colour for textctrl-editor
-    if ( val.m_type == wxPG_COLOUR_CUSTOM ||
-         ind == GetCustomColourIndex() ||
-         (argFlags & wxPG_PROPERTY_SPECIFIC) )
+    if ( argFlags & wxPG_VALUE_IS_CURRENT )
     {
-        return ColourToString(val.m_colour, wxNOT_FOUND);
+        // GetIndex() only works reliably if wxPG_VALUE_IS_CURRENT flag is set,
+        // but we should use it whenever possible.
+        index = GetIndex();
+
+        // If custom colour was selected, use invalid index, so that
+        // ColourToString() will return properly formatted colour text.
+        if ( index == GetCustomColourIndex() )
+            index = wxNOT_FOUND;
+    }
+    else
+    {
+        index = m_choices.Index(val.m_type);
     }
 
-    if ( ind == -1 )
-        return wxEmptyString;
-
-    return ColourToString(val.m_colour, ind);
+    return ColourToString(val.m_colour, index);
 }
 
 
@@ -1004,14 +1177,14 @@ int wxSystemColourProperty::GetCustomColourIndex() const
 
 bool wxSystemColourProperty::QueryColourFromUser( wxVariant& variant ) const
 {
-    wxASSERT( m_value.GetType() != wxT("string") );
+    wxASSERT( m_value.GetType() != wxPG_VARIANT_TYPE_STRING );
     bool res = false;
 
     wxPropertyGrid* propgrid = GetGrid();
     wxASSERT( propgrid );
 
     // Must only occur when user triggers event
-    if ( !(propgrid->GetInternalFlags() & wxPG_FL_IN_ONCUSTOMEDITOREVENT) )
+    if ( !(propgrid->GetInternalFlags() & wxPG_FL_IN_HANDLECUSTOMEDITOREVENT) )
         return res;
 
     wxColourPropertyValue val = GetVal();
@@ -1048,14 +1221,9 @@ bool wxSystemColourProperty::QueryColourFromUser( wxVariant& variant ) const
 bool wxSystemColourProperty::IntToValue( wxVariant& variant, int number, int WXUNUSED(argFlags) ) const
 {
     int index = number;
-    int type = GetValueForIndex(index);
-    bool hasValue = m_choices[index].HasValue();
+    int type = m_choices.GetValue(index);
 
-    if ( ( hasValue && type == wxPG_COLOUR_CUSTOM ) ||
-         ( !hasValue && (index == (int)GetCustomColourIndex() &&
-                                      !(m_flags & wxPG_PROP_HIDE_CUSTOM_COLOUR))
-         )
-       )
+    if ( type == wxPG_COLOUR_CUSTOM )
     {
         QueryColourFromUser(variant);
     }
@@ -1213,7 +1381,7 @@ bool wxSystemColourProperty::StringToValue( wxVariant& value, const wxString& te
             if ( res && GetIndex() >= 0 )
             {
                 val.m_type = GetIndex();
-                if ( val.m_type >= 0 && val.m_type < m_choices.GetCount() && m_choices[val.m_type].HasValue() )
+                if ( val.m_type < m_choices.GetCount() )
                     val.m_type = m_choices[val.m_type].GetValue();
 
                 // Get proper colour for type.
@@ -1259,8 +1427,6 @@ bool wxSystemColourProperty::DoSetAttribute( const wxString& name, wxVariant& va
     {
         int ival = wxPGVariantToInt(value);
 
-        SetChoicesExclusive(); // Make sure we don't corrupt colour lists of other properties
-
         if ( ival && (m_flags & wxPG_PROP_HIDE_CUSTOM_COLOUR) )
         {
             // Show custom choice
@@ -1328,11 +1494,63 @@ static unsigned long gs_cp_es_normcolour_colours[] = {
     wxPG_COLOUR(0,0,0)
 };
 
-WX_PG_IMPLEMENT_CUSTOM_COLOUR_PROPERTY_USES_WXCOLOUR2(wxColourProperty,
-                                                     gs_cp_es_normcolour_labels,
-                                                     (const long*)NULL,
-                                                     gs_cp_es_normcolour_colours,
-                                                     TextCtrlAndButton)
+WX_PG_IMPLEMENT_PROPERTY_CLASS(wxColourProperty, wxSystemColourProperty,
+                               wxColour, const wxColour&, TextCtrlAndButton)
+
+static wxPGChoices gs_wxColourProperty_choicesCache;
+
+wxColourProperty::wxColourProperty( const wxString& label,
+                      const wxString& name,
+                      const wxColour& value )
+    : wxSystemColourProperty(label, name, gs_cp_es_normcolour_labels,
+                             NULL,
+                             &gs_wxColourProperty_choicesCache, value )
+{
+    Init( value );
+
+    m_flags |= wxPG_PROP_TRANSLATE_CUSTOM;
+}
+
+wxColourProperty::~wxColourProperty()
+{
+}
+
+void wxColourProperty::Init( wxColour colour )
+{
+    if ( !colour.Ok() )
+        colour = *wxWHITE;
+    wxVariant variant;
+    variant << colour;
+    m_value = variant;
+    int ind = ColToInd(colour);
+    if ( ind < 0 )
+        ind = m_choices.GetCount() - 1;
+    SetIndex( ind );
+}
+
+wxString wxColourProperty::ValueToString( wxVariant& value,
+                                          int argFlags ) const
+{
+    const wxPGEditor* editor = GetEditorClass();
+    if ( editor != wxPGEditor_Choice &&
+         editor != wxPGEditor_ChoiceAndButton &&
+         editor != wxPGEditor_ComboBox )
+        argFlags |= wxPG_PROPERTY_SPECIFIC;
+
+    return wxSystemColourProperty::ValueToString(value, argFlags);
+}
+
+wxColour wxColourProperty::GetColour( int index ) const
+{
+    return gs_cp_es_normcolour_colours[m_choices.GetValue(index)];
+}
+
+wxVariant wxColourProperty::DoTranslateVal( wxColourPropertyValue& v ) const
+{
+    wxVariant variant;
+    variant << v.m_colour;
+    return variant;
+}
 
 // -----------------------------------------------------------------------
 // wxCursorProperty
@@ -1449,13 +1667,14 @@ void wxCursorProperty::OnCustomPaint( wxDC& dc,
 
         if ( paintdata.m_choiceItem < NUM_CURSORS )
         {
-            int cursorindex = gs_cp_es_syscursors_values[paintdata.m_choiceItem];
+            wxStockCursor cursorIndex =
+                (wxStockCursor) gs_cp_es_syscursors_values[paintdata.m_choiceItem];
 
             {
-                if ( cursorindex == wxCURSOR_NONE )
-                    cursorindex = wxCURSOR_ARROW;
+                if ( cursorIndex == wxCURSOR_NONE )
+                    cursorIndex = wxCURSOR_ARROW;
 
-                wxCursor cursor( cursorindex );
+                wxCursor cursor( cursorIndex );
 
             #ifdef __WXMSW__
                 HDC hDc = (HDC)((const wxMSWDCImpl *)dc.GetImpl())->GetHDC();
@@ -1467,7 +1686,10 @@ void wxCursorProperty::OnCustomPaint( wxDC& dc,
                               0,
                               0,
                               NULL,
-                              DI_COMPAT | DI_DEFAULTSIZE | DI_NORMAL
+            #if !defined(__WXWINCE__)
+                              DI_COMPAT | DI_DEFAULTSIZE |
+            #endif
+                              DI_NORMAL
                             );
             #endif
             }
@@ -1505,7 +1727,7 @@ const wxString& wxPGGetDefaultImageWildcard()
 
         // Let's iterate over the image handler list.
         //for ( wxList::Node *node = handlers.GetFirst(); node; node = node->GetNext() )
-        for ( node = handlers.begin(); node != handlers.end(); node++ )
+        for ( node = handlers.begin(); node != handlers.end(); ++node )
         {
             wxImageHandler *handler = (wxImageHandler*)*node;
 
@@ -1528,9 +1750,7 @@ const wxString& wxPGGetDefaultImageWildcard()
     return wxPGGlobalVars->m_pDefaultImageWildcard;
 }
 
-WX_PG_IMPLEMENT_DERIVED_PROPERTY_CLASS(wxImageFileProperty,
-                                       wxFileProperty,
-                                       const wxString&)
+IMPLEMENT_DYNAMIC_CLASS(wxImageFileProperty, wxFileProperty)
 
 wxImageFileProperty::wxImageFileProperty( const wxString& label, const wxString& name,
     const wxString& value )
@@ -1538,8 +1758,8 @@ wxImageFileProperty::wxImageFileProperty( const wxString& label, const wxString&
 {
     SetAttribute( wxPG_FILE_WILDCARD, wxPGGetDefaultImageWildcard() );
 
-    m_pImage = (wxImage*) NULL;
-    m_pBitmap = (wxBitmap*) NULL;
+    m_pImage = NULL;
+    m_pBitmap = NULL;
 }
 
 wxImageFileProperty::~wxImageFileProperty()
@@ -1566,10 +1786,12 @@ void wxImageFileProperty::OnSetValue()
         m_pBitmap = NULL;
     }
 
+    wxFileName filename = GetFileName();
+
     // Create the image thumbnail
-    if ( m_filename.FileExists() )
+    if ( filename.FileExists() )
     {
-        m_pImage = new wxImage( m_filename.GetFullPath() );
+        m_pImage = new wxImage( filename.GetFullPath() );
     }
 }
 
@@ -1613,7 +1835,7 @@ void wxImageFileProperty::OnCustomPaint( wxDC& dc,
 
 #if wxUSE_CHOICEDLG
 
-#include <wx/choicdlg.h>
+#include "wx/choicdlg.h"
 
 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxMultiChoiceProperty,wxPGProperty,
                                wxArrayInt,const wxArrayInt&,TextCtrlAndButton)
@@ -1654,22 +1876,30 @@ wxMultiChoiceProperty::~wxMultiChoiceProperty()
 
 void wxMultiChoiceProperty::OnSetValue()
 {
-    GenerateValueAsString();
+    GenerateValueAsString(m_value, &m_display);
 }
 
-wxString wxMultiChoiceProperty::GetValueAsString( int ) const
+wxString wxMultiChoiceProperty::ValueToString( wxVariant& value,
+                                               int argFlags ) const
 {
-    return m_display;
+    // If possible, use cached string
+    if ( argFlags & wxPG_VALUE_IS_CURRENT )
+        return m_display;
+
+    wxString s;
+    GenerateValueAsString(value, &s);
+    return s;
 }
 
-void wxMultiChoiceProperty::GenerateValueAsString()
+void wxMultiChoiceProperty::GenerateValueAsString( wxVariant& value,
+                                                   wxString* target ) const
 {
     wxArrayString strings;
 
-    if ( wxPGIsVariantType(m_value, arrstring) )
-        strings = m_value.GetArrayString();
+    if ( value.GetType() == wxPG_VARIANT_TYPE_ARRSTRING )
+        strings = value.GetArrayString();
 
-    wxString& tempStr = m_display;
+    wxString& tempStr = *target;
     unsigned int i;
     unsigned int itemCount = strings.size();
 
@@ -1689,7 +1919,8 @@ void wxMultiChoiceProperty::GenerateValueAsString()
 
 wxArrayInt wxMultiChoiceProperty::GetValueAsIndices() const
 {
-    const wxArrayInt& valueArr = wxArrayIntFromVariant(GetValue());
+    wxVariant variant = GetValue();
+    const wxArrayInt& valueArr = wxArrayIntRefFromVariant(variant);
     unsigned int i;
 
     // Translate values to string indices.
@@ -1720,7 +1951,7 @@ bool wxMultiChoiceProperty::OnEvent( wxPropertyGrid* propgrid,
     if ( propgrid->IsMainButtonEvent(event) )
     {
         // Update the value
-        PrepareValueForDialogEditing(propgrid);
+        wxVariant useValue = propgrid->GetUncommittedPropertyValue();
 
         wxArrayString labels = m_choices.GetLabels();
         unsigned int choiceCount;
@@ -1740,7 +1971,7 @@ bool wxMultiChoiceProperty::OnEvent( wxPropertyGrid* propgrid,
 
         dlg.Move( propgrid->GetGoodEditorDialogPosition(this,dlg.GetSize()) );
 
-        wxArrayString strings = m_value.GetArrayString();
+        wxArrayString strings = useValue.GetArrayString();
         wxArrayString extraStrings;
 
         dlg.SetSelections(m_choices.GetIndicesForStrings(strings, &extraStrings));
@@ -1785,13 +2016,6 @@ bool wxMultiChoiceProperty::OnEvent( wxPropertyGrid* propgrid,
     return false;
 }
 
-int wxMultiChoiceProperty::GetChoiceInfo( wxPGChoiceInfo* choiceinfo )
-{
-    if ( choiceinfo )
-        choiceinfo->m_choices = &m_choices;
-    return -1;
-}
-
 bool wxMultiChoiceProperty::StringToValue( wxVariant& variant, const wxString& text, int ) const
 {
     wxArrayString arr;
@@ -1857,12 +2081,25 @@ wxDateProperty::~wxDateProperty()
 {
 }
 
+void wxDateProperty::OnSetValue()
+{
+    //
+    // Convert invalid dates to unspecified value
+    if ( m_value.GetType() == wxT("datetime") )
+    {
+        if ( !m_value.GetDateTime().IsValid() )
+            m_value.MakeNull();
+    }
+}
+
 bool wxDateProperty::StringToValue( wxVariant& variant, const wxString& text,
                                     int WXUNUSED(argFlags) ) const
 {
     wxDateTime dt;
 
-    const char* c = dt.ParseFormat(text, wxString(wxDefaultDateTimeFormat), wxDefaultDateTime, NULL);
+    // FIXME: do we really want to return true from here if only part of the
+    //        string was parsed?
+    const char* c = dt.ParseFormat(text);
 
     if ( c )
     {
@@ -1873,11 +2110,12 @@ bool wxDateProperty::StringToValue( wxVariant& variant, const wxString& text,
     return false;
 }
 
-wxString wxDateProperty::GetValueAsString( int argFlags ) const
+wxString wxDateProperty::ValueToString( wxVariant& value,
+                                        int argFlags ) const
 {
     const wxChar* format = (const wxChar*) NULL;
 
-    wxDateTime dateTime = m_value.GetDateTime();
+    wxDateTime dateTime = value.GetDateTime();
 
     if ( !dateTime.IsValid() )
         return wxT("Invalid");
@@ -1980,6 +2218,10 @@ void wxPropertyGridInterface::InitAllTypeHandlers()
 
 void wxPropertyGridInterface::RegisterAdditionalEditors()
 {
+    // Register editor classes, if necessary.
+    if ( wxPGGlobalVars->m_mapEditorClasses.empty() )
+        wxPropertyGrid::RegisterDefaultEditors();
+
 #if wxUSE_SPINBTN
     wxPGRegisterEditorClass(SpinCtrl);
 #endif
@@ -1990,4 +2232,7 @@ void wxPropertyGridInterface::RegisterAdditionalEditors()
 
 // -----------------------------------------------------------------------
 
-#endif // wxPG_INCLUDE_ADVPROPS
+#endif  // wxPG_INCLUDE_ADVPROPS
+
+#endif  // wxUSE_PROPGRID
+