// 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".
#include "wx/hash.h"
#include "wx/string.h"
#include "wx/log.h"
+ #include "wx/math.h"
#include "wx/event.h"
#include "wx/window.h"
#include "wx/panel.h"
#include "wx/intl.h"
#endif
+#include "wx/image.h"
+
#include "wx/propgrid/propgrid.h"
if ( editor )
{
- wxRect rect2(rect);
+ wxRect rect2(rect);
rect2.x += xOffset;
rect2.y += yOffset;
rect2.height -= yOffset;
// 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 & (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() &&
+ if ( bmp.IsOk() &&
// Do not draw oversized bitmap outside choice popup
((flags & ChoicePopup) || bmp.GetHeight() < rect.height )
)
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 )
{
// 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 imageWidth = 0;
int preDrawFlags = flags;
+ bool res = false;
property->GetDisplayInfo(column, item, flags, &text, &cell);
if ( column == 1 )
{
+ editor = property->GetColumnEditor(column);
+
if ( !isUnspecified )
{
- editor = property->GetColumnEditor(column);
-
// Regular property value
wxSize imageSize = propertyGrid->GetImageSize(property, item);
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 its 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 ( imageWidth > 0 )
+ if ( imageOffset > 0 )
{
imageOffset -= DEFAULT_IMAGE_OFFSET_INCREMENT;
- imageWidth += wxCC_CUSTOM_IMAGE_MARGIN2 + 4;
+ imageOffset += wxCC_CUSTOM_IMAGE_MARGIN2 + 4;
}
DrawCaptionSelectionRect( dc,
propertyGrid->GetFontHeight()+(wxPG_CAPRECTYMARGIN*2) );
}
}
+
+ PostDrawCell(dc, propertyGrid, *cell, preDrawFlags);
+
+ return res;
}
wxSize wxPGDefaultRenderer::GetImageSize( const wxPGProperty* property,
{
wxBitmap* bmp = property->GetValueImage();
- if ( bmp && bmp->Ok() )
+ if ( bmp && bmp->IsOk() )
return wxSize(bmp->GetWidth(),bmp->GetHeight());
}
}
GetData()->SetFgCol(col);
}
+void wxPGCell::SetFont( const wxFont& font )
+{
+ AllocExclusive();
+
+ GetData()->SetFont(font);
+}
+
void wxPGCell::SetBgCol( const wxColour& col )
{
AllocExclusive();
data->SetBitmap(srcCell.GetBitmap());
}
+void wxPGCell::SetEmptyData()
+{
+ AllocExclusive();
+}
+
+
// -----------------------------------------------------------------------
// wxPGProperty
// -----------------------------------------------------------------------
wxPGProperty* parent = m_parent;
bool parentIsRoot = parent->IsKindOf(CLASSINFO(wxPGRootProperty));
+ //
+ // Convert invalid cells to default ones in this grid
+ for ( unsigned int i=0; i<m_cells.size(); i++ )
+ {
+ wxPGCell& cell = m_cells[i];
+ if ( cell.IsInvalid() )
+ {
+ const wxPGCell& propDefCell = propgrid->GetPropertyDefaultCell();
+ const wxPGCell& catDefCell = propgrid->GetCategoryDefaultCell();
+
+ if ( !HasFlag(wxPG_PROP_CATEGORY) )
+ cell = propDefCell;
+ else
+ cell = catDefCell;
+ }
+ }
+
m_parentState = pageState;
#if wxPG_COMPATIBILITY_1_4
}
}
+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; i<m_cells.size(); i++ )
+ {
+ wxPGCell& cell = m_cells[i];
+ if ( cell.IsSameAs(propDefCell) ||
+ cell.IsSameAs(catDefCell) )
+ {
+ cell.UnRef();
+ }
+ }
+ }
+}
+
wxPGProperty::wxPGProperty()
: wxObject()
{
return false;
}
+void wxPGProperty::SetName( const wxString& newName )
+{
+ wxPropertyGrid* pg = GetGrid();
+
+ if ( pg )
+ pg->SetPropertyName(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;
int wxPGProperty::Index( const wxPGProperty* p ) const
{
- for ( unsigned int i = 0; i<m_children.size(); i++ )
- {
- if ( p == m_children[i] )
- return i;
- }
- return wxNOT_FOUND;
+ return wxPGFindInVector(m_children, p);
}
bool wxPGProperty::ValidateValue( wxVariant& WXUNUSED(value), wxPGValidationInfo& WXUNUSED(validationInfo) ) const
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();
/*
wxString wxPGProperty::GetColumnText( unsigned int col, int choiceIndex ) const
{
-
+
if ( col != 1 || choiceIndex == wxNOT_FOUND )
{
const wxPGCell& cell = GetCell(col);
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 )
}
#endif
+ wxPropertyGrid* pg = GetGrid();
+
if ( IsValueUnspecified() )
- return wxEmptyString;
+ return pg->GetUnspecifiedValueText(argFlags);
if ( m_commonValue == -1 )
{
//
// Return common value's string representation
- wxPropertyGrid* pg = GetGrid();
const wxPGCommonValue* cv = pg->GetCommonValue(m_commonValue);
if ( argFlags & wxPG_FULL_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 )
{
token = text.substr(startPos,pos-startPos-1);
- if ( !token.length() )
+ if ( token.empty() )
break;
const wxPGProperty* child = Item(curChild);
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();
{
wxBitmap* bmp = m_valueBitmap;
- wxCHECK_RET( bmp && bmp->Ok(), wxT("invalid bitmap") );
+ wxCHECK_RET( bmp && bmp->IsOk(), wxT("invalid bitmap") );
wxCHECK_RET( rect.x >= 0, wxT("unexpected measure call") );
}
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() )
UpdateParentValues();
//
- // Update editor control
- //
-
- // 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);
+ }
}
}
GetGrid()->ValueChangeInEvent(value);
}
-void wxPGProperty::SetFlagRecursively( FlagType flag, bool set )
+void wxPGProperty::SetFlagRecursively( wxPGPropertyFlags flag, bool set )
{
ChangeFlag(flag, set);
wxVariant wxPGProperty::GetDefaultValue() const
{
- wxVariant defVal = GetAttribute(wxS("DefaultValue"));
+ wxVariant defVal = GetAttribute(wxPG_ATTR_DEFAULT_VALUE);
if ( !defVal.IsNull() )
return defVal;
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() )
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;
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
}
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
{
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
// 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"),
{
const wxChar* fs = gs_propFlagToString[i];
wxASSERT(fs);
- if ( s.length() )
+ if ( !s.empty() )
s << wxS("|");
s << fs;
}
}
}
-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);
{
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;
{
delete m_valueBitmap;
- if ( &bmp && bmp.Ok() )
+ if ( &bmp && bmp.IsOk() )
{
// Resize the image
wxSize maxSz = GetGrid()->GetImageSize();
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(wxRound(bmp.GetWidth()*scaleY),
+ wxRound(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 scaleY = (double)maxSz.y / (double)imSz.y;
-
dc.SetUserScale(scaleY, scaleY);
-
dc.DrawBitmap(bmp, 0, 0);
+ #endif
m_valueBitmap = bmpNew;
}
{
if ( *it == p )
{
- m_children.erase(it);
+ children.erase(it);
break;
}
}
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());
}
if ( allChildrenSpecified )
- ChildChanged(*value, i, childValue);
+ {
+ *value = ChildChanged(*value, i, childValue);
+ }
+
n++;
if ( n == (unsigned int)list.GetCount() )
break;
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 );
/*
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;
m_children.clear();
}
+wxPGProperty* wxPGProperty::GetItemAtY( unsigned int y ) const
+{
+ unsigned int nextItem;
+ return GetItemAtY( y, GetGrid()->GetRowHeight(), &nextItem);
+}
+
void wxPGProperty::DeleteChildren()
{
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);
}
}
-void wxPGProperty::ChildChanged( wxVariant& WXUNUSED(thisValue),
- int WXUNUSED(childIndex),
- wxVariant& WXUNUSED(childValue) ) const
+bool wxPGProperty::IsChildSelected( bool recursive ) const
{
+ size_t i;
+ for ( i = 0; i < GetChildCount(); i++ )
+ {
+ wxPGProperty* child = Item(i);
+
+ // Test child
+ if ( m_parentState->DoIsPropertySelected( child ) )
+ return true;
+
+ // Test sub-childs
+ if ( recursive && child->IsChildSelected( recursive ) )
+ return true;
+ }
+
+ return false;
+}
+
+wxVariant wxPGProperty::ChildChanged( wxVariant& WXUNUSED(thisValue),
+ int WXUNUSED(childIndex),
+ wxVariant& WXUNUSED(childValue) ) const
+{
+ return wxNullVariant;
}
bool wxPGProperty::AreAllChildrenSpecified( wxVariant* pendingList ) 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;
}
+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;
}
// -----------------------------------------------------------------------
-void wxPGChoices::Add( const wxChar** labels, const ValArrItem* values )
+void wxPGChoices::Add( const wxChar* const* labels, const ValArrItem* values )
{
AllocExclusive();
unsigned int itemcount = 0;
- const wxChar** p = &labels[0];
+ const wxChar* const* p = &labels[0];
while ( *p ) { p++; itemcount++; }
unsigned int i;
{
AllocExclusive();
- wxASSERT( m_data->m_refCount != 0xFFFFFFF );
+ wxASSERT( m_data->GetRefCount() != -1 );
m_data->m_items.erase(m_data->m_items.begin()+nIndex,
m_data->m_items.begin()+nIndex+count);
}
{
EnsureData();
- if ( m_data->m_refCount != 1 )
+ if ( m_data->GetRefCount() != 1 )
{
wxPGChoicesData* data = new wxPGChoicesData();
data->CopyDataFrom(m_data);
if ( data != wxPGChoicesEmptyData )
{
m_data = data;
- data->m_refCount++;
+ data->IncRef();
}
}
projects / wxWidgets.git / blobdiff