X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/a2851207a67cf0ca12bf83611ecd6a4367d30f53..df97a4ef79613ac2f73a62601a9fa738d79c77a4:/src/propgrid/property.cpp diff --git a/src/propgrid/property.cpp b/src/propgrid/property.cpp index 53a26de39f..f878d4ddda 100644 --- a/src/propgrid/property.cpp +++ b/src/propgrid/property.cpp @@ -6,7 +6,7 @@ // Created: 2008-08-23 // RCS-ID: $Id$ // Copyright: (c) Jaakko Salli -// Licence: wxWindows license +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// // For compilers that support precompilation, includes "wx/wx.h". @@ -35,6 +35,8 @@ #include "wx/intl.h" #endif +#include "wx/image.h" + #include "wx/propgrid/propgrid.h" @@ -94,8 +96,6 @@ wxSize wxPGCellRenderer::GetImageSize( const wxPGProperty* WXUNUSED(property), void wxPGCellRenderer::DrawText( wxDC& dc, const wxRect& rect, int xOffset, const wxString& text ) const { - if ( xOffset ) - xOffset += wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2; dc.DrawText( text, rect.x+xOffset+wxPG_XBEFORETEXT, rect.y+((rect.height-dc.GetCharHeight())/2) ); @@ -106,14 +106,11 @@ void wxPGCellRenderer::DrawEditorValue( wxDC& dc, const wxRect& rect, wxPGProperty* property, const wxPGEditor* editor ) const { - if ( xOffset ) - xOffset += wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2; - int yOffset = ((rect.height-dc.GetCharHeight())/2); if ( editor ) { - wxRect rect2(rect); + wxRect rect2(rect); rect2.x += xOffset; rect2.y += yOffset; rect2.height -= yOffset; @@ -135,13 +132,14 @@ void wxPGCellRenderer::DrawCaptionSelectionRect( wxDC& dc, int x, int y, int w, int wxPGCellRenderer::PreDrawCell( wxDC& dc, const wxRect& rect, const wxPGCell& cell, int flags ) const { - int imageOffset = 0; + int imageWidth = 0; // 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) ) @@ -154,6 +152,11 @@ int wxPGCellRenderer::PreDrawCell( wxDC& dc, const wxRect& rect, const wxPGCell& if ( !(flags & (Control|ChoicePopup)) ) dc.DrawRectangle(rect); + // Use cell font, if provided + const wxFont& font = cell.GetFont(); + if ( font.IsOk() ) + dc.SetFont(font); + const wxBitmap& bmp = cell.GetBitmap(); if ( bmp.Ok() && // Do not draw oversized bitmap outside choice popup @@ -164,20 +167,35 @@ int wxPGCellRenderer::PreDrawCell( wxDC& dc, const wxRect& rect, const wxPGCell& rect.x + wxPG_CONTROL_MARGIN + wxCC_CUSTOM_IMAGE_MARGIN1, rect.y + wxPG_CUSTOM_IMAGE_SPACINGY, true ); - imageOffset = bmp.GetWidth(); + imageWidth = bmp.GetWidth(); } - return imageOffset; + return imageWidth; +} + +void wxPGCellRenderer::PostDrawCell( wxDC& dc, + const wxPropertyGrid* propGrid, + const wxPGCell& cell, + int WXUNUSED(flags) ) const +{ + // Revert font + const wxFont& font = cell.GetFont(); + if ( font.IsOk() ) + dc.SetFont(propGrid->GetFont()); } // ----------------------------------------------------------------------- // 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 wxPGEditor* editor = NULL; + const wxPGCell* cell = NULL; + + wxString text; bool isUnspecified = property->IsValueUnspecified(); if ( column == 1 && item == -1 ) @@ -187,28 +205,30 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect, { // Common Value if ( !isUnspecified ) - DrawText( dc, rect, 0, propertyGrid->GetCommonValueLabel(cmnVal) ); - return; + { + text = propertyGrid->GetCommonValueLabel(cmnVal); + DrawText( dc, rect, 0, text ); + if ( !text.empty() ) + return true; + } + return false; } } - const wxPGEditor* editor = NULL; - const wxPGCell* cell = NULL; - - wxString text; - int imageOffset = 0; + int imageWidth = 0; int preDrawFlags = flags; + bool res = false; property->GetDisplayInfo(column, item, flags, &text, &cell); - imageOffset = PreDrawCell( dc, rect, *cell, preDrawFlags ); + imageWidth = PreDrawCell( dc, rect, *cell, preDrawFlags ); if ( column == 1 ) { + editor = property->GetColumnEditor(column); + if ( !isUnspecified ) { - editor = property->GetColumnEditor(column); - // Regular property value wxSize imageSize = propertyGrid->GetImageSize(property, item); @@ -231,7 +251,7 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect, property->OnCustomPaint( dc, imageRect, paintdata ); - imageOffset = paintdata.m_drawnWidth; + imageWidth = paintdata.m_drawnWidth; } text = property->GetValueAsString(); @@ -240,32 +260,47 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect, if ( propertyGrid->GetColumnCount() <= 2 ) { wxString unitsString = property->GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString); - if ( unitsString.length() ) + if ( !unitsString.empty() ) text = wxString::Format(wxS("%s %s"), text.c_str(), unitsString.c_str() ); } } - if ( text.length() == 0 ) + if ( text.empty() ) { - // Try to show inline help if no text - wxVariant vInlineHelp = property->GetAttribute(wxPGGlobalVars->m_strInlineHelp); - if ( !vInlineHelp.IsNull() ) + text = property->GetHintText(); + if ( !text.empty() ) { - 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); + 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 ( imageOffset > 0 ) + { + imageOffset -= DEFAULT_IMAGE_OFFSET_INCREMENT; imageOffset += wxCC_CUSTOM_IMAGE_MARGIN2 + 4; + } DrawCaptionSelectionRect( dc, rect.x+wxPG_XBEFORETEXT-wxPG_CAPRECTXMARGIN+imageOffset, @@ -276,6 +311,10 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect, propertyGrid->GetFontHeight()+(wxPG_CAPRECTYMARGIN*2) ); } } + + PostDrawCell(dc, propertyGrid, *cell, preDrawFlags); + + return res; } wxSize wxPGDefaultRenderer::GetImageSize( const wxPGProperty* property, @@ -362,6 +401,13 @@ void wxPGCell::SetFgCol( const wxColour& col ) GetData()->SetFgCol(col); } +void wxPGCell::SetFont( const wxFont& font ) +{ + AllocExclusive(); + + GetData()->SetFont(font); +} + void wxPGCell::SetBgCol( const wxColour& col ) { AllocExclusive(); @@ -388,6 +434,12 @@ void wxPGCell::MergeFrom( const wxPGCell& srcCell ) data->SetBitmap(srcCell.GetBitmap()); } +void wxPGCell::SetEmptyData() +{ + AllocExclusive(); +} + + // ----------------------------------------------------------------------- // wxPGProperty // ----------------------------------------------------------------------- @@ -402,16 +454,16 @@ void wxPGProperty::Init() m_arrIndex = 0xFFFF; m_parent = NULL; - m_parentState = (wxPropertyGridPageState*) NULL; + m_parentState = NULL; m_clientData = NULL; m_clientObject = NULL; - m_customEditor = (wxPGEditor*) NULL; + m_customEditor = NULL; #if wxUSE_VALIDATORS - m_validator = (wxValidator*) NULL; + m_validator = NULL; #endif - m_valueBitmap = (wxBitmap*) NULL; + m_valueBitmap = NULL; m_maxLen = 0; // infinite maximum length @@ -449,6 +501,23 @@ void wxPGProperty::InitAfterAdded( wxPropertyGridPageState* pageState, wxPGProperty* parent = m_parent; bool parentIsRoot = parent->IsKindOf(CLASSINFO(wxPGRootProperty)); + // + // Convert invalid cells to default ones in this grid + for ( unsigned int i=0; iGetPropertyDefaultCell(); + const wxPGCell& catDefCell = propgrid->GetCategoryDefaultCell(); + + if ( !HasFlag(wxPG_PROP_CATEGORY) ) + cell = propDefCell; + else + cell = catDefCell; + } + } + m_parentState = pageState; #if wxPG_COMPATIBILITY_1_4 @@ -539,10 +608,12 @@ void wxPGProperty::InitAfterAdded( wxPropertyGridPageState* pageState, if ( GetChildCount() ) { // Check parental flags - wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS), - "Call SetFlag(wxPG_PROP_MISC_PARENT) or" - "SetFlag(wxPG_PROP_AGGREGATE) before calling" - "wxPGProperty::AddChild()." ); + wxASSERT_MSG( ((m_flags & wxPG_PROP_PARENTAL_FLAGS) == + wxPG_PROP_AGGREGATE) || + ((m_flags & wxPG_PROP_PARENTAL_FLAGS) == + wxPG_PROP_MISC_PARENT), + "wxPGProperty parental flags set incorrectly at " + "this time" ); if ( HasFlag(wxPG_PROP_AGGREGATE) ) { @@ -569,6 +640,27 @@ void wxPGProperty::InitAfterAdded( wxPropertyGridPageState* pageState, } } +void wxPGProperty::OnDetached(wxPropertyGridPageState* WXUNUSED(state), + wxPropertyGrid* propgrid) +{ + if ( propgrid ) + { + const wxPGCell& propDefCell = propgrid->GetPropertyDefaultCell(); + const wxPGCell& catDefCell = propgrid->GetCategoryDefaultCell(); + + // Make default cells invalid + for ( unsigned int i=0; iSetPropertyName(this, newName); + else + DoSetName(newName); +} wxString wxPGProperty::GetName() const { wxPGProperty* parent = GetParent(); - if ( !m_name.length() || !parent || parent->IsCategory() || parent->IsRoot() ) + if ( m_name.empty() || !parent || parent->IsCategory() || parent->IsRoot() ) return m_name; return m_parent->GetName() + wxS(".") + m_name; @@ -631,18 +732,7 @@ wxPropertyGrid* wxPGProperty::GetGrid() const int wxPGProperty::Index( const wxPGProperty* p ) const { - for ( unsigned int i = 0; iUpdateControl(this, primary); + return wxPGFindInVector(m_children, p); } bool wxPGProperty::ValidateValue( wxVariant& WXUNUSED(value), wxPGValidationInfo& WXUNUSED(validationInfo) ) const @@ -658,6 +748,10 @@ void wxPGProperty::RefreshChildren () { } +void wxPGProperty::OnValidationFailure( wxVariant& WXUNUSED(pendingValue) ) +{ +} + void wxPGProperty::GetDisplayInfo( unsigned int column, int choiceIndex, int flags, @@ -668,8 +762,17 @@ void wxPGProperty::GetDisplayInfo( unsigned int column, 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(); @@ -712,7 +815,7 @@ void wxPGProperty::GetDisplayInfo( unsigned int column, /* wxString wxPGProperty::GetColumnText( unsigned int col, int choiceIndex ) const { - + if ( col != 1 || choiceIndex == wxNOT_FOUND ) { const wxPGCell& cell = GetCell(col); @@ -818,12 +921,12 @@ void wxPGProperty::DoGenerateComposedValue( wxString& text, argFlags|wxPG_COMPOSITE_FRAGMENT); } } - + if ( childResults && curChild->GetChildCount() ) (*childResults)[curChild->GetName()] = s; bool skip = false; - if ( (argFlags & wxPG_UNEDITABLE_COMPOSITE_FRAGMENT) && !s.length() ) + if ( (argFlags & wxPG_UNEDITABLE_COMPOSITE_FRAGMENT) && s.empty() ) skip = true; if ( !curChild->GetChildCount() || skip ) @@ -890,8 +993,10 @@ wxString wxPGProperty::GetValueAsString( int argFlags ) const } #endif + wxPropertyGrid* pg = GetGrid(); + if ( IsValueUnspecified() ) - return wxEmptyString; + return pg->GetUnspecifiedValueText(argFlags); if ( m_commonValue == -1 ) { @@ -901,7 +1006,6 @@ wxString wxPGProperty::GetValueAsString( int argFlags ) const // // Return common value's string representation - wxPropertyGrid* pg = GetGrid(); const wxPGCommonValue* cv = pg->GetCommonValue(m_commonValue); if ( argFlags & wxPG_FULL_VALUE ) @@ -959,14 +1063,8 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int int propagatedFlags = argFlags & (wxPG_REPORT_ERROR|wxPG_PROGRAMMATIC_VALUE); -#ifdef __WXDEBUG__ - bool debug_print = false; -#endif - -#ifdef __WXDEBUG__ - if ( debug_print ) - wxLogDebug(wxT(">> %s.StringToValue('%s')"),GetLabel().c_str(),text.c_str()); -#endif + wxLogTrace("propgrid", + wxT(">> %s.StringToValue('%s')"), GetLabel(), text); wxString::const_iterator it = text.begin(); wxUniChar a; @@ -978,6 +1076,11 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int for ( ;; ) { + // How many units we iterate string forward at the end of loop? + // We need to keep track of this or risk going to negative + // with it-- operation. + unsigned int strPosIncrement = 1; + if ( tokenStart != 0xFFFFFF ) { // Token is running @@ -991,21 +1094,31 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int { const wxPGProperty* child = Item(curChild); wxVariant variant(child->GetValue()); - variant.SetName(child->GetBaseName()); + wxString childName = child->GetBaseName(); - #ifdef __WXDEBUG__ - if ( debug_print ) - wxLogDebug(wxT("token = '%s', child = %s"),token.c_str(),child->GetLabel().c_str()); - #endif + wxLogTrace("propgrid", + wxT("token = '%s', child = %s"), + token, childName); // 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 ( child->StringToValue(variant, token, propagatedFlags|wxPG_COMPOSITE_FRAGMENT) ) + if ( child->StringToValue(variant, token, + propagatedFlags|wxPG_COMPOSITE_FRAGMENT) ) { + // We really need to set the variant's name + // *after* child->StringToValue() has been + // called, since variant's value may be set by + // assigning another variant into it, which + // then usually causes name to be copied (ie. + // usually cleared) as well. wxBoolProperty + // being case in point with its use of + // wxPGVariant_Bool macro as an optimization. + variant.SetName(childName); list.Append(variant); changed = true; @@ -1015,6 +1128,7 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int { // Empty, becomes unspecified variant.MakeNull(); + variant.SetName(childName); list.Append(variant); changed = true; } @@ -1060,7 +1174,7 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int token = text.substr(startPos,pos-startPos-1); - if ( !token.length() ) + if ( token.empty() ) break; const wxPGProperty* child = Item(curChild); @@ -1069,25 +1183,26 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int 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)) ) { - bool stvRes = child->StringToValue( variant, token, propagatedFlags ); + wxString childName = child->GetBaseName(); + + bool stvRes = child->StringToValue( variant, token, + propagatedFlags ); if ( stvRes || (variant != oldChildValue) ) { - if ( stvRes ) - changed = true; + variant.SetName(childName); + list.Append(variant); + + changed = true; } else { - // Failed, becomes unspecified - variant.MakeNull(); - changed = true; + // No changes... } } - variant.SetName(child->GetBaseName()); - list.Append(variant); - curChild++; if ( curChild >= iMax ) break; @@ -1101,10 +1216,7 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int tokenStart = pos; if ( a == delimeter ) - { - pos--; - --it; - } + strPosIncrement -= 1; } } } @@ -1112,7 +1224,8 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int if ( a == 0 ) break; - ++it; + it += strPosIncrement; + if ( it != text.end() ) { a = *it; @@ -1121,7 +1234,8 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int { a = 0; } - pos++; + + pos += strPosIncrement; } if ( changed ) @@ -1156,6 +1270,22 @@ wxSize wxPGProperty::OnMeasureImage( int WXUNUSED(item) ) const return wxSize(0,0); } +int wxPGProperty::GetImageOffset( int imageWidth ) const +{ + int imageOffset = 0; + + if ( imageWidth ) + { + // Do not increment offset too much for wide images + if ( imageWidth <= (wxPG_CUSTOM_IMAGE_WIDTH+5) ) + imageOffset = imageWidth + DEFAULT_IMAGE_OFFSET_INCREMENT; + else + imageOffset = imageWidth + 1; + } + + return imageOffset; +} + wxPGCellRenderer* wxPGProperty::GetCellRenderer( int WXUNUSED(column) ) const { return wxPGGlobalVars->m_defaultRenderer; @@ -1269,15 +1399,18 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags ) } i++; } + + // Always call OnSetValue() for a parent property (do not call it + // here if the value is non-null because it will then be called + // below) + if ( value.IsNull() ) + OnSetValue(); } if ( !value.IsNull() ) { m_value = value; OnSetValue(); - - if ( !(flags & wxPG_SETVAL_FROM_PARENT) ) - UpdateParentValues(); } if ( flags & wxPG_SETVAL_BY_USER ) @@ -1307,13 +1440,28 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags ) } } - // - // Update editor control - // + if ( !(flags & wxPG_SETVAL_FROM_PARENT) ) + UpdateParentValues(); - // We need to check for these, otherwise GetGrid() may fail. + // + // Update editor control. if ( flags & wxPG_SETVAL_REFRESH_EDITOR ) - RefreshEditor(); + { + 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); + } + } } @@ -1322,12 +1470,9 @@ void wxPGProperty::SetValueInEvent( wxVariant value ) const GetGrid()->ValueChangeInEvent(value); } -void wxPGProperty::SetFlagRecursively( FlagType flag, bool set ) +void wxPGProperty::SetFlagRecursively( wxPGPropertyFlags flag, bool set ) { - if ( set ) - SetFlag(flag); - else - ClearFlag(flag); + ChangeFlag(flag, set); unsigned int i; for ( i = 0; i < GetChildCount(); i++ ) @@ -1336,22 +1481,17 @@ void wxPGProperty::SetFlagRecursively( FlagType flag, bool set ) void wxPGProperty::RefreshEditor() { - if ( m_parent && GetParentState() ) - { - wxPropertyGrid* pg = GetParentState()->GetGrid(); - if ( pg->GetSelectedProperty() == this ) - { - wxWindow* editor = pg->GetEditorControl(); - if ( editor ) - GetEditorClass()->UpdateControl( this, editor ); - } - } -} + if ( !m_parent ) + return; + wxPropertyGrid* pg = GetGrid(); + if ( pg && pg->GetSelectedProperty() == this ) + pg->RefreshEditor(); +} wxVariant wxPGProperty::GetDefaultValue() const { - wxVariant defVal = GetAttribute(wxS("DefaultValue")); + wxVariant defVal = GetAttribute(wxPG_ATTR_DEFAULT_VALUE); if ( !defVal.IsNull() ) return defVal; @@ -1392,6 +1532,31 @@ wxVariant wxPGProperty::GetDefaultValue() const return wxVariant(); } +void wxPGProperty::Enable( bool enable ) +{ + wxPropertyGrid* pg = GetGrid(); + + // Preferably call the version in the owning wxPropertyGrid, + // since it handles the editor de-activation. + if ( pg ) + pg->EnableProperty(this, enable); + else + DoEnable(enable); +} + +void wxPGProperty::DoEnable( bool enable ) +{ + if ( enable ) + ClearFlag(wxPG_PROP_DISABLED); + else + SetFlag(wxPG_PROP_DISABLED); + + // Apply same to sub-properties as well + unsigned int i; + for ( i = 0; i < GetChildCount(); i++ ) + Item(i)->DoEnable( enable ); +} + void wxPGProperty::EnsureCells( unsigned int column ) { if ( column >= m_cells.size() ) @@ -1400,10 +1565,17 @@ void wxPGProperty::EnsureCells( unsigned int column ) wxPropertyGrid* pg = GetGrid(); wxPGCell defaultCell; - if ( !HasFlag(wxPG_PROP_CATEGORY) ) - defaultCell = pg->GetPropertyDefaultCell(); - else - defaultCell = pg->GetCategoryDefaultCell(); + if ( pg ) + { + // Work around possible VC6 bug by using intermediate variables + const wxPGCell& propDefCell = pg->GetPropertyDefaultCell(); + const wxPGCell& catDefCell = pg->GetCategoryDefaultCell(); + + if ( !HasFlag(wxPG_PROP_CATEGORY) ) + defaultCell = propDefCell; + else + defaultCell = catDefCell; + } // TODO: Replace with resize() call unsigned int cellCountMax = column+1; @@ -1481,16 +1653,17 @@ const wxPGCell& wxPGProperty::GetCell( unsigned int column ) const return pg->GetPropertyDefaultCell(); } -wxPGCell& wxPGProperty::GetCell( unsigned int column ) +wxPGCell& wxPGProperty::GetOrCreateCell( unsigned int column ) { EnsureCells(column); return m_cells[column]; } void wxPGProperty::SetBackgroundColour( const wxColour& colour, - bool recursively ) + int flags ) { wxPGProperty* firstProp = this; + bool recursively = flags & wxPG_RECURSE ? true : false; // // If category is tried to set recursively, skip it and only @@ -1523,9 +1696,10 @@ void wxPGProperty::SetBackgroundColour( const wxColour& colour, } void wxPGProperty::SetTextColour( const wxColour& colour, - bool recursively ) + int flags ) { wxPGProperty* firstProp = this; + bool recursively = flags & wxPG_RECURSE ? true : false; // // If category is tried to set recursively, skip it and only @@ -1613,18 +1787,20 @@ long wxPGProperty::GetAttributeAsLong( const wxString& name, long defVal ) const { wxVariant variant = m_attributes.FindValue(name); - return wxPGVariantToInt(variant, defVal); + if ( variant.IsNull() ) + return defVal; + + return variant.GetLong(); } double wxPGProperty::GetAttributeAsDouble( const wxString& name, double defVal ) const { - double retVal; wxVariant variant = m_attributes.FindValue(name); - if ( wxPGVariantToDouble(variant, &retVal) ) - return retVal; + if ( variant.IsNull() ) + return defVal; - return defVal; + return variant.GetDouble(); } wxVariant wxPGProperty::GetAttributesAsList() const @@ -1644,7 +1820,7 @@ wxVariant wxPGProperty::GetAttributesAsList() const // Slots of utility flags are NULL const unsigned int gs_propFlagToStringSize = 14; -static const wxChar* gs_propFlagToString[gs_propFlagToStringSize] = { +static const wxChar* const gs_propFlagToString[gs_propFlagToStringSize] = { NULL, wxT("DISABLED"), wxT("HIDDEN"), @@ -1674,7 +1850,7 @@ wxString wxPGProperty::GetFlagsAsString( FlagType flagsMask ) const { const wxChar* fs = gs_propFlagToString[i]; wxASSERT(fs); - if ( s.length() ) + if ( !s.empty() ) s << wxS("|"); s << fs; } @@ -1706,7 +1882,7 @@ void wxPGProperty::SetFlagsFromString( const wxString& str ) wxValidator* wxPGProperty::DoGetValidator() const { - return (wxValidator*) NULL; + return NULL; } int wxPGProperty::InsertChoice( const wxString& label, int index, int value ) @@ -1804,8 +1980,14 @@ void wxPGProperty::SetChoiceSelection( int newValue ) } } -bool wxPGProperty::SetChoices( wxPGChoices& choices ) +bool wxPGProperty::SetChoices( const 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); { @@ -1849,6 +2031,32 @@ const wxPGEditor* wxPGProperty::GetEditorClass() const return editor; } +bool wxPGProperty::Hide( bool hide, int flags ) +{ + wxPropertyGrid* pg = GetGrid(); + if ( pg ) + return pg->HideProperty(this, hide, flags); + + return DoHide( hide, flags ); +} + +bool wxPGProperty::DoHide( bool hide, int flags ) +{ + if ( !hide ) + ClearFlag( wxPG_PROP_HIDDEN ); + else + SetFlag( wxPG_PROP_HIDDEN ); + + if ( flags & wxPG_RECURSE ) + { + unsigned int i; + for ( i = 0; i < GetChildCount(); i++ ) + Item(i)->DoHide(hide, flags | wxPG_RECURSE_STARTS); + } + + return true; +} + bool wxPGProperty::HasVisibleChildren() const { unsigned int i; @@ -1889,22 +2097,25 @@ void wxPGProperty::SetValueImage( wxBitmap& bmp ) wxSize maxSz = GetGrid()->GetImageSize(); wxSize imSz(bmp.GetWidth(),bmp.GetHeight()); - if ( imSz.x != maxSz.x || imSz.y != maxSz.y ) + if ( imSz.y != maxSz.y ) { - // Create a memory DC + #if wxUSE_IMAGE + // Here we use high-quality wxImage scaling functions available + wxImage img = bmp.ConvertToImage(); + double scaleY = (double)maxSz.y / (double)imSz.y; + img.Rescale(((double)bmp.GetWidth())*scaleY, + ((double)bmp.GetHeight())*scaleY, + wxIMAGE_QUALITY_HIGH); + wxBitmap* bmpNew = new wxBitmap(img, 32); + #else + // This is the old, deprecated method of scaling the image wxBitmap* bmpNew = new wxBitmap(maxSz.x,maxSz.y,bmp.GetDepth()); - wxMemoryDC dc; dc.SelectObject(*bmpNew); - - // Scale - // FIXME: This is ugly - use image or wait for scaling patch. - double scaleX = (double)maxSz.x / (double)imSz.x; double scaleY = (double)maxSz.y / (double)imSz.y; - - dc.SetUserScale(scaleX,scaleY); - - dc.DrawBitmap( bmp, 0, 0 ); + dc.SetUserScale(scaleY, scaleY); + dc.DrawBitmap(bmp, 0, 0); + #endif m_valueBitmap = bmpNew; } @@ -1968,6 +2179,8 @@ bool wxPGProperty::IsVisible() const wxPropertyGrid* wxPGProperty::GetGridIfDisplayed() const { wxPropertyGridPageState* state = GetParentState(); + if ( !state ) + return NULL; wxPropertyGrid* propGrid = state->GetGrid(); if ( state == propGrid->GetState() ) return propGrid; @@ -2003,7 +2216,8 @@ int wxPGProperty::GetY() const } // This is used by Insert etc. -void wxPGProperty::AddChild2( wxPGProperty* prop, int index, bool correct_mode ) +void wxPGProperty::DoAddChild( wxPGProperty* prop, int index, + bool correct_mode ) { if ( index < 0 || (size_t)index >= m_children.size() ) { @@ -2019,14 +2233,15 @@ void wxPGProperty::AddChild2( wxPGProperty* prop, int index, bool correct_mode ) prop->m_parent = this; } -// This is used by properties that have fixed sub-properties -void wxPGProperty::AddChild( wxPGProperty* prop ) +void wxPGProperty::DoPreAddChild( int index, wxPGProperty* prop ) { wxASSERT_MSG( prop->GetBaseName().length(), - "Property's children must have unique, non-empty names within their scope" ); + "Property's children must have unique, non-empty " + "names within their scope" ); - prop->m_arrIndex = m_children.size(); - m_children.push_back( prop ); + prop->m_arrIndex = index; + m_children.insert( m_children.begin()+index, + prop ); int custImgHeight = prop->OnMeasureImage().y; if ( custImgHeight < 0 /*|| custImgHeight > 1*/ ) @@ -2035,6 +2250,52 @@ void wxPGProperty::AddChild( wxPGProperty* prop ) prop->m_parent = this; } +void wxPGProperty::AddPrivateChild( wxPGProperty* prop ) +{ + if ( !(m_flags & wxPG_PROP_PARENTAL_FLAGS) ) + SetParentalType(wxPG_PROP_AGGREGATE); + + wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS) == + wxPG_PROP_AGGREGATE, + "Do not mix up AddPrivateChild() calls with other " + "property adders." ); + + DoPreAddChild( m_children.size(), prop ); +} + +#if wxPG_COMPATIBILITY_1_4 +void wxPGProperty::AddChild( wxPGProperty* prop ) +{ + AddPrivateChild(prop); +} +#endif + +wxPGProperty* wxPGProperty::InsertChild( int index, + wxPGProperty* childProperty ) +{ + if ( index < 0 ) + index = m_children.size(); + + if ( m_parentState ) + { + m_parentState->DoInsert(this, index, childProperty); + } + else + { + if ( !(m_flags & wxPG_PROP_PARENTAL_FLAGS) ) + SetParentalType(wxPG_PROP_MISC_PARENT); + + wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS) == + wxPG_PROP_MISC_PARENT, + "Do not mix up AddPrivateChild() calls with other " + "property adders." ); + + DoPreAddChild( index, childProperty ); + } + + return childProperty; +} + void wxPGProperty::RemoveChild( wxPGProperty* p ) { wxArrayPGProperty::iterator it; @@ -2044,7 +2305,7 @@ void wxPGProperty::RemoveChild( wxPGProperty* p ) { if ( *it == p ) { - m_children.erase(it); + children.erase(it); break; } } @@ -2071,9 +2332,9 @@ void wxPGProperty::AdaptListToValue( wxVariant& list, wxVariant* value ) const else allChildrenSpecified = true; - wxVariant childValue = list[0]; unsigned int i; unsigned int n = 0; + wxVariant childValue = list[n]; //wxLogDebug(wxT(">> %s.AdaptListToValue()"),GetBaseName().c_str()); @@ -2093,7 +2354,10 @@ void wxPGProperty::AdaptListToValue( wxVariant& list, wxVariant* value ) const } if ( allChildrenSpecified ) - ChildChanged(*value, i, childValue); + { + *value = ChildChanged(*value, i, childValue); + } + n++; if ( n == (unsigned int)list.GetCount() ) break; @@ -2126,7 +2390,7 @@ wxPGProperty* wxPGProperty::GetPropertyByName( const wxString& name ) const // Does it have point, then? int pos = name.Find(wxS('.')); if ( pos <= 0 ) - return (wxPGProperty*) NULL; + return NULL; wxPGProperty* p = GetPropertyByName(name. substr(0,pos)); @@ -2204,7 +2468,9 @@ int wxPGProperty::GetChildrenHeight( int lh, int iMax_ ) const return h; } -wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y, unsigned int lh, unsigned int* nextItemY ) const +wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y, + unsigned int lh, + unsigned int* nextItemY ) const { wxASSERT( nextItemY ); @@ -2254,9 +2520,13 @@ wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y, unsigned int lh, unsigne /* if ( current ) + { wxLogDebug(wxT("%s::GetItemAtY(%i) -> %s"),this->GetLabel().c_str(),y,current->GetLabel().c_str()); + } else + { wxLogDebug(wxT("%s::GetItemAtY(%i) -> NULL"),this->GetLabel().c_str(),y); + } */ return (wxPGProperty*) result; @@ -2276,10 +2546,34 @@ void wxPGProperty::Empty() m_children.clear(); } -void wxPGProperty::ChildChanged( wxVariant& WXUNUSED(thisValue), - int WXUNUSED(childIndex), - wxVariant& WXUNUSED(childValue) ) const +wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y ) const +{ + unsigned int nextItem; + return GetItemAtY( y, GetGrid()->GetRowHeight(), &nextItem); +} + +void wxPGProperty::DeleteChildren() { + wxPropertyGridPageState* state = m_parentState; + + 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 ) + { + i--; + state->DoDelete(Item(i), true); + } +} + +wxVariant wxPGProperty::ChildChanged( wxVariant& WXUNUSED(thisValue), + int WXUNUSED(childIndex), + wxVariant& WXUNUSED(childValue) ) const +{ + return wxNullVariant; } bool wxPGProperty::AreAllChildrenSpecified( wxVariant* pendingList ) const @@ -2384,7 +2678,7 @@ void wxPGProperty::SubPropsChanged( int oldSelInd ) child->InitAfterAdded(state, grid); } - wxPGProperty* sel = (wxPGProperty*) NULL; + wxPGProperty* sel = NULL; if ( oldSelInd >= (int)m_children.size() ) oldSelInd = (int)m_children.size() - 1; @@ -2410,12 +2704,11 @@ WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxPGRootProperty,none,TextCtrl) IMPLEMENT_DYNAMIC_CLASS(wxPGRootProperty, wxPGProperty) -wxPGRootProperty::wxPGRootProperty() +wxPGRootProperty::wxPGRootProperty( const wxString& name ) : wxPGProperty() { -#ifdef __WXDEBUG__ - m_name = wxS(""); -#endif + m_name = name; + m_label = m_name; SetParentalType(0); m_depth = 0; } @@ -2463,25 +2756,311 @@ wxPropertyCategory::~wxPropertyCategory() wxString wxPropertyCategory::ValueToString( wxVariant& WXUNUSED(value), int WXUNUSED(argFlags) ) const { + if ( m_value.GetType() == wxPG_VARIANT_TYPE_STRING ) + return m_value.GetString(); 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 ) return m_textExtent; int x = 0, y = 0; - ((wxWindow*)wnd)->GetTextExtent( m_label, &x, &y, 0, 0, &font ); + ((wxWindow*)wnd)->GetTextExtent( m_label, &x, &y, 0, 0, &font ); return x; } void wxPropertyCategory::CalculateTextExtent( wxWindow* wnd, const wxFont& font ) { int x = 0, y = 0; - wnd->GetTextExtent( m_label, &x, &y, 0, 0, &font ); + wnd->GetTextExtent( m_label, &x, &y, 0, 0, &font ); m_textExtent = x; } +// ----------------------------------------------------------------------- +// wxPGChoices +// ----------------------------------------------------------------------- + +wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, int value ) +{ + AllocExclusive(); + + wxPGChoiceEntry entry(label, value); + return m_data->Insert( -1, entry ); +} + +// ----------------------------------------------------------------------- + +wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, const wxBitmap& bitmap, int value ) +{ + AllocExclusive(); + + wxPGChoiceEntry entry(label, value); + entry.SetBitmap(bitmap); + return m_data->Insert( -1, entry ); +} + +// ----------------------------------------------------------------------- + +wxPGChoiceEntry& wxPGChoices::Insert( const wxPGChoiceEntry& entry, int index ) +{ + AllocExclusive(); + + return m_data->Insert( index, entry ); +} + +// ----------------------------------------------------------------------- + +wxPGChoiceEntry& wxPGChoices::Insert( const wxString& label, int index, int value ) +{ + AllocExclusive(); + + wxPGChoiceEntry entry(label, value); + return m_data->Insert( index, entry ); +} + +// ----------------------------------------------------------------------- + +wxPGChoiceEntry& wxPGChoices::AddAsSorted( const wxString& label, int value ) +{ + AllocExclusive(); + + size_t index = 0; + + while ( index < GetCount() ) + { + int cmpRes = GetLabel(index).Cmp(label); + if ( cmpRes > 0 ) + break; + index++; + } + + wxPGChoiceEntry entry(label, value); + return m_data->Insert( index, entry ); +} + +// ----------------------------------------------------------------------- + +void wxPGChoices::Add( const wxChar* const* labels, const ValArrItem* values ) +{ + AllocExclusive(); + + unsigned int itemcount = 0; + const wxChar* const* p = &labels[0]; + while ( *p ) { p++; itemcount++; } + + unsigned int i; + for ( i = 0; i < itemcount; i++ ) + { + int value = i; + if ( values ) + value = values[i]; + wxPGChoiceEntry entry(labels[i], value); + m_data->Insert( i, entry ); + } +} + +// ----------------------------------------------------------------------- + +void wxPGChoices::Add( const wxArrayString& arr, const wxArrayInt& arrint ) +{ + AllocExclusive(); + + unsigned int i; + unsigned int itemcount = arr.size(); + + for ( i = 0; i < itemcount; i++ ) + { + int value = i; + if ( &arrint && arrint.size() ) + value = arrint[i]; + wxPGChoiceEntry entry(arr[i], value); + m_data->Insert( i, entry ); + } +} + +// ----------------------------------------------------------------------- + +void wxPGChoices::RemoveAt(size_t nIndex, size_t count) +{ + AllocExclusive(); + + wxASSERT( m_data->GetRefCount() != -1 ); + m_data->m_items.erase(m_data->m_items.begin()+nIndex, + m_data->m_items.begin()+nIndex+count); +} + +// ----------------------------------------------------------------------- + +void wxPGChoices::Clear() +{ + if ( m_data != wxPGChoicesEmptyData ) + { + AllocExclusive(); + m_data->Clear(); + } +} + +// ----------------------------------------------------------------------- + +int wxPGChoices::Index( const wxString& str ) const +{ + if ( IsOk() ) + { + unsigned int i; + for ( i=0; i< m_data->GetCount(); i++ ) + { + const wxPGChoiceEntry& entry = m_data->Item(i); + if ( entry.HasText() && entry.GetText() == str ) + return i; + } + } + return -1; +} + +// ----------------------------------------------------------------------- + +int wxPGChoices::Index( int val ) const +{ + if ( IsOk() ) + { + unsigned int i; + for ( i=0; i< m_data->GetCount(); i++ ) + { + const wxPGChoiceEntry& entry = m_data->Item(i); + if ( entry.GetValue() == val ) + return i; + } + } + return -1; +} + +// ----------------------------------------------------------------------- + +wxArrayString wxPGChoices::GetLabels() const +{ + wxArrayString arr; + unsigned int i; + + if ( this && IsOk() ) + for ( i=0; i= 0 ) + arr.Add(GetValue(index)); + else + arr.Add(wxPG_INVALID_VALUE); + } + } + + return arr; +} + +// ----------------------------------------------------------------------- + +wxArrayInt wxPGChoices::GetIndicesForStrings( const wxArrayString& strings, + wxArrayString* unmatched ) const +{ + wxArrayInt arr; + + if ( IsOk() ) + { + unsigned int i; + for ( i=0; i< strings.size(); i++ ) + { + const wxString& str = strings[i]; + int index = Index(str); + if ( index >= 0 ) + arr.Add(index); + else if ( unmatched ) + unmatched->Add(str); + } + } + + return arr; +} + +// ----------------------------------------------------------------------- + +void wxPGChoices::AllocExclusive() +{ + EnsureData(); + + if ( m_data->GetRefCount() != 1 ) + { + wxPGChoicesData* data = new wxPGChoicesData(); + data->CopyDataFrom(m_data); + Free(); + m_data = data; + } +} + +// ----------------------------------------------------------------------- + +void wxPGChoices::AssignData( wxPGChoicesData* data ) +{ + Free(); + + if ( data != wxPGChoicesEmptyData ) + { + m_data = data; + data->IncRef(); + } +} + +// ----------------------------------------------------------------------- + +void wxPGChoices::Init() +{ + m_data = wxPGChoicesEmptyData; +} + +// ----------------------------------------------------------------------- + +void wxPGChoices::Free() +{ + if ( m_data != wxPGChoicesEmptyData ) + { + m_data->DecRef(); + m_data = wxPGChoicesEmptyData; + } +} + // ----------------------------------------------------------------------- // wxPGAttributeStorage // -----------------------------------------------------------------------