X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/939d936402b4ac38310531ed39b4fd05afe29531..12bb29f5432174ecbd65549bda832d70d34a98ae:/src/propgrid/propgridiface.cpp

diff --git a/src/propgrid/propgridiface.cpp b/src/propgrid/propgridiface.cpp
index 74b071871d..5f66781a81 100644
--- a/src/propgrid/propgridiface.cpp
+++ b/src/propgrid/propgridiface.cpp
@@ -4,9 +4,9 @@
 // Author:      Jaakko Salli
 // Modified by:
 // Created:     2008-08-24
-// RCS-ID:      $Id:
+// RCS-ID:      $Id$
 // Copyright:   (c) Jaakko Salli
-// Licence:     wxWindows license
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // For compilers that support precompilation, includes "wx/wx.h".
@@ -32,27 +32,13 @@
     #include "wx/button.h"
     #include "wx/pen.h"
     #include "wx/brush.h"
-    #include "wx/cursor.h"
-    #include "wx/dialog.h"
     #include "wx/settings.h"
-    #include "wx/msgdlg.h"
-    #include "wx/choice.h"
-    #include "wx/stattext.h"
-    #include "wx/scrolwin.h"
-    #include "wx/dirdlg.h"
-    #include "wx/layout.h"
     #include "wx/sizer.h"
-    #include "wx/textdlg.h"
-    #include "wx/filedlg.h"
-    #include "wx/statusbr.h"
     #include "wx/intl.h"
-    #include "wx/frame.h"
 #endif
 
-#include <wx/propgrid/property.h>
-#include <wx/propgrid/propgrid.h>
-
-#include <typeinfo>
+#include "wx/propgrid/property.h"
+#include "wx/propgrid/propgrid.h"
 
 
 const wxChar *wxPGTypeName_long = wxT("long");
@@ -70,133 +56,8 @@ const wxChar *wxPGTypeName_wxArrayString = wxT("arrstring");
 WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED(wxPoint, WXDLLIMPEXP_PROPGRID)
 WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED(wxSize, WXDLLIMPEXP_PROPGRID)
 WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED_DUMMY_EQ(wxArrayInt, WXDLLIMPEXP_PROPGRID)
-WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED(wxLongLong, WXDLLIMPEXP_PROPGRID)
-WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED(wxULongLong, WXDLLIMPEXP_PROPGRID)
-
 IMPLEMENT_VARIANT_OBJECT_EXPORTED(wxFont, WXDLLIMPEXP_PROPGRID)
 
