dc.SetTextForeground(cell.GetFgCol());
}
- // Draw Background
- dc.DrawRectangle(rect);
+ // 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() &&
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;
}
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
// 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()." );
return wxNOT_FOUND;
}
-void wxPGProperty::UpdateControl( wxWindow* primary )
-{
- if ( primary )
- GetEditorClass()->UpdateControl(this, primary);
-}
-
bool wxPGProperty::ValidateValue( wxVariant& WXUNUSED(value), wxPGValidationInfo& WXUNUSED(validationInfo) ) const
{
return true;
{
}
+void wxPGProperty::OnValidationFailure( wxVariant& WXUNUSED(pendingValue) )
+{
+}
+
void wxPGProperty::GetDisplayInfo( unsigned int column,
int choiceIndex,
int flags,
childValue = overrideValue;
else
childValue = curChild->GetValue();
- node++;
+ ++node;
if ( node != valueOverrides->end() )
overrideValue = *node;
else
}
}
- // 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),
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
{
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());
+ wxLogDebug(wxT("token = '%s', child = %s"),
+ token.c_str(), childName.c_str());
#endif
// Add only if editable or setting programmatically
{
if ( len > 0 )
{
- bool wasUnspecified = child->IsValueUnspecified();
-
- if ( child->StringToValue(variant, token, propagatedFlags|wxPG_COMPOSITE_FRAGMENT) )
+ if ( child->StringToValue(variant, token,
+ propagatedFlags|wxPG_COMPOSITE_FRAGMENT) )
{
- // Clear unspecified flag only if OnSetValue() didn't
- // affect it.
- if ( child->IsValueUnspecified() &&
- (wasUnspecified || !UsesAutoUnspecified()) )
- {
- 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;
{
// Empty, becomes unspecified
variant.MakeNull();
+ variant.SetName(childName);
list.Append(variant);
changed = true;
}
{
int depth = 1;
- if ( it != text.end() ) it++;
+ if ( it != text.end() ) ++it;
pos++;
size_t startPos = pos;
while ( it != text.end() && depth > 0 )
{
a = *it;
- it++;
+ ++it;
pos++;
if ( a == wxS(']') )
if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
!child->HasFlag(wxPG_PROP_DISABLED|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;
tokenStart = pos;
if ( a == delimeter )
- {
- pos--;
- it--;
- }
+ strPosIncrement -= 1;
}
}
}
if ( a == 0 )
break;
- it++;
+ it += strPosIncrement;
+
if ( it != text.end() )
{
a = *it;
{
a = 0;
}
- pos++;
+
+ pos += strPosIncrement;
}
if ( changed )
// 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);
{
m_value = value;
OnSetValue();
-
- if ( !(flags & wxPG_SETVAL_FROM_PARENT) )
- UpdateParentValues();
}
if ( flags & wxPG_SETVAL_BY_USER )
}
}
+ if ( !(flags & wxPG_SETVAL_FROM_PARENT) )
+ UpdateParentValues();
+
//
// Update editor control
//
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
{
wxValidator* wxPGProperty::DoGetValidator() const
{
- return (wxValidator*) NULL;
+ return NULL;
}
int wxPGProperty::InsertChoice( const wxString& label, int index, int value )
// 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));
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
{
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 )
child->InitAfterAdded(state, grid);
}
- wxPGProperty* sel = (wxPGProperty*) NULL;
+ wxPGProperty* sel = NULL;
if ( oldSelInd >= (int)m_children.size() )
oldSelInd = (int)m_children.size() - 1;
IMPLEMENT_DYNAMIC_CLASS(wxPGRootProperty, wxPGProperty)
-wxPGRootProperty::wxPGRootProperty()
+wxPGRootProperty::wxPGRootProperty( const wxString& name )
: wxPGProperty()
{
#ifdef __WXDEBUG__
- m_name = wxS("<root>");
+ m_name = name;
+ m_label = m_name;
+#else
+ wxUnusedVar(name);
#endif
SetParentalType(0);
m_depth = 0;
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<GetCount(); i++ )
+ arr.push_back(GetLabel(i));
+
+ return arr;
+}
+
+// -----------------------------------------------------------------------
+
+wxArrayInt wxPGChoices::GetValuesForStrings( const wxArrayString& strings ) const
+{
+ wxArrayInt arr;
+
+ if ( IsOk() )
+ {
+ unsigned int i;
+ for ( i=0; i< strings.size(); i++ )
+ {
+ int index = Index(strings[i]);
+ if ( index >= 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
// -----------------------------------------------------------------------
{
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();
projects / wxWidgets.git / blobdiff