freeze whole window for TLW

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

diff --git a/src/propgrid/property.cpp b/src/propgrid/property.cpp
index 09f4bc8ba86266680fcf094e64ff5bdba669cf2f..44dd00af8f0739045cd30450718137b879a5283b 100644 (file)
--- a/src/propgrid/property.cpp
+++ b/src/propgrid/property.cpp
@@ -135,8 +135,9 @@ int wxPGCellRenderer::PreDrawCell( wxDC& dc, const wxRect& rect, const wxPGCell&
     // If possible, use cell colours
     if ( !(flags & DontUseCellBgCol) )
     {
     // If possible, use cell colours
     if ( !(flags & DontUseCellBgCol) )
     {

-        dc.SetPen(cell.GetBgCol());
-        dc.SetBrush(cell.GetBgCol());
+        const wxColour& bgCol = cell.GetBgCol();
+        dc.SetPen(bgCol);
+        dc.SetBrush(bgCol);

     }
 
     if ( !(flags & DontUseCellFgCol) )
     }
 
     if ( !(flags & DontUseCellFgCol) )


@@ -185,10 +186,14 @@ void wxPGCellRenderer::PostDrawCell( wxDC& dc,
 // wxPGDefaultRenderer
 // -----------------------------------------------------------------------
 
 // wxPGDefaultRenderer
 // -----------------------------------------------------------------------
 

-void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
+bool wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,

                                   const wxPropertyGrid* propertyGrid, wxPGProperty* property,
                                   int column, int item, int flags ) const
 {
                                   const wxPropertyGrid* propertyGrid, wxPGProperty* property,
                                   int column, int item, int flags ) const
 {

+    const wxPGEditor* editor = NULL;
+    const wxPGCell* cell = NULL;
+
+    wxString text;

     bool isUnspecified = property->IsValueUnspecified();
 
     if ( column == 1 && item == -1 )
     bool isUnspecified = property->IsValueUnspecified();
 
     if ( column == 1 && item == -1 )


@@ -198,17 +203,19 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
         {
             // Common Value
             if ( !isUnspecified )
         {
             // Common Value
             if ( !isUnspecified )

-                DrawText( dc, rect, 0, propertyGrid->GetCommonValueLabel(cmnVal) );
-            return;
+            {
+                text = propertyGrid->GetCommonValueLabel(cmnVal);
+                DrawText( dc, rect, 0, text );
+                if ( text.length() )
+                    return true;
+            }
+            return false;

         }
     }
 
         }
     }
 

-    const wxPGEditor* editor = NULL;
-    const wxPGCell* cell = NULL;
-
-    wxString text;

     int imageWidth = 0;
     int preDrawFlags = flags;
     int imageWidth = 0;
     int preDrawFlags = flags;

+    bool res = false;

 
     property->GetDisplayInfo(column, item, flags, &text, &cell);
 
 
     property->GetDisplayInfo(column, item, flags, &text, &cell);
 