-// -----------------------------------------------------------------------
-// wxVariant helpers
-// -----------------------------------------------------------------------
-
-long wxPGVariantToInt( const wxVariant& variant, long defVal )
-{
-    if ( variant.IsNull() )
-        return defVal;
-
-    if ( variant.GetType() == wxS("long") )
-        return variant.GetLong();
-
-    if ( variant.GetType() == wxS("bool") )
-        return variant.GetBool() ? 1 : 0;
-
-    if ( variant.GetType() == wxS("wxLongLong") )
-    {
-        wxLongLong ll;
-        ll << variant;
-        if ( ll >= LONG_MAX )
-            return LONG_MAX;
-        else if ( ll <= LONG_MIN )
-            return LONG_MIN;
-        return ll.ToLong();
-    }
-
-    long l = defVal;
-
-    if ( variant.GetType() == wxPG_VARIANT_TYPE_STRING )
-        variant.GetString().ToLong(&l, 0);
-
-    return l;
-}
-
-// -----------------------------------------------------------------------
-
-bool wxPGVariantToLongLong( const wxVariant& variant, wxLongLong_t* pResult )
-{
-    if ( variant.IsNull() )
-        return false;
-
-    wxString variantType = variant.GetType();
-
-    if ( variantType == wxPG_VARIANT_TYPE_LONG )
-    {
-        *pResult = variant.GetLong();
-        return true;
-    }
-
-    if ( variantType == wxLongLong_VariantType )
-    {
-        wxLongLong ll;
-        ll << variant;
-        *pResult = ll.GetValue();
-        return true;
-    }
-
-    return false;
-}
-
-// -----------------------------------------------------------------------
-
-bool wxPGVariantToULongLong( const wxVariant& variant, wxULongLong_t* pResult )
-{
-    if ( variant.IsNull() )
-        return false;
-
-    wxString variantType = variant.GetType();
-
-    if ( variantType == wxPG_VARIANT_TYPE_LONG )
-    {
-        *pResult = (unsigned long)variant.GetLong();
-        return true;
-    }
-
-    if ( variantType == wxULongLong_VariantType )
-    {
-        wxULongLong ull;
-        ull << variant;
-        *pResult = ull.GetValue();
-        return true;
-    }
-
-    return false;
-}
-
-// -----------------------------------------------------------------------
-
-bool wxPGVariantToDouble( const wxVariant& variant, double* pResult )
-{
-    if ( variant.IsNull() )
-        return false;
-
-    wxString variantType = variant.GetType();
-
-    if ( variantType == wxPG_VARIANT_TYPE_DOUBLE )
-    {
-        *pResult = variant.GetDouble();
-        return true;
-    }
-
-    if ( variantType == wxPG_VARIANT_TYPE_LONG )
-    {
-        *pResult = (double)variant.GetLong();
-        return true;
-    }
-
-    if ( variantType == wxLongLong_VariantType )
-    {
-        wxLongLong ll;
-        ll << variant;
-        *pResult = ll.ToDouble();
-        return true;
-    }
-
-    if ( variantType == wxPG_VARIANT_TYPE_STRING )
-        if ( variant.GetString().ToDouble(pResult) )
-            return true;
-
-    return false;
-}
-
 // -----------------------------------------------------------------------
 // wxPGPropArgCls
 // -----------------------------------------------------------------------
@@ -212,10 +73,8 @@ wxPGProperty* wxPGPropArgCls::GetPtr( wxPropertyGridInterface* iface ) const
         return iface->GetPropertyByNameA(*m_ptr.stringName);
     else if ( m_flags & IsCharPtr )
         return iface->GetPropertyByNameA(m_ptr.charName);
-#if wxUSE_WCHAR_T
     else if ( m_flags & IsWCharPtr )
         return iface->GetPropertyByNameA(m_ptr.wcharName);
-#endif
 
     return NULL;
 }
@@ -241,7 +100,7 @@ void wxPropertyGridInterface::RefreshGrid( wxPropertyGridPageState* state )
 wxPGProperty* wxPropertyGridInterface::Append( wxPGProperty* property )
 {
     wxPGProperty* retp = m_pState->DoAppend(property);
-    
+
     wxPropertyGrid* grid = m_pState->GetGrid();
     if ( grid )
         grid->RefreshGrid();
@@ -264,7 +123,7 @@ wxPGProperty* wxPropertyGridInterface::AppendIn( wxPGPropArg id, wxPGProperty* n
 wxPGProperty* wxPropertyGridInterface::Insert( wxPGPropArg id, wxPGProperty* property )
 {
     wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
-    wxPGProperty* retp = m_pState->DoInsert(p->GetParent(), p->GetArrIndex(), property);
+    wxPGProperty* retp = m_pState->DoInsert(p->GetParent(), p->GetIndexInParent(), property);
     RefreshGrid();
     return retp;
 }
@@ -286,18 +145,28 @@ void wxPropertyGridInterface::DeleteProperty( wxPGPropArg id )
     wxPG_PROP_ARG_CALL_PROLOG()
 
     wxPropertyGridPageState* state = p->GetParentState();
-    wxPropertyGrid* grid = state->GetGrid();
 
-    if ( grid->GetState() == state )
-    {
-        bool selRes = grid->DoSelectProperty(NULL, wxPG_SEL_DELETING);
-        wxPG_CHECK_RET_DBG( selRes,
-                            wxT("failed to deselect a property (editor probably had invalid value)") );
-    }
+    state->DoDelete( p, true );
 
-    state->DoDelete( p );
+    RefreshGrid(state);
+}
+
+// -----------------------------------------------------------------------
+
+wxPGProperty* wxPropertyGridInterface::RemoveProperty( wxPGPropArg id )
+{
+    wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxNullProperty)
+
+    wxCHECK( !p->GetChildCount() || p->HasFlag(wxPG_PROP_AGGREGATE),
+             wxNullProperty);
+
+    wxPropertyGridPageState* state = p->GetParentState();
+
+    state->DoDelete( p, false );
 
     RefreshGrid(state);
+
+    return p;
 }
 
 // -----------------------------------------------------------------------
