missing commit

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

diff --git a/src/propgrid/propgridiface.cpp b/src/propgrid/propgridiface.cpp
index 033f06121379de33117279e8a112e258ba655555..5f66781a81ca759ddc80f4e020cd96c12f59bddc 100644 (file)
--- a/src/propgrid/propgridiface.cpp
+++ b/src/propgrid/propgridiface.cpp
@@ -6,7 +6,7 @@
 // Created:     2008-08-24
 // RCS-ID:      $Id$
 // Copyright:   (c) Jaakko Salli
 // Created:     2008-08-24
 // RCS-ID:      $Id$
 // 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".


@@ -56,173 +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(wxPoint, WXDLLIMPEXP_PROPGRID)
 WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED(wxSize, WXDLLIMPEXP_PROPGRID)
 WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED_DUMMY_EQ(wxArrayInt, WXDLLIMPEXP_PROPGRID)

-
-// For wxLongLong and wxULongLong have custom classname << variant
-// implementation for improved flexibility.
-WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED_NO_EQ_NO_GETTER(wxLongLong, WXDLLIMPEXP_PROPGRID)
-WX_PG_IMPLEMENT_VARIANT_DATA_EQ(wxLongLong, WXDLLIMPEXP_PROPGRID)
-WXDLLIMPEXP_PROPGRID wxLongLong& operator << ( wxLongLong &value, const wxVariant &variant )
-{
-    wxLongLong_t ll;
-    if ( !wxPGVariantToLongLong(variant, &ll) )
-    {
-        wxFAIL_MSG("Cannot convert to wxLongLong");
-    }
-    value = ll;
-    return value;
-}
-WXDLLIMPEXP_PROPGRID wxLongLong_t& operator << ( wxLongLong_t &value, const wxVariant &variant )
-{
-    if ( !wxPGVariantToLongLong(variant, &value) )
-    {
-        wxFAIL_MSG("Cannot convert to wxLongLong");
-    }
-    return value;
-}
-
-WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED_NO_EQ_NO_GETTER(wxULongLong, WXDLLIMPEXP_PROPGRID)
-WX_PG_IMPLEMENT_VARIANT_DATA_EQ(wxULongLong, WXDLLIMPEXP_PROPGRID)
-WXDLLIMPEXP_PROPGRID wxULongLong& operator << ( wxULongLong &value, const wxVariant &variant )
-{
-    wxULongLong_t ull;
-    if ( !wxPGVariantToULongLong(variant, &ull) )
-    {
-        wxFAIL_MSG("Cannot convert to wxULongLong");
-    }
-    value = ull;
-    return value;
-}
-WXDLLIMPEXP_PROPGRID wxULongLong_t& operator << ( wxULongLong_t &value, const wxVariant &variant )
-{
-    if ( !wxPGVariantToULongLong(variant, &value) )
-    {
-        wxFAIL_MSG("Cannot convert to wxULongLong");
-    }
-    return value;
-}
-

 IMPLEMENT_VARIANT_OBJECT_EXPORTED(wxFont, 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 )
-    {
-        // NOTE: << operator uses this functions, so we can't use it here
-        *pResult = wxLongLongRefFromVariant(variant).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 )
-    {
-        // NOTE: << operator uses this functions, so we can't use it here
-        *pResult = wxULongLongRefFromVariant(variant).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
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // wxPGPropArgCls
 // -----------------------------------------------------------------------


@@ -238,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);
         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);
     else if ( m_flags & IsWCharPtr )
         return iface->GetPropertyByNameA(m_ptr.wcharName);

-#endif

 
     return NULL;
 }
 
     return NULL;
 }


