X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/1425eca550ca78f6d0824e50376d763aff17242d..69cf69be93c6410fc49ac0fb5ee7bf7a54f93f00:/src/propgrid/property.cpp diff --git a/src/propgrid/property.cpp b/src/propgrid/property.cpp index d2ad9a372d..eed6f76b22 100644 --- a/src/propgrid/property.cpp +++ b/src/propgrid/property.cpp @@ -94,8 +94,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,9 +104,6 @@ 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 ) @@ -135,38 +130,39 @@ 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 ( !(flags & Selected) ) + // If possible, use cell colours + if ( !(flags & DontUseCellBgCol) ) { - // Draw using wxPGCell information, if available - wxColour fgCol = cell.GetFgCol(); - if ( fgCol.Ok() ) - dc.SetTextForeground(fgCol); + dc.SetPen(cell.GetBgCol()); + dc.SetBrush(cell.GetBgCol()); + } - wxColour bgCol = cell.GetBgCol(); - if ( bgCol.Ok() ) - { - dc.SetPen(bgCol); - dc.SetBrush(bgCol); - dc.DrawRectangle(rect); - } + if ( !(flags & DontUseCellFgCol) ) + { + dc.SetTextForeground(cell.GetFgCol()); } + // Draw Background, but only if not rendering in control + // (as control already has rendered correct background). + if ( !(flags & (Control|ChoicePopup)) ) + dc.DrawRectangle(rect); + const wxBitmap& bmp = cell.GetBitmap(); if ( bmp.Ok() && - // In control, do not draw oversized bitmap - (!(flags & Control) || bmp.GetHeight() < rect.height ) + // Do not draw oversized bitmap outside choice popup + ((flags & ChoicePopup) || bmp.GetHeight() < rect.height ) ) { dc.DrawBitmap( bmp, 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; } // ----------------------------------------------------------------------- @@ -192,51 +188,17 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect, } const wxPGEditor* editor = NULL; - const wxPGCell* cell = property->GetCell(column); + const wxPGCell* cell = NULL; wxString text; - int imageOffset = 0; - - // Use choice cell? - if ( column == 1 && (flags & Control) ) - { - int selectedIndex = property->GetChoiceSelection(); - if ( selectedIndex != wxNOT_FOUND ) - { - const wxPGChoices& choices = property->GetChoices(); - const wxPGCell* ccell = &choices[selectedIndex]; - if ( ccell && - ( ccell->GetBitmap().IsOk() || ccell->GetFgCol().IsOk() || ccell->GetBgCol().IsOk() ) - ) - cell = ccell; - } - } + int imageWidth = 0; + int preDrawFlags = flags; - if ( cell ) - { - int preDrawFlags = flags; + property->GetDisplayInfo(column, item, flags, &text, &cell); - if ( propertyGrid->GetInternalFlags() & wxPG_FL_CELL_OVERRIDES_SEL ) - preDrawFlags = preDrawFlags & ~(Selected); + imageWidth = PreDrawCell( dc, rect, *cell, preDrawFlags ); - imageOffset = PreDrawCell( dc, rect, *cell, preDrawFlags ); - text = cell->GetText(); - if ( text == wxS("@!") ) - { - if ( column == 0 ) - text = property->GetLabel(); - else if ( column == 1 ) - text = property->GetValueAsString(); - else - text = wxEmptyString; - } - } - else if ( column == 0 ) - { - // Caption - DrawText( dc, rect, 0, property->GetLabel() ); - } - else if ( column == 1 ) + if ( column == 1 ) { if ( !isUnspecified ) { @@ -257,27 +219,14 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect, wxPG_CUSTOM_IMAGE_WIDTH, rect.height-(wxPG_CUSTOM_IMAGE_SPACINGY*2)); - /*if ( imageSize.x == wxPG_FULL_CUSTOM_PAINT_WIDTH ) - { - imageRect.width = m_width - imageRect.x; - }*/ - dc.SetPen( wxPen(propertyGrid->GetCellTextColour(), 1, wxSOLID) ); paintdata.m_drawnWidth = imageSize.x; paintdata.m_drawnHeight = imageSize.y; - if ( !isUnspecified ) - { - property->OnCustomPaint( dc, imageRect, paintdata ); - } - else - { - dc.SetBrush(*wxWHITE_BRUSH); - dc.DrawRectangle(imageRect); - } + property->OnCustomPaint( dc, imageRect, paintdata ); - imageOffset = paintdata.m_drawnWidth; + imageWidth = paintdata.m_drawnWidth; } text = property->GetValueAsString(); @@ -302,12 +251,8 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect, } } } - else if ( column == 2 ) - { - // Add units string? - if ( !text.length() ) - text = property->GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString); - } + + int imageOffset = property->GetImageOffset(imageWidth); DrawEditorValue( dc, rect, imageOffset, text, property, editor ); @@ -316,8 +261,11 @@ void wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect, { if ( flags & Selected ) { - if ( imageOffset > 0 ) - imageOffset += wxCC_CUSTOM_IMAGE_MARGIN2 + 4; + if ( imageWidth > 0 ) + { + imageOffset -= DEFAULT_IMAGE_OFFSET_INCREMENT; + imageWidth += wxCC_CUSTOM_IMAGE_MARGIN2 + 4; + } DrawCaptionSelectionRect( dc, rect.x+wxPG_XBEFORETEXT-wxPG_CAPRECTXMARGIN+imageOffset, @@ -347,11 +295,22 @@ wxSize wxPGDefaultRenderer::GetImageSize( const wxPGProperty* property, return wxSize(0,0); } +// ----------------------------------------------------------------------- +// wxPGCellData +// ----------------------------------------------------------------------- + +wxPGCellData::wxPGCellData() + : wxObjectRefData() +{ + m_hasValidText = false; +} + // ----------------------------------------------------------------------- // wxPGCell // ----------------------------------------------------------------------- wxPGCell::wxPGCell() + : wxObject() { } @@ -359,9 +318,74 @@ wxPGCell::wxPGCell( const wxString& text, const wxBitmap& bitmap, const wxColour& fgCol, const wxColour& bgCol ) - : m_bitmap(bitmap), m_fgCol(fgCol), m_bgCol(bgCol) + : wxObject() +{ + wxPGCellData* data = new wxPGCellData(); + m_refData = data; + data->m_text = text; + data->m_bitmap = bitmap; + data->m_fgCol = fgCol; + data->m_bgCol = bgCol; + data->m_hasValidText = true; +} + +wxObjectRefData *wxPGCell::CloneRefData( const wxObjectRefData *data ) const +{ + wxPGCellData* c = new wxPGCellData(); + const wxPGCellData* o = (const wxPGCellData*) data; + c->m_text = o->m_text; + c->m_bitmap = o->m_bitmap; + c->m_fgCol = o->m_fgCol; + c->m_bgCol = o->m_bgCol; + c->m_hasValidText = o->m_hasValidText; + return c; +} + +void wxPGCell::SetText( const wxString& text ) +{ + AllocExclusive(); + + GetData()->SetText(text); +} + +void wxPGCell::SetBitmap( const wxBitmap& bitmap ) +{ + AllocExclusive(); + + GetData()->SetBitmap(bitmap); +} + +void wxPGCell::SetFgCol( const wxColour& col ) +{ + AllocExclusive(); + + GetData()->SetFgCol(col); +} + +void wxPGCell::SetBgCol( const wxColour& col ) +{ + AllocExclusive(); + + GetData()->SetBgCol(col); +} + +void wxPGCell::MergeFrom( const wxPGCell& srcCell ) { - m_text = text; + AllocExclusive(); + + wxPGCellData* data = GetData(); + + if ( srcCell.HasText() ) + data->SetText(srcCell.GetText()); + + if ( srcCell.GetFgCol().IsOk() ) + data->SetFgCol(srcCell.GetFgCol()); + + if ( srcCell.GetBgCol().IsOk() ) + data->SetBgCol(srcCell.GetBgCol()); + + if ( srcCell.GetBitmap().IsOk() ) + data->SetBitmap(srcCell.GetBitmap()); } // ----------------------------------------------------------------------- @@ -378,24 +402,22 @@ 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 m_flags = wxPG_PROP_PROPERTY; m_depth = 1; - m_bgColIndex = 0; - m_fgColIndex = 0; SetExpanded(true); } @@ -436,10 +458,9 @@ void wxPGProperty::InitAfterAdded( wxPropertyGridPageState* pageState, "Implement ValueToString() instead of GetValueAsString()" ); #endif - if ( !parentIsRoot ) + if ( !parentIsRoot && !parent->IsCategory() ) { - m_bgColIndex = parent->m_bgColIndex; - m_fgColIndex = parent->m_fgColIndex; + m_cells = parent->m_cells; } // If in hideable adding mode, or if assigned parent is hideable, then @@ -517,10 +538,8 @@ void wxPGProperty::InitAfterAdded( wxPropertyGridPageState* pageState, // Has initial children if ( GetChildCount() ) { - FlagType parentalFlags = m_flags & wxPG_PROP_PARENTAL_FLAGS; - // Check parental flags - wxASSERT_MSG( parentalFlags, + wxASSERT_MSG( (m_flags & wxPG_PROP_PARENTAL_FLAGS), "Call SetFlag(wxPG_PROP_MISC_PARENT) or" "SetFlag(wxPG_PROP_AGGREGATE) before calling" "wxPGProperty::AddChild()." ); @@ -575,11 +594,6 @@ wxPGProperty::~wxPGProperty() delete m_validator; #endif - unsigned int i; - - for ( i=0; iUpdateControl(this, primary); -} - bool wxPGProperty::ValidateValue( wxVariant& WXUNUSED(value), wxPGValidationInfo& WXUNUSED(validationInfo) ) const { return true; @@ -644,30 +652,96 @@ void wxPGProperty::RefreshChildren () { } -wxString wxPGProperty::GetColumnText( unsigned int col ) const +void wxPGProperty::OnValidationFailure( wxVariant& WXUNUSED(pendingValue) ) +{ +} + +void wxPGProperty::GetDisplayInfo( unsigned int column, + int choiceIndex, + int flags, + wxString* pString, + const wxPGCell** pCell ) +{ + const wxPGCell* cell = NULL; + + if ( !(flags & wxPGCellRenderer::ChoicePopup) ) + { + // Not painting listi of choice popups, so get text from property + cell = &GetCell(column); + if ( cell->HasText() ) + { + *pString = cell->GetText(); + } + else + { + if ( column == 0 ) + *pString = GetLabel(); + else if ( column == 1 ) + *pString = GetDisplayedString(); + else if ( column == 2 ) + *pString = GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString); + } + } + else + { + wxASSERT( column == 1 ); + + if ( choiceIndex != wxNOT_FOUND ) + { + const wxPGChoiceEntry& entry = m_choices[choiceIndex]; + if ( entry.GetBitmap().IsOk() || + entry.GetFgCol().IsOk() || + entry.GetBgCol().IsOk() ) + cell = &entry; + *pString = m_choices.GetLabel(choiceIndex); + } + } + + if ( !cell ) + cell = &GetCell(column); + + wxASSERT_MSG( cell->GetData(), + wxString::Format("Invalid cell for property %s", + GetName().c_str()) ); + + *pCell = cell; +} + +/* +wxString wxPGProperty::GetColumnText( unsigned int col, int choiceIndex ) const { - wxPGCell* cell = GetCell(col); - if ( cell ) + + if ( col != 1 || choiceIndex == wxNOT_FOUND ) { - return cell->GetText(); + const wxPGCell& cell = GetCell(col); + if ( cell->HasText() ) + { + return cell->GetText(); + } + else + { + if ( col == 0 ) + return GetLabel(); + else if ( col == 1 ) + return GetDisplayedString(); + else if ( col == 2 ) + return GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString); + } } else { - if ( col == 0 ) - return GetLabel(); - else if ( col == 1 ) - return GetDisplayedString(); - else if ( col == 2 ) - return GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString); + // Use choice + return m_choices.GetLabel(choiceIndex); } return wxEmptyString; } +*/ -void wxPGProperty::GenerateComposedValue( wxString& text, - int argFlags, - const wxVariantList* valueOverrides, - wxPGHashMapS2S* childResults ) const +void wxPGProperty::DoGenerateComposedValue( wxString& text, + int argFlags, + const wxVariantList* valueOverrides, + wxPGHashMapS2S* childResults ) const { int i; int iMax = m_children.size(); @@ -714,7 +788,7 @@ void wxPGProperty::GenerateComposedValue( wxString& text, childValue = overrideValue; else childValue = curChild->GetValue(); - node++; + ++node; if ( node != valueOverrides->end() ) overrideValue = *node; else @@ -733,8 +807,8 @@ void wxPGProperty::GenerateComposedValue( wxString& text, childValue.GetType() == wxPG_VARIANT_TYPE_LIST ) { wxVariantList& childList = childValue.GetList(); - GenerateComposedValue(s, argFlags|wxPG_COMPOSITE_FRAGMENT, - &childList, childResults); + DoGenerateComposedValue(s, argFlags|wxPG_COMPOSITE_FRAGMENT, + &childList, childResults); } else { @@ -774,13 +848,13 @@ void wxPGProperty::GenerateComposedValue( wxString& text, } } - // Remove superfluous semicolon and space - wxString rest; - if ( text.EndsWith(wxS("; "), &rest) ) - text = rest; - if ( (unsigned int)i < m_children.size() ) - text += wxS("; ..."); + { + if ( !text.EndsWith(wxS("; ")) ) + text += wxS("; ..."); + else + text += wxS("..."); + } } wxString wxPGProperty::ValueToString( wxVariant& WXUNUSED(value), @@ -797,7 +871,7 @@ wxString wxPGProperty::ValueToString( wxVariant& WXUNUSED(value), "implementation only works if value is m_value." ); wxString text; - GenerateComposedValue(text, argFlags); + DoGenerateComposedValue(text, argFlags); return text; } @@ -881,7 +955,7 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int wxVariantList temp_list; wxVariant list(temp_list); - int propagatedFlags = argFlags & wxPG_REPORT_ERROR; + int propagatedFlags = argFlags & (wxPG_REPORT_ERROR|wxPG_PROGRAMMATIC_VALUE); #ifdef __WXDEBUG__ bool debug_print = false; @@ -902,6 +976,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 @@ -914,41 +993,47 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int if ( !addOnlyIfNotEmpty || len > 0 ) { const wxPGProperty* child = Item(curChild); + wxVariant variant(child->GetValue()); + wxString childName = child->GetBaseName(); + #ifdef __WXDEBUG__ if ( debug_print ) - wxLogDebug(wxT("token = '%s', child = %s"),token.c_str(),child->GetLabel().c_str()); + wxLogDebug(wxT("token = '%s', child = %s"), + token.c_str(), childName.c_str()); #endif - if ( len > 0 ) + // Add only if editable or setting programmatically + if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) || + !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) ) { - bool wasUnspecified = child->IsValueUnspecified(); - - wxVariant variant(child->GetValueRef()); - if ( child->StringToValue(variant, token, propagatedFlags|wxPG_COMPOSITE_FRAGMENT) ) + if ( len > 0 ) { - variant.SetName(child->GetBaseName()); - - // Clear unspecified flag only if OnSetValue() didn't - // affect it. - if ( child->IsValueUnspecified() && - (wasUnspecified || !UsesAutoUnspecified()) ) + if ( child->StringToValue(variant, token, + propagatedFlags|wxPG_COMPOSITE_FRAGMENT) ) { - variant = child->GetDefaultValue(); + // 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; } - + } + else + { + // Empty, becomes unspecified + variant.MakeNull(); + variant.SetName(childName); list.Append(variant); - changed = true; } } - else - { - // Empty, becomes unspecified - wxVariant variant2; - variant2.SetName(child->GetBaseName()); - list.Append(variant2); - changed = true; - } curChild++; if ( curChild >= iMax ) @@ -971,7 +1056,7 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int { int depth = 1; - if ( it != text.end() ) it++; + if ( it != text.end() ) ++it; pos++; size_t startPos = pos; @@ -979,7 +1064,7 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int while ( it != text.end() && depth > 0 ) { a = *it; - it++; + ++it; pos++; if ( a == wxS(']') ) @@ -997,21 +1082,26 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int wxVariant oldChildValue = child->GetValue(); wxVariant variant(oldChildValue); - bool stvRes = child->StringToValue( variant, token, propagatedFlags ); - if ( stvRes || (variant != oldChildValue) ) + + if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) || + !child->HasFlag(wxPG_PROP_DISABLED|wxPG_PROP_READONLY) ) { - if ( stvRes ) + wxString childName = child->GetBaseName(); + + bool stvRes = child->StringToValue( variant, token, + propagatedFlags ); + if ( stvRes || (variant != oldChildValue) ) + { + variant.SetName(childName); + list.Append(variant); + changed = true; + } + else + { + // No changes... + } } - else - { - // Failed, becomes unspecified - variant.MakeNull(); - changed = true; - } - - variant.SetName(child->GetBaseName()); - list.Append(variant); curChild++; if ( curChild >= iMax ) @@ -1026,10 +1116,7 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int tokenStart = pos; if ( a == delimeter ) - { - pos--; - it--; - } + strPosIncrement -= 1; } } } @@ -1037,7 +1124,8 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int if ( a == 0 ) break; - it++; + it += strPosIncrement; + if ( it != text.end() ) { a = *it; @@ -1046,7 +1134,8 @@ bool wxPGProperty::StringToValue( wxVariant& variant, const wxString& text, int { a = 0; } - pos++; + + pos += strPosIncrement; } if ( changed ) @@ -1081,6 +1170,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; @@ -1162,7 +1267,7 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags ) // Children in list can be in any order, but we will give hint to // GetPropertyByNameWH(). This optimizes for full list parsing. - for ( node = list.begin(); node != list.end(); node++ ) + for ( node = list.begin(); node != list.end(); ++node ) { wxVariant& childValue = *((wxVariant*)*node); wxPGProperty* child = GetPropertyByNameWH(childValue.GetName(), i); @@ -1200,9 +1305,6 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags ) { m_value = value; OnSetValue(); - - if ( !(flags & wxPG_SETVAL_FROM_PARENT) ) - UpdateParentValues(); } if ( flags & wxPG_SETVAL_BY_USER ) @@ -1232,13 +1334,21 @@ void wxPGProperty::SetValue( wxVariant value, wxVariant* pList, int flags ) } } + if ( !(flags & wxPG_SETVAL_FROM_PARENT) ) + UpdateParentValues(); + // // Update editor control // // We need to check for these, otherwise GetGrid() may fail. if ( flags & wxPG_SETVAL_REFRESH_EDITOR ) + { RefreshEditor(); + wxPropertyGrid* pg = GetGridIfDisplayed(); + if ( pg ) + pg->DrawItemAndValueRelated(this); + } } @@ -1261,18 +1371,13 @@ 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 { @@ -1317,13 +1422,169 @@ wxVariant wxPGProperty::GetDefaultValue() const return wxVariant(); } -void wxPGProperty::SetCell( int column, wxPGCell* cellObj ) +void wxPGProperty::EnsureCells( unsigned int column ) +{ + if ( column >= m_cells.size() ) + { + // Fill empty slots with default cells + wxPropertyGrid* pg = GetGrid(); + wxPGCell defaultCell; + + if ( !HasFlag(wxPG_PROP_CATEGORY) ) + defaultCell = pg->GetPropertyDefaultCell(); + else + defaultCell = pg->GetCategoryDefaultCell(); + + // TODO: Replace with resize() call + unsigned int cellCountMax = column+1; + + for ( unsigned int i=m_cells.size(); i= (int)m_cells.size() ) - m_cells.SetCount(column+1, NULL); + // + // Sets cell in memory optimizing fashion. That is, if + // current cell data matches unmodCellData, we will + // simply get reference to data from cell. Otherwise, + // cell information from srcData is merged into current. + // + + if ( !(m_flags & ignoreWithFlags) && !IsRoot() ) + { + EnsureCells(lastCol); + + for ( unsigned int col=firstCol; col<=lastCol; col++ ) + { + if ( m_cells[col].GetData() == unmodCellData ) + { + // Data matches... use cell directly + m_cells[col] = cell; + } + else + { + // Data did not match... merge valid information + m_cells[col].MergeFrom(srcData); + } + } + } - delete (wxPGCell*) m_cells[column]; - m_cells[column] = cellObj; + if ( recursively ) + { + for ( unsigned int i=0; iAdaptiveSetCell( firstCol, + lastCol, + cell, + srcData, + unmodCellData, + ignoreWithFlags, + recursively ); + } +} + +const wxPGCell& wxPGProperty::GetCell( unsigned int column ) const +{ + if ( m_cells.size() > column ) + return m_cells[column]; + + wxPropertyGrid* pg = GetGrid(); + + if ( IsCategory() ) + return pg->GetCategoryDefaultCell(); + + return pg->GetPropertyDefaultCell(); +} + +wxPGCell& wxPGProperty::GetCell( unsigned int column ) +{ + EnsureCells(column); + return m_cells[column]; +} + +void wxPGProperty::SetBackgroundColour( const wxColour& colour, + bool recursively ) +{ + wxPGProperty* firstProp = this; + + // + // If category is tried to set recursively, skip it and only + // affect the children. + if ( recursively ) + { + while ( firstProp->IsCategory() ) + { + if ( !firstProp->GetChildCount() ) + return; + firstProp = firstProp->Item(0); + } + } + + wxPGCell& firstCell = firstProp->GetCell(0); + wxPGCellData* firstCellData = firstCell.GetData(); + + wxPGCell newCell(firstCell); + newCell.SetBgCol(colour); + wxPGCell srcCell; + srcCell.SetBgCol(colour); + + AdaptiveSetCell( 0, + GetParentState()->GetColumnCount()-1, + newCell, + srcCell, + firstCellData, + recursively ? wxPG_PROP_CATEGORY : 0, + recursively ); +} + +void wxPGProperty::SetTextColour( const wxColour& colour, + bool recursively ) +{ + wxPGProperty* firstProp = this; + + // + // If category is tried to set recursively, skip it and only + // affect the children. + if ( recursively ) + { + while ( firstProp->IsCategory() ) + { + if ( !firstProp->GetChildCount() ) + return; + firstProp = firstProp->Item(0); + } + } + + wxPGCell& firstCell = firstProp->GetCell(0); + wxPGCellData* firstCellData = firstCell.GetData(); + + wxPGCell newCell(firstCell); + newCell.SetFgCol(colour); + wxPGCell srcCell; + srcCell.SetFgCol(colour); + + AdaptiveSetCell( 0, + GetParentState()->GetColumnCount()-1, + newCell, + srcCell, + firstCellData, + recursively ? wxPG_PROP_CATEGORY : 0, + recursively ); } wxPGEditorDialogAdapter* wxPGProperty::GetEditorDialog() const @@ -1475,7 +1736,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 ) @@ -1658,7 +1919,7 @@ 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 wxBitmap* bmpNew = new wxBitmap(maxSz.x,maxSz.y,bmp.GetDepth()); @@ -1668,12 +1929,11 @@ void wxPGProperty::SetValueImage( wxBitmap& bmp ) // 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.SetUserScale(scaleY, scaleY); - dc.DrawBitmap( bmp, 0, 0 ); + dc.DrawBitmap(bmp, 0, 0); m_valueBitmap = bmpNew; } @@ -1737,6 +1997,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; @@ -1895,7 +2157,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)); @@ -2045,6 +2307,17 @@ void wxPGProperty::Empty() m_children.clear(); } +void wxPGProperty::DeleteChildren() +{ + wxPropertyGridPageState* state = m_parentState; + + while ( GetChildCount() ) + { + wxPGProperty* child = Item(GetChildCount()-1); + state->DoDelete(child, true); + } +} + void wxPGProperty::ChildChanged( wxVariant& WXUNUSED(thisValue), int WXUNUSED(childIndex), wxVariant& WXUNUSED(childValue) ) const @@ -2074,7 +2347,7 @@ bool wxPGProperty::AreAllChildrenSpecified( wxVariant* pendingList ) const { const wxString& childName = child->GetBaseName(); - for ( ; node != pList->end(); node++ ) + for ( ; node != pList->end(); ++node ) { const wxVariant& item = *((const wxVariant*)*node); if ( item.GetName() == childName ) @@ -2115,7 +2388,7 @@ wxPGProperty* wxPGProperty::UpdateParentValues() !parent->IsCategory() && !parent->IsRoot() ) { wxString s; - parent->GenerateComposedValue(s); + parent->DoGenerateComposedValue(s); parent->m_value = s; return parent->UpdateParentValues(); } @@ -2153,7 +2426,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; @@ -2179,11 +2452,14 @@ 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(""); + m_name = name; + m_label = m_name; +#else + wxUnusedVar(name); #endif SetParentalType(0); m_depth = 0; @@ -2251,6 +2527,270 @@ void wxPropertyCategory::CalculateTextExtent( wxWindow* wnd, const wxFont& 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** labels, const ValArrItem* values ) +{ + AllocExclusive(); + + unsigned int itemcount = 0; + const wxChar** 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->m_refCount != 0xFFFFFFF ); + 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->m_refCount != 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->m_refCount++; + } +} + +// ----------------------------------------------------------------------- + +void wxPGChoices::Init() +{ + m_data = wxPGChoicesEmptyData; +} + +// ----------------------------------------------------------------------- + +void wxPGChoices::Free() +{ + if ( m_data != wxPGChoicesEmptyData ) + { + m_data->DecRef(); + m_data = wxPGChoicesEmptyData; + } +} + // ----------------------------------------------------------------------- // wxPGAttributeStorage // ----------------------------------------------------------------------- @@ -2263,7 +2803,7 @@ wxPGAttributeStorage::~wxPGAttributeStorage() { wxPGHashMapS2P::iterator it; - for ( it = m_map.begin(); it != m_map.end(); it++ ) + for ( it = m_map.begin(); it != m_map.end(); ++it ) { wxVariantData* data = (wxVariantData*) it->second; data->DecRef();