@@ -332,14 +201,41 @@ wxPGProperty* wxPropertyGridInterface::ReplaceProperty( wxPGPropArg id, wxPGProp
 // wxPropertyGridInterface property operations
 // -----------------------------------------------------------------------
 
-bool wxPropertyGridInterface::ClearSelection()
+wxPGProperty* wxPropertyGridInterface::GetSelection() const
+{
+    return m_pState->GetSelection();
+}
+
+// -----------------------------------------------------------------------
+
+bool wxPropertyGridInterface::ClearSelection( bool validation )
+{
+    bool res = DoClearSelection(validation, wxPG_SEL_DONT_SEND_EVENT);
+    wxPropertyGrid* pg = GetPropertyGrid();
+    if ( pg )
+        pg->Refresh();
+    return res;
+}
+
+// -----------------------------------------------------------------------
+
+bool wxPropertyGridInterface::DoClearSelection( bool validation,
+                                                int selFlags )
 {
+    if ( !validation )
+        selFlags |= wxPG_SEL_NOVALIDATE;
+
     wxPropertyGridPageState* state = m_pState;
-    wxPropertyGrid* pg = state->GetGrid();
-    if ( pg->GetState() == state )
-        return pg->DoClearSelection();
-    else
-        state->SetSelection(NULL);
+
+    if ( state )
+    {
+        wxPropertyGrid* pg = state->GetGrid();
+        if ( pg->GetState() == state )
+            return pg->DoSelectProperty(NULL, selFlags);
+        else
+            state->DoSetSelection(NULL);
+    }
+
     return true;
 }
 
@@ -368,7 +264,7 @@ bool wxPropertyGridInterface::EnableProperty( wxPGPropArg id, bool enable )
             return false;
 
         // If active, Set active Editor.
-        if ( grid->GetState() == state && p == grid->GetSelection() )
+        if ( grid && grid->GetState() == state && p == grid->GetSelection() )
             grid->DoSelectProperty( p, wxPG_SEL_FORCE );
     }
     else
@@ -377,11 +273,11 @@ bool wxPropertyGridInterface::EnableProperty( wxPGPropArg id, bool enable )
             return false;
 
         // If active, Disable as active Editor.
-        if ( grid->GetState() == state && p == grid->GetSelection() )
+        if ( grid && grid->GetState() == state && p == grid->GetSelection() )
             grid->DoSelectProperty( p, wxPG_SEL_FORCE );
     }
 
-    state->DoEnableProperty(p, enable);
+    p->DoEnable(enable);
 
     RefreshProperty( p );
 
@@ -402,8 +298,7 @@ bool wxPropertyGridInterface::ExpandAll( bool doExpand )
     if ( GetSelection() && GetSelection() != state->DoGetRoot() &&
          !doExpand )
     {
-        if ( !pg->ClearSelection() )
-            return false;
+        pg->DoClearSelection();
     }
 
     wxPGVIterator it;
@@ -439,14 +334,34 @@ bool wxPropertyGridInterface::ExpandAll( bool doExpand )
 
 // -----------------------------------------------------------------------
 