@@ -267,7 +100,7 @@ void wxPropertyGridInterface::RefreshGrid( wxPropertyGridPageState* state )
 wxPGProperty* wxPropertyGridInterface::Append( wxPGProperty* property )
 {
     wxPGProperty* retp = m_pState->DoAppend(property);
 wxPGProperty* wxPropertyGridInterface::Append( wxPGProperty* property )
 {
     wxPGProperty* retp = m_pState->DoAppend(property);

-    
+

     wxPropertyGrid* grid = m_pState->GetGrid();
     if ( grid )
         grid->RefreshGrid();
     wxPropertyGrid* grid = m_pState->GetGrid();
     if ( grid )
         grid->RefreshGrid();


@@ -312,10 +145,6 @@ void wxPropertyGridInterface::DeleteProperty( wxPGPropArg id )
     wxPG_PROP_ARG_CALL_PROLOG()
 
     wxPropertyGridPageState* state = p->GetParentState();
     wxPG_PROP_ARG_CALL_PROLOG()
 
     wxPropertyGridPageState* state = p->GetParentState();

-    wxPropertyGrid* grid = state->GetGrid();
-
-    if ( grid->GetState() == state )
-        grid->DoSelectProperty(NULL, wxPG_SEL_DELETING|wxPG_SEL_NOVALIDATE);

 
     state->DoDelete( p, true );
 
 
     state->DoDelete( p, true );
 


@@ -332,20 +161,9 @@ wxPGProperty* wxPropertyGridInterface::RemoveProperty( wxPGPropArg id )
              wxNullProperty);
 
     wxPropertyGridPageState* state = p->GetParentState();
              wxNullProperty);
 
     wxPropertyGridPageState* state = p->GetParentState();

-    wxPropertyGrid* grid = state->GetGrid();
-
-    if ( grid->GetState() == state )
-    {
-        grid->DoSelectProperty(NULL,
-            wxPG_SEL_DELETING|wxPG_SEL_NOVALIDATE);
-    }

 
     state->DoDelete( p, false );
 
 
     state->DoDelete( p, false );
 

-    // Mark the property as 'unattached'
-    p->m_parentState = NULL;
-    p->m_parent = NULL;
-

     RefreshGrid(state);
 
     return p;
     RefreshGrid(state);
 
     return p;


@@ -383,11 +201,29 @@ wxPGProperty* wxPropertyGridInterface::ReplaceProperty( wxPGPropArg id, wxPGProp
 // wxPropertyGridInterface property operations
 // -----------------------------------------------------------------------
 
 // wxPropertyGridInterface property operations
 // -----------------------------------------------------------------------
 

+wxPGProperty* wxPropertyGridInterface::GetSelection() const
+{
+    return m_pState->GetSelection();
+}
+
+// -----------------------------------------------------------------------
+

 bool wxPropertyGridInterface::ClearSelection( bool validation )
 {
 bool wxPropertyGridInterface::ClearSelection( bool validation )
 {

-    int flags = 0;
+    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 )
     if ( !validation )

-        flags |= wxPG_SEL_NOVALIDATE;
+        selFlags |= wxPG_SEL_NOVALIDATE;

 
     wxPropertyGridPageState* state = m_pState;
 
 
     wxPropertyGridPageState* state = m_pState;
 


@@ -395,9 +231,9 @@ bool wxPropertyGridInterface::ClearSelection( bool validation )
     {
         wxPropertyGrid* pg = state->GetGrid();
         if ( pg->GetState() == state )
     {
         wxPropertyGrid* pg = state->GetGrid();
         if ( pg->GetState() == state )

-            return pg->DoSelectProperty(NULL, flags);
+            return pg->DoSelectProperty(NULL, selFlags);

         else
         else

-            state->SetSelection(NULL);
+            state->DoSetSelection(NULL);

     }
 
     return true;
     }
 
     return true;


@@ -428,7 +264,7 @@ bool wxPropertyGridInterface::EnableProperty( wxPGPropArg id, bool enable )
             return false;
 
         // If active, Set active Editor.
             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
             grid->DoSelectProperty( p, wxPG_SEL_FORCE );
     }
     else


@@ -437,11 +273,11 @@ bool wxPropertyGridInterface::EnableProperty( wxPGPropArg id, bool enable )
             return false;
 
         // If active, Disable as active Editor.
             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 );
     }
 
             grid->DoSelectProperty( p, wxPG_SEL_FORCE );
     }
 

-    state->DoEnableProperty(p, enable);
+    p->DoEnable(enable);

 
     RefreshProperty( p );
 
 
     RefreshProperty( p );
 


@@ -462,7 +298,7 @@ bool wxPropertyGridInterface::ExpandAll( bool doExpand )
     if ( GetSelection() && GetSelection() != state->DoGetRoot() &&
          !doExpand )
     {
     if ( GetSelection() && GetSelection() != state->DoGetRoot() &&
          !doExpand )
     {

-        pg->ClearSelection(false);
+        pg->DoClearSelection();

     }
 
     wxPGVIterator it;
     }
 
     wxPGVIterator it;