@@ -216,10 +223,10 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
 
     if ( column == 1 )
     {
 
     if ( column == 1 )
     {

+        editor = property->GetColumnEditor(column);
+

         if ( !isUnspecified )
         {
         if ( !isUnspecified )
         {

-            editor = property->GetColumnEditor(column);
-

             // Regular property value
 
             wxSize imageSize = propertyGrid->GetImageSize(property, item);
             // Regular property value
 
             wxSize imageSize = propertyGrid->GetImageSize(property, item);


@@ -258,14 +265,24 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
 
         if ( text.length() == 0 )
         {
 
         if ( text.length() == 0 )
         {

-            // Try to show inline help if no text
-            wxVariant vInlineHelp = property->GetAttribute(wxPGGlobalVars->m_strInlineHelp);
-            if ( !vInlineHelp.IsNull() )
+            text = property->GetHintText();
+            if ( text.length() > 0 )

             {
             {

-                text = vInlineHelp.GetString();
-                dc.SetTextForeground(propertyGrid->GetCellDisabledTextColour());
+                res = true;
+
+                const wxColour& hCol =
+                    propertyGrid->GetCellDisabledTextColour();
+                dc.SetTextForeground(hCol);
+
+                // Must make the editor NULL to override it's own rendering
+                // code.
+                editor = NULL;

             }
         }
             }
         }

+        else
+        {
+            res = true;
+        }

     }
 
     int imageOffset = property->GetImageOffset(imageWidth);
     }
 
     int imageOffset = property->GetImageOffset(imageWidth);


@@ -273,7 +290,7 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
     DrawEditorValue( dc, rect, imageOffset, text, property, editor );
 
     // active caption gets nice dotted rectangle
     DrawEditorValue( dc, rect, imageOffset, text, property, editor );
 
     // active caption gets nice dotted rectangle

-    if ( property->IsCategory() /*&& column == 0*/ )
+    if ( property->IsCategory() && column == 0 )

     {
         if ( flags & Selected )
         {
     {
         if ( flags & Selected )
         {


@@ -294,6 +311,8 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
     }
 
     PostDrawCell(dc, propertyGrid, *cell, preDrawFlags);
     }
 
     PostDrawCell(dc, propertyGrid, *cell, preDrawFlags);

+
+    return res;

 }
 
 wxSize wxPGDefaultRenderer::GetImageSize( const wxPGProperty* property,
 }
 
 wxSize wxPGDefaultRenderer::GetImageSize( const wxPGProperty* property,


@@ -413,6 +432,12 @@ void wxPGCell::MergeFrom( const wxPGCell& srcCell )
         data->SetBitmap(srcCell.GetBitmap());
 }
 
         data->SetBitmap(srcCell.GetBitmap());
 }
 

+void wxPGCell::SetEmptyData()
+{
+    AllocExclusive();
+}
+
+

 // -----------------------------------------------------------------------
 // wxPGProperty
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // wxPGProperty
 // -----------------------------------------------------------------------


@@ -702,8 +727,17 @@ void wxPGProperty::GetDisplayInfo( unsigned int column,
 
     if ( !(flags & wxPGCellRenderer::ChoicePopup) )
     {
 
     if ( !(flags & wxPGCellRenderer::ChoicePopup) )
     {

-        // Not painting listi of choice popups, so get text from property
-        cell = &GetCell(column);
+        // Not painting list of choice popups, so get text from property
+        if ( column != 1 || !IsValueUnspecified() || IsCategory() )
+        {
+            cell = &GetCell(column);
+        }
+        else
+        {
+            // Use special unspecified value cell
+            cell = &GetGrid()->GetUnspecifiedValueAppearance();
+        }
+

         if ( cell->HasText() )
         {
             *pString = cell->GetText();
         if ( cell->HasText() )
         {
             *pString = cell->GetText();


@@ -924,8 +958,10 @@ wxString wxPGProperty::GetValueAsString( int argFlags ) const
     }
 #endif
 
     }
 #endif
 

+    wxPropertyGrid* pg = GetGrid();
+

     if ( IsValueUnspecified() )
     if ( IsValueUnspecified() )

-        return wxEmptyString;
+        return pg->GetUnspecifiedValueText(argFlags);

 
     if ( m_commonValue == -1 )
     {
 
     if ( m_commonValue == -1 )
     {


@@ -935,7 +971,6 @@ wxString wxPGProperty::GetValueAsString( int argFlags ) const
 
     //
     // Return common value's string representation
 
     //
     // Return common value's string representation

-    wxPropertyGrid* pg = GetGrid();

     const wxPGCommonValue* cv = pg->GetCommonValue(m_commonValue);
 
     if ( argFlags & wxPG_FULL_VALUE )
     const wxPGCommonValue* cv = pg->GetCommonValue(m_commonValue);
 
     if ( argFlags & wxPG_FULL_VALUE )


@@ -1032,7 +1067,8 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
 
                     // Add only if editable or setting programmatically
                     if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
 
                     // Add only if editable or setting programmatically
                     if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||

-                         !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) )
+                         (!child->HasFlag(wxPG_PROP_DISABLED) &&
+                          !child->HasFlag(wxPG_PROP_READONLY)) )

                     {
                         if ( len > 0 )
                         {
                     {
                         if ( len > 0 )
                         {


@@ -1112,7 +1148,8 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int
                     wxVariant variant(oldChildValue);
 
                     if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
                     wxVariant variant(oldChildValue);
 
                     if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||

-                         !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) )
+                         (!child->HasFlag(wxPG_PROP_DISABLED) &&
+                          !child->HasFlag(wxPG_PROP_READONLY)) )

                     {
                         wxString childName = child->GetBaseName();
 
                     {
                         wxString childName = child->GetBaseName();
 


@@ -1366,16 +1403,23 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags )
         UpdateParentValues();
 
     //
         UpdateParentValues();
 
     //

-    // Update editor control
-    //
-
-    // We need to check for these, otherwise GetGrid() may fail.
+    // Update editor control.

     if ( flags & wxPG_SETVAL_REFRESH_EDITOR )
     {
     if ( flags & wxPG_SETVAL_REFRESH_EDITOR )
     {

-        RefreshEditor();

         wxPropertyGrid* pg = GetGridIfDisplayed();
         if ( pg )
         wxPropertyGrid* pg = GetGridIfDisplayed();
         if ( pg )

+        {
+            wxPGProperty* selected = pg->GetSelectedProperty();
+
+            // Only refresh the control if this was selected, or
+            // this was some parent of selected, or vice versa)
+            if ( selected && (selected == this ||
+                              selected->IsSomeParent(this) ||
+                              this->IsSomeParent(selected)) )
+                RefreshEditor();
+

             pg->DrawItemAndValueRelated(this);
             pg->DrawItemAndValueRelated(this);

+        }

     }
 }
 
     }
 }
 


@@ -1385,7 +1429,7 @@ void wxPGProperty::SetValueInEvent( wxVariant value ) const
     GetGrid()->ValueChangeInEvent(value);
 }
 
     GetGrid()->ValueChangeInEvent(value);
 }
 

-void wxPGProperty::SetFlagRecursively( FlagType flag, bool set )
+void wxPGProperty::SetFlagRecursively( wxPGPropertyFlags flag, bool set )

 {
     ChangeFlag(flag, set);
 
 {
     ChangeFlag(flag, set);
 


@@ -1869,6 +1913,12 @@ void wxPGProperty::SetChoiceSelection( int newValue )
 
 bool wxPGProperty::SetChoices( wxPGChoices& choices )
 {
 
 bool wxPGProperty::SetChoices( wxPGChoices& choices )
 {

+    // Property must be de-selected first (otherwise choices in
+    // the control would be de-synced with true choices)
+    wxPropertyGrid* pg = GetGrid();
+    if ( pg && pg->GetSelection() == this )
+        pg->ClearSelection();
+

     m_choices.Assign(choices);
 
     {
     m_choices.Assign(choices);
 
     {


@@ -2407,10 +2457,16 @@ void wxPGProperty::DeleteChildren()
 {
     wxPropertyGridPageState* state = m_parentState;
 
 {
     wxPropertyGridPageState* state = m_parentState;
 

-    while ( GetChildCount() )
+    if ( !GetChildCount() )
+        return;
+
+    // Because deletion is sometimes deferred, we have to use
+    // this sort of code for enumerating the child properties.
+    unsigned int i = GetChildCount();
+    while ( i > 0 )

     {
     {

-        wxPGProperty* child = Item(GetChildCount()-1);
-        state->DoDelete(child, true);
+        i--;
+        state->DoDelete(Item(i), true);

     }
 }
 
     }
 }
 


@@ -2601,9 +2657,31 @@ wxPropertyCategory::~wxPropertyCategory()
 wxString wxPropertyCategory::ValueToString( wxVariant& WXUNUSED(value),
                                             int WXUNUSED(argFlags) ) const
 {
 wxString wxPropertyCategory::ValueToString( wxVariant& WXUNUSED(value),
                                             int WXUNUSED(argFlags) ) const
 {

+    if ( m_value.GetType() == wxPG_VARIANT_TYPE_STRING )
+        return m_value.GetString();

     return wxEmptyString;
 }
 
     return wxEmptyString;
 }
 

+wxString wxPropertyCategory::GetValueAsString( int argFlags ) const
+{
+#if wxPG_COMPATIBILITY_1_4
+    // This is backwards compatibility test
+    // That is, to make sure this function is not overridden
+    // (instead, ValueToString() should be).
+    if ( argFlags == 0xFFFF )
+    {
+        // Do not override! (for backwards compliancy)
+        return g_invalidStringContent;
+    }
+#endif
+
+    // Unspecified value is always empty string
+    if ( IsValueUnspecified() )
+        return wxEmptyString;
+
+    return wxPGProperty::GetValueAsString(argFlags);
+}
+

 int wxPropertyCategory::GetTextExtent( const wxWindow* wnd, const wxFont& font ) const
 {
     if ( m_textExtent > 0 )
 int wxPropertyCategory::GetTextExtent( const wxWindow* wnd, const wxFont& font ) const
 {
     if ( m_textExtent > 0 )