-void wxPropertyGridInterface::SetPropertyValueUnspecified( wxPGPropArg id )
+void wxPropertyGridInterface::ClearModifiedStatus()
 {
-    wxPG_PROP_ARG_CALL_PROLOG()
-    wxPropertyGrid* propGrid = p->GetGridIfDisplayed();
-    if ( propGrid )
-        propGrid->DoSetPropertyValueUnspecified(p);
-    else
-        p->GetParentState()->DoSetPropertyValueUnspecified(p);
+    unsigned int pageIndex = 0;
+
+    for (;;)
+    {
+        wxPropertyGridPageState* page = GetPageState(pageIndex);
+        if ( !page ) break;
+
+        page->DoGetRoot()->SetFlagRecursively(wxPG_PROP_MODIFIED, false);
+        page->m_anyModified = false;
+
+        pageIndex++;
+    }
+
+    // Update active editor control, if any
+    GetPropertyGrid()->RefreshEditor();
+}
+
+bool wxPropertyGridInterface::SetColumnProportion( unsigned int column,
+                                                   int proportion )
+{
+    wxCHECK(m_pState, false);
+    wxPropertyGrid* pg = m_pState->GetGrid();
+    wxCHECK(pg, false);
+    wxCHECK(pg->HasFlag(wxPG_SPLITTER_AUTO_CENTER), false);
+    m_pState->DoSetColumnProportion(column, proportion);
+    return true;
 }
 
 // -----------------------------------------------------------------------
@@ -476,13 +391,7 @@ void wxPropertyGridInterface::SetPropVal( wxPGPropArg id, wxVariant& value )
     wxPG_PROP_ARG_CALL_PROLOG()
 
     if ( p )
-    {
         p->SetValue(value);
-        wxPropertyGrid* propGrid = p->GetGridIfDisplayed();
-        if ( propGrid )
-            propGrid->DrawItemAndValueRelated( p );
-
-    }
 }
 
 // -----------------------------------------------------------------------