@@ -498,18 +334,6 @@ bool wxPropertyGridInterface::ExpandAll( bool doExpand )
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 

-void wxPropertyGridInterface::SetPropertyValueUnspecified( wxPGPropArg id )
-{
-    wxPG_PROP_ARG_CALL_PROLOG()
-    wxPropertyGrid* propGrid = p->GetGridIfDisplayed();
-    if ( propGrid )
-        propGrid->DoSetPropertyValueUnspecified(p);
-    else
-        p->GetParentState()->DoSetPropertyValueUnspecified(p);
-}
-
-// -----------------------------------------------------------------------
-

 void wxPropertyGridInterface::ClearModifiedStatus()
 {
     unsigned int pageIndex = 0;
 void wxPropertyGridInterface::ClearModifiedStatus()
 {
     unsigned int pageIndex = 0;


@@ -520,6 +344,7 @@ void wxPropertyGridInterface::ClearModifiedStatus()
         if ( !page ) break;
 
         page->DoGetRoot()->SetFlagRecursively(wxPG_PROP_MODIFIED, false);
         if ( !page ) break;
 
         page->DoGetRoot()->SetFlagRecursively(wxPG_PROP_MODIFIED, false);

+        page->m_anyModified = false;

 
         pageIndex++;
     }
 
         pageIndex++;
     }


@@ -528,6 +353,17 @@ void wxPropertyGridInterface::ClearModifiedStatus()
     GetPropertyGrid()->RefreshEditor();
 }
 
     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;
+}
+

 // -----------------------------------------------------------------------
 // wxPropertyGridInterface property value setting and getting
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // wxPropertyGridInterface property value setting and getting
 // -----------------------------------------------------------------------


@@ -555,13 +391,7 @@ void wxPropertyGridInterface::SetPropVal( wxPGPropArg id, wxVariant& value )
     wxPG_PROP_ARG_CALL_PROLOG()
 
     if ( p )
     wxPG_PROP_ARG_CALL_PROLOG()
 
     if ( p )

-    {

         p->SetValue(value);
         p->SetValue(value);

-        wxPropertyGrid* propGrid = p->GetGridIfDisplayed();
-        if ( propGrid )
-            propGrid->DrawItemAndValueRelated( p );
-
-    }

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


@@ -570,12 +400,8 @@ void wxPropertyGridInterface::SetPropertyValueString( wxPGPropArg id, const wxSt
 {
     wxPG_PROP_ARG_CALL_PROLOG()
 
 {
     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);

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


@@ -762,21 +588,23 @@ bool wxPropertyGridInterface::Expand( wxPGPropArg id )
 
 // -----------------------------------------------------------------------
 
 
 // -----------------------------------------------------------------------
 

-void wxPropertyGridInterface::Sort()
+void wxPropertyGridInterface::Sort( int flags )

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

-    pg->ClearSelection(false);
-

     unsigned int pageIndex = 0;
 
     for (;;)
     {
         wxPropertyGridPageState* page = GetPageState(pageIndex);
         if ( !page ) break;
     unsigned int pageIndex = 0;
 
     for (;;)
     {
         wxPropertyGridPageState* page = GetPageState(pageIndex);
         if ( !page ) break;

-        page->DoSort();
+        page->DoSort(flags);

         pageIndex++;
     }
         pageIndex++;
     }

+
+    // Fix positions of any open editor controls
+    if ( pg )
+        pg->CorrectEditorWidgetPosY();

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


@@ -832,22 +660,22 @@ bool wxPropertyGridInterface::SetPropertyMaxLength( wxPGPropArg id, int maxLen )
 void
 wxPropertyGridInterface::SetPropertyBackgroundColour( wxPGPropArg id,
                                                       const wxColour& colour,
 void
 wxPropertyGridInterface::SetPropertyBackgroundColour( wxPGPropArg id,
                                                       const wxColour& colour,

-                                                      bool recursively )
+                                                      int flags )

 {
     wxPG_PROP_ARG_CALL_PROLOG()
 {
     wxPG_PROP_ARG_CALL_PROLOG()

-    p->SetBackgroundColour( colour, recursively );
-    RefreshProperty( p );
+    p->SetBackgroundColour(colour, flags);
+    RefreshProperty(p);

 }
 
 // -----------------------------------------------------------------------
 
 void wxPropertyGridInterface::SetPropertyTextColour( wxPGPropArg id,
                                                      const wxColour& colour,
 }
 
 // -----------------------------------------------------------------------
 
 void wxPropertyGridInterface::SetPropertyTextColour( wxPGPropArg id,
                                                      const wxColour& colour,

-                                                     bool recursively )
+                                                     int flags )

 {
     wxPG_PROP_ARG_CALL_PROLOG()
 {
     wxPG_PROP_ARG_CALL_PROLOG()

-    p->SetTextColour( colour, recursively );
-    RefreshProperty( p );
+    p->SetTextColour(colour, flags);
+    RefreshProperty(p);

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


@@ -871,7 +699,7 @@ void wxPropertyGridInterface::SetPropertyCell( wxPGPropArg id,
     wxPG_PROP_ARG_CALL_PROLOG()
 
     wxPGCell& cell = p->GetCell(column);
     wxPG_PROP_ARG_CALL_PROLOG()
 
     wxPGCell& cell = p->GetCell(column);

-    if ( text.length() && text != wxPG_LABEL )
+    if ( !text.empty() && text != wxPG_LABEL )

         cell.SetText(text);
     if ( bitmap.IsOk() )
         cell.SetBitmap(bitmap);
         cell.SetText(text);
     if ( bitmap.IsOk() )
         cell.SetBitmap(bitmap);


@@ -1044,7 +872,7 @@ wxString wxPropertyGridInterface::SaveEditableState( int includedStates ) const
         if ( includedStates & ExpandedState )
         {
             wxArrayPGProperty ptrs;
         if ( includedStates & ExpandedState )
         {
             wxArrayPGProperty ptrs;

-            wxPropertyGridConstIterator it = 
+            wxPropertyGridConstIterator it =

                 wxPropertyGridConstIterator( pageState,
                                              wxPG_ITERATE_ALL_PARENTS_RECURSIVELY|wxPG_ITERATE_HIDDEN,
                                              wxNullProperty );
                 wxPropertyGridConstIterator( pageState,
                                              wxPG_ITERATE_ALL_PARENTS_RECURSIVELY|wxPG_ITERATE_HIDDEN,
                                              wxNullProperty );


@@ -1104,7 +932,7 @@ wxString wxPropertyGridInterface::SaveEditableState( int includedStates ) const
     }
 
     // Remove last '|'
     }
 
     // Remove last '|'

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

         result.RemoveLast();
 
     return result;
         result.RemoveLast();
 
     return result;


@@ -1148,7 +976,7 @@ bool wxPropertyGridInterface::RestoreEditableState( const wxString& src, int res
                 {
                     if ( restoreStates & ExpandedState )
                     {
                 {
                     if ( restoreStates & ExpandedState )
                     {

-                        wxPropertyGridIterator it = 
+                        wxPropertyGridIterator it =

                             wxPropertyGridIterator( pageState,
                                                     wxPG_ITERATE_ALL,
                                                     wxNullProperty );
                             wxPropertyGridIterator( pageState,
                                                     wxPG_ITERATE_ALL,
                                                     wxNullProperty );


@@ -1206,14 +1034,14 @@ bool wxPropertyGridInterface::RestoreEditableState( const wxString& src, int res
                         {
                             if ( pageState->IsDisplayed() )
                             {
                         {
                             if ( pageState->IsDisplayed() )
                             {

-                                if ( values[0].length() )
+                                if ( !values[0].empty() )

                                     newSelection = GetPropertyByName(value);
                                 pgSelectionSet = true;
                             }
                             else
                             {
                                     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();
                             }
                                 else
                                     pageState->DoClearSelection();
                             }


@@ -1278,9 +1106,9 @@ bool wxPropertyGridInterface::RestoreEditableState( const wxString& src, int res
     if ( pgSelectionSet )
     {
         if ( newSelection )
     if ( pgSelectionSet )
     {
         if ( newSelection )

-            pg->SelectProperty(newSelection);
+            pg->DoSelectProperty(newSelection);

         else
         else

-            pg->ClearSelection();
+            pg->DoClearSelection();

     }
 
     if ( selectedPage != -1 )
     }
 
     if ( selectedPage != -1 )