@@ -491,12 +400,8 @@ void wxPropertyGridInterface::SetPropertyValueString( wxPGPropArg id, const wxSt
 {
     wxPG_PROP_ARG_CALL_PROLOG()
 
-    if ( m_pState->DoSetPropertyValueString(p,value) )
-    {
-        wxPropertyGrid* propGrid = p->GetGridIfDisplayed();
-        if ( propGrid )
-            propGrid->DrawItemAndValueRelated( p );
-    }
+    if ( p )
+        m_pState->DoSetPropertyValueString(p, value);
 }
 
 // -----------------------------------------------------------------------
@@ -549,6 +454,24 @@ void wxPropertyGridInterface::DoSetPropertyAttribute( wxPGPropArg id, const wxSt
 
 // -----------------------------------------------------------------------
 
+void wxPropertyGridInterface::SetPropertyAttributeAll( const wxString& attrName,
+                                                       wxVariant value )
+{
+    unsigned int pageIndex = 0;
+
+    for (;;)
+    {
+        wxPropertyGridPageState* page = GetPageState(pageIndex);
+        if ( !page ) break;
+
+        DoSetPropertyAttribute(page->DoGetRoot(), attrName, value, wxPG_RECURSE);
+
+        pageIndex++;
+    }
+}
+
+// -----------------------------------------------------------------------
+
 void wxPropertyGridInterface::GetPropertiesWithFlag( wxArrayPGProperty* targetArr,
                                                      wxPGProperty::FlagType flags,
                                                      bool inverse,
@@ -578,34 +501,6 @@ void wxPropertyGridInterface::GetPropertiesWithFlag( wxArrayPGProperty* targetAr
 
 // -----------------------------------------------------------------------
 
-void wxPropertyGridInterface::SetPropertiesFlag( const wxArrayPGProperty& srcArr,
-                                                 wxPGProperty::FlagType flags,
-                                                 bool inverse )
-{
-    unsigned int i;
-
-    for ( i=0; i<srcArr.size(); i++ )
-    {
-        wxPGProperty* property = srcArr[i];
-
-        if ( !inverse )
-            property->SetFlag(flags);
-        else
-            property->ClearFlag(flags);
-    }
-
-    // If collapsed flag or hidden was manipulated, we need to update virtual
-    // size.
-    wxPropertyGrid* pg = GetPropertyGrid();
-    if ( flags & (wxPG_PROP_COLLAPSED|wxPG_PROP_HIDDEN) )
-    {
-        GetState()->VirtualHeightChanged();
-        pg->RecalculateVirtualSize();
-    }
-}
-
-// -----------------------------------------------------------------------
-
 void wxPropertyGridInterface::SetBoolChoices( const wxString& trueChoice,
                                                  const wxString& falseChoice )
 {
@@ -693,6 +588,27 @@ bool wxPropertyGridInterface::Expand( wxPGPropArg id )
 
 // -----------------------------------------------------------------------
 
+void wxPropertyGridInterface::Sort( int flags )
+{
+    wxPropertyGrid* pg = GetPropertyGrid();
+
+    unsigned int pageIndex = 0;
+
+    for (;;)
+    {
+        wxPropertyGridPageState* page = GetPageState(pageIndex);
+        if ( !page ) break;
+        page->DoSort(flags);
+        pageIndex++;
+    }
+
+    // Fix positions of any open editor controls
+    if ( pg )
+        pg->CorrectEditorWidgetPosY();
+}
+
+// -----------------------------------------------------------------------
+
 void wxPropertyGridInterface::SetPropertyLabel( wxPGPropArg id, const wxString& newproplabel )
 {
     wxPG_PROP_ARG_CALL_PROLOG()
@@ -739,6 +655,60 @@ bool wxPropertyGridInterface::SetPropertyMaxLength( wxPGPropArg id, int maxLen )
     return true;
 }
 
+// -----------------------------------------------------------------------
+
+void
+wxPropertyGridInterface::SetPropertyBackgroundColour( wxPGPropArg id,
+                                                      const wxColour& colour,
+                                                      int flags )
+{
+    wxPG_PROP_ARG_CALL_PROLOG()
+    p->SetBackgroundColour(colour, flags);
+    RefreshProperty(p);
+}
+
+// -----------------------------------------------------------------------
+
+void wxPropertyGridInterface::SetPropertyTextColour( wxPGPropArg id,
+                                                     const wxColour& colour,
+                                                     int flags )
+{
+    wxPG_PROP_ARG_CALL_PROLOG()
+    p->SetTextColour(colour, flags);
+    RefreshProperty(p);
+}
+
+// -----------------------------------------------------------------------
+
+void wxPropertyGridInterface::SetPropertyColoursToDefault( wxPGPropArg id )
+{
+    wxPG_PROP_ARG_CALL_PROLOG()
+
+    p->m_cells.clear();
+}
+
+// -----------------------------------------------------------------------
+
+void wxPropertyGridInterface::SetPropertyCell( wxPGPropArg id,
+                                               int column,
+                                               const wxString& text,
+                                               const wxBitmap& bitmap,
+                                               const wxColour& fgCol,
+                                               const wxColour& bgCol )
+{
+    wxPG_PROP_ARG_CALL_PROLOG()
+
+    wxPGCell& cell = p->GetCell(column);
+    if ( !text.empty() && text != wxPG_LABEL )
+        cell.SetText(text);
+    if ( bitmap.IsOk() )
+        cell.SetBitmap(bitmap);
+    if ( fgCol != wxNullColour )
+        cell.SetFgCol(fgCol);
+    if ( bgCol != wxNullColour )
+        cell.SetBgCol(bgCol);
+}
+
 // -----------------------------------------------------------------------
 // GetPropertyValueAsXXX methods
 
@@ -780,7 +750,6 @@ bool wxPropertyGridInterface::GetPropertyValueAsBool( wxPGPropArg id ) const
 
 IMPLEMENT_GET_VALUE(long,long,Long,0)
 IMPLEMENT_GET_VALUE(double,double,Double,0.0)
-IMPLEMENT_GET_VALUE(void,void*,VoidPtr,NULL)
 
 bool wxPropertyGridInterface::IsPropertyExpanded( wxPGPropArg id ) const
 {
@@ -874,14 +843,17 @@ wxString wxPropertyGridInterface::SaveEditableState( int includedStates ) const
 
     //
     // Save state on page basis
-    size_t pageIndex = 0;
-    wxPropertyGridPageState* pageState = GetPageState(pageIndex);
+    unsigned int pageIndex = 0;
     wxArrayPtrVoid pageStates;
-    while ( pageState )
+
+    for (;;)
     {
-        pageStates.Add(pageState);
-        pageIndex += 1;
-        pageState = GetPageState(pageIndex);
+        wxPropertyGridPageState* page = GetPageState(pageIndex);
+        if ( !page ) break;
+
+        pageStates.Add(page);
+
+        pageIndex++;
     }
 
     for ( pageIndex=0; pageIndex < pageStates.size(); pageIndex++ )
@@ -900,7 +872,7 @@ wxString wxPropertyGridInterface::SaveEditableState( int includedStates ) const
         if ( includedStates & ExpandedState )
         {
             wxArrayPGProperty ptrs;
-            wxPropertyGridConstIterator it = 
+            wxPropertyGridConstIterator it =
                 wxPropertyGridConstIterator( pageState,
                                              wxPG_ITERATE_ALL_PARENTS_RECURSIVELY|wxPG_ITERATE_HIDDEN,
                                              wxNullProperty );
@@ -915,7 +887,7 @@ wxString wxPropertyGridInterface::SaveEditableState( int includedStates ) const
 
                 if ( !p->HasFlag(wxPG_PROP_COLLAPSED) )
                     result += EscapeDelimiters(p->GetName());
-                    result += wxS(",");
+                result += wxS(",");
 
             }
 
@@ -949,12 +921,18 @@ wxString wxPropertyGridInterface::SaveEditableState( int includedStates ) const
             else
                 result += wxS("0;");
         }
+        if ( includedStates & DescBoxState )
+        {
+            wxVariant v = GetEditableStateItem(wxS("descboxheight"));
+            if ( !v.IsNull() )
+                result += wxString::Format(wxS("descboxheight=%i;"), (int)v.GetLong());
+        }
         result.RemoveLast();  // Remove last semicolon
         result += wxS("|");
     }
 
     // Remove last '|'
-    if ( result.length() )
+    if ( !result.empty() )
         result.RemoveLast();
 
     return result;
@@ -998,7 +976,7 @@ bool wxPropertyGridInterface::RestoreEditableState( const wxString& src, int res
                 {
                     if ( restoreStates & ExpandedState )
                     {
-                        wxPropertyGridIterator it = 
+                        wxPropertyGridIterator it =
                             wxPropertyGridIterator( pageState,
                                                     wxPG_ITERATE_ALL,
                                                     wxNullProperty );
@@ -1056,14 +1034,14 @@ bool wxPropertyGridInterface::RestoreEditableState( const wxString& src, int res
                         {
                             if ( pageState->IsDisplayed() )
                             {
-                                if ( values[0].length() )
+                                if ( !values[0].empty() )
                                     newSelection = GetPropertyByName(value);
                                 pgSelectionSet = true;
                             }
                             else
                             {
-                                if ( values[0].length() )
-                                    pageState->SetSelection(GetPropertyByName(value));
+                                if ( !values[0].empty() )
+                                    pageState->DoSetSelection(GetPropertyByName(value));
                                 else
                                     pageState->DoClearSelection();
                             }
@@ -1086,6 +1064,21 @@ bool wxPropertyGridInterface::RestoreEditableState( const wxString& src, int res
                         }
                     }
                 }
+                else if ( key == wxS("descboxheight") )
+                {
+                    if ( restoreStates & DescBoxState )
+                    {
+                        long descBoxHeight;
+                        if ( values.size() == 1 && values[0].ToLong(&descBoxHeight) )
+                        {
+                            SetEditableStateItem(wxS("descboxheight"), descBoxHeight);
+                        }
+                        else
+                        {
+                            res = false;
+                        }
+                    }
+                }
                 else
                 {
                     res = false;
@@ -1113,9 +1106,9 @@ bool wxPropertyGridInterface::RestoreEditableState( const wxString& src, int res
     if ( pgSelectionSet )
     {
         if ( newSelection )
-            pg->SelectProperty(newSelection);
+            pg->DoSelectProperty(newSelection);
         else
-            pg->ClearSelection();
+            pg->DoClearSelection();
     }
 
     if ( selectedPage != -1 )