// 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".
#define PWC_CHILD_SUMMARY_CHAR_LIMIT 64 // Character limit of summary field when not editing
+#if wxPG_COMPATIBILITY_1_4
+
+// Used to establish backwards compatiblity
+const char* g_invalidStringContent = "@__TOTALLY_INVALID_STRING__@";
+
+#endif
// -----------------------------------------------------------------------
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) );
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;
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);
+ const wxColour& bgCol = cell.GetBgCol();
+ dc.SetPen(bgCol);
+ dc.SetBrush(bgCol);
+ }
- 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);
+
+ // Use cell font, if provided
+ const wxFont& font = cell.GetFont();
+ if ( font.IsOk() )
+ dc.SetFont(font);
+
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;
+}
+
+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.length() )
+ return true;
+ }
+ return false;
}
}
- const wxPGEditor* editor = NULL;
- const wxPGCell* cell = property->GetCell(column);
+ int imageWidth = 0;
+ int preDrawFlags = flags;
+ bool res = false;
- wxString text;
- int imageOffset = 0;
+ property->GetDisplayInfo(column, item, flags, &text, &cell);
- // 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;
- }
- }
+ imageWidth = PreDrawCell( dc, rect, *cell, preDrawFlags );
- if ( cell )
+ if ( column == 1 )
{
- int preDrawFlags = flags;
+ editor = property->GetColumnEditor(column);
- if ( propertyGrid->GetInternalFlags() & wxPG_FL_CELL_OVERRIDES_SEL )
- preDrawFlags = preDrawFlags & ~(Selected);
-
- imageOffset = PreDrawCell( dc, rect, *cell, preDrawFlags );
- text = cell->GetText();
- if ( text == wxS("@!") )
- {
- if ( column == 0 )
- text = property->GetLabel();
- else if ( column == 1 )
- text = property->GetValueString();
- else
- text = wxEmptyString;
- }
- }
- else if ( column == 0 )
- {
- // Caption
- DrawText( dc, rect, 0, property->GetLabel() );
- }
- else if ( column == 1 )
- {
if ( !isUnspecified )
{
- editor = property->GetColumnEditor(column);
-
// Regular property value
wxSize imageSize = propertyGrid->GetImageSize(property, item);
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->GetValueString();
+ text = property->GetValueAsString();
// Add units string?
if ( propertyGrid->GetColumnCount() <= 2 )
if ( text.length() == 0 )
{
- // Try to show inline help if no text
- wxVariant vInlineHelp = property->GetAttribute(wxPGGlobalVars->m_strInlineHelp);
- if ( !vInlineHelp.IsNull() )
+ text = property->GetHintText();
+ if ( text.length() > 0 )
{
- text = vInlineHelp.GetString();
- dc.SetTextForeground(propertyGrid->GetCellDisabledTextColour());
+ res = true;
+
+ const wxColour& hCol =
+ propertyGrid->GetCellDisabledTextColour();
+ dc.SetTextForeground(hCol);
+
+ // Must make the editor NULL to override it's own rendering
+ // code.
+ editor = NULL;
}
}
- }
- else if ( column == 2 )
- {
- // Add units string?
- if ( !text.length() )
- text = property->GetAttribute(wxPGGlobalVars->m_strUnits, wxEmptyString);
+ 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,
propertyGrid->GetFontHeight()+(wxPG_CAPRECTYMARGIN*2) );
}
}
+
+ PostDrawCell(dc, propertyGrid, *cell, preDrawFlags);
+
+ return res;
}
wxSize wxPGDefaultRenderer::GetImageSize( const wxPGProperty* property,
return wxSize(0,0);
}
+// -----------------------------------------------------------------------
+// wxPGCellData
+// -----------------------------------------------------------------------
+
+wxPGCellData::wxPGCellData()
+ : wxObjectRefData()
+{
+ m_hasValidText = false;
+}
+
// -----------------------------------------------------------------------
// wxPGCell
// -----------------------------------------------------------------------
wxPGCell::wxPGCell()
+ : wxObject()
{
}
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::SetFont( const wxFont& font )
+{
+ AllocExclusive();
+
+ GetData()->SetFont(font);
+}
+
+void wxPGCell::SetBgCol( const wxColour& col )
{
- m_text = text;
+ AllocExclusive();
+
+ GetData()->SetBgCol(col);
}
+void wxPGCell::MergeFrom( const wxPGCell& srcCell )
+{
+ 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());
+}
+
+void wxPGCell::SetEmptyData()
+{
+ AllocExclusive();
+}
+
+
// -----------------------------------------------------------------------
// wxPGProperty
// -----------------------------------------------------------------------
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);
}
Init();
}
+void wxPGProperty::InitAfterAdded( wxPropertyGridPageState* pageState,
+ wxPropertyGrid* propgrid )
+{
+ //
+ // Called after property has been added to grid or page
+ // (so propgrid can be NULL, too).
+
+ 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
+ // Make sure deprecated virtual functions are not implemented
+ wxString s = GetValueAsString( 0xFFFF );
+ wxASSERT_MSG( s == g_invalidStringContent,
+ "Implement ValueToString() instead of GetValueAsString()" );
+#endif
+
+ if ( !parentIsRoot && !parent->IsCategory() )
+ {
+ m_cells = parent->m_cells;
+ }
+
+ // If in hideable adding mode, or if assigned parent is hideable, then
+ // make this one hideable.
+ if (
+ ( !parentIsRoot && parent->HasFlag(wxPG_PROP_HIDDEN) ) ||
+ ( propgrid && (propgrid->HasInternalFlag(wxPG_FL_ADDING_HIDEABLES)) )
+ )
+ SetFlag( wxPG_PROP_HIDDEN );
+
+ // Set custom image flag.
+ int custImgHeight = OnMeasureImage().y;
+ if ( custImgHeight < 0 )
+ {
+ SetFlag(wxPG_PROP_CUSTOMIMAGE);
+ }
+
+ if ( propgrid && (propgrid->HasFlag(wxPG_LIMITED_EDITING)) )
+ SetFlag(wxPG_PROP_NOEDITOR);
+
+ // Make sure parent has some parental flags
+ if ( !parent->HasFlag(wxPG_PROP_PARENTAL_FLAGS) )
+ parent->SetParentalType(wxPG_PROP_MISC_PARENT);
+
+ if ( !IsCategory() )
+ {
+ // This is not a category.
+
+ // Depth.
+ //
+ unsigned char depth = 1;
+ if ( !parentIsRoot )
+ {
+ depth = parent->m_depth;
+ if ( !parent->IsCategory() )
+ depth++;
+ }
+ m_depth = depth;
+ unsigned char greyDepth = depth;
+
+ if ( !parentIsRoot )
+ {
+ wxPropertyCategory* pc;
+
+ if ( parent->IsCategory() )
+ pc = (wxPropertyCategory* ) parent;
+ else
+ // This conditional compile is necessary to
+ // bypass some compiler bug.
+ pc = pageState->GetPropertyCategory(parent);
+
+ if ( pc )
+ greyDepth = pc->GetDepth();
+ else
+ greyDepth = parent->m_depthBgCol;
+ }
+
+ m_depthBgCol = greyDepth;
+ }
+ else
+ {
+ // This is a category.
+
+ // depth
+ unsigned char depth = 1;
+ if ( !parentIsRoot )
+ {
+ depth = parent->m_depth + 1;
+ }
+ m_depth = depth;
+ m_depthBgCol = depth;
+ }
+
+ //
+ // Has initial children
+ if ( GetChildCount() )
+ {
+ // Check parental flags
+ 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) )
+ {
+ // Properties with private children are not expanded by default.
+ SetExpanded(false);
+ }
+ else if ( propgrid && propgrid->HasFlag(wxPG_HIDE_MARGIN) )
+ {
+ // ...unless it cannot be expanded by user and therefore must
+ // remain visible at all times
+ SetExpanded(true);
+ }
+
+ //
+ // Prepare children recursively
+ for ( unsigned int i=0; i<GetChildCount(); i++ )
+ {
+ wxPGProperty* child = Item(i);
+ child->InitAfterAdded(pageState, pageState->GetGrid());
+ }
+
+ if ( propgrid && (propgrid->GetExtraStyle() & wxPG_EX_AUTO_UNSPECIFIED_VALUES) )
+ SetFlagRecursively(wxPG_PROP_AUTO_UNSPECIFIED, true);
+ }
+}
+
+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()
{
delete m_validator;
#endif
- unsigned int i;
-
- for ( i=0; i<m_cells.size(); i++ )
- delete (wxPGCell*) m_cells[i];
-
// This makes it easier for us to detect dangling pointers
m_parent = NULL;
}
return false;
}
+void wxPGProperty::SetName( const wxString& newName )
+{
+ wxPropertyGrid* pg = GetGrid();
+
+ if ( pg )
+ pg->SetPropertyName(this, newName);
+ else
+ DoSetName(newName);
+}
wxString wxPGProperty::GetName() const
{
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;
-}
-
-void wxPGProperty::UpdateControl( wxWindow* primary )
-{
- if ( primary )
- GetEditorClass()->UpdateControl(this, primary);
+ return wxPGFindInVector(m_children, p);
}
bool wxPGProperty::ValidateValue( wxVariant& WXUNUSED(value), wxPGValidationInfo& WXUNUSED(validationInfo) ) const
{
}
-wxString wxPGProperty::GetColumnText( unsigned int col ) const
+void wxPGProperty::OnValidationFailure( wxVariant& WXUNUSED(pendingValue) )
{
- wxPGCell* cell = GetCell(col);
- if ( cell )
+}
+
+void wxPGProperty::GetDisplayInfo( unsigned int column,
+ int choiceIndex,
+ int flags,
+ wxString* pString,
+ const wxPGCell** pCell )
+{
+ const wxPGCell* cell = NULL;
+
+ if ( !(flags & wxPGCellRenderer::ChoicePopup) )
{
- return cell->GetText();
+ // 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();
+ }
+ else
+ {
+ if ( column == 0 )
+ *pString = GetLabel();
+ else if ( column == 1 )
+ *pString = GetDisplayedString();
+ else if ( column == 2 )
+ *pString = 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);
+ 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
+{
+
+ if ( col != 1 || choiceIndex == wxNOT_FOUND )
+ {
+ 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
+ {
+ // Use choice
+ return m_choices.GetLabel(choiceIndex);
}
return wxEmptyString;
}
+*/
-void wxPGProperty::GenerateComposedValue( wxString& text, int argFlags ) const
+void wxPGProperty::DoGenerateComposedValue( wxString& text,
+ int argFlags,
+ const wxVariantList* valueOverrides,
+ wxPGHashMapS2S* childResults ) const
{
int i;
int iMax = m_children.size();
wxPGProperty* curChild = m_children[0];
+ bool overridesLeft = false;
+ wxVariant overrideValue;
+ wxVariantList::const_iterator node;
+
+ if ( valueOverrides )
+ {
+ node = valueOverrides->begin();
+ if ( node != valueOverrides->end() )
+ {
+ overrideValue = *node;
+ overridesLeft = true;
+ }
+ }
+
for ( i = 0; i < iMax; i++ )
{
+ wxVariant childValue;
+
+ wxString childLabel = curChild->GetLabel();
+
+ // Check for value override
+ if ( overridesLeft && overrideValue.GetName() == childLabel )
+ {
+ if ( !overrideValue.IsNull() )
+ childValue = overrideValue;
+ else
+ childValue = curChild->GetValue();
+ ++node;
+ if ( node != valueOverrides->end() )
+ overrideValue = *node;
+ else
+ overridesLeft = false;
+ }
+ else
+ {
+ childValue = curChild->GetValue();
+ }
+
wxString s;
- if ( !curChild->IsValueUnspecified() )
- s = curChild->GetValueString(argFlags|wxPG_COMPOSITE_FRAGMENT);
+ if ( !childValue.IsNull() )
+ {
+ if ( overridesLeft &&
+ curChild->HasFlag(wxPG_PROP_COMPOSED_VALUE) &&
+ childValue.GetType() == wxPG_VARIANT_TYPE_LIST )
+ {
+ wxVariantList& childList = childValue.GetList();
+ DoGenerateComposedValue(s, argFlags|wxPG_COMPOSITE_FRAGMENT,
+ &childList, childResults);
+ }
+ else
+ {
+ s = curChild->ValueToString(childValue,
+ argFlags|wxPG_COMPOSITE_FRAGMENT);
+ }
+ }
+
+ if ( childResults && curChild->GetChildCount() )
+ (*childResults)[curChild->GetName()] = s;
bool skip = false;
if ( (argFlags & wxPG_UNEDITABLE_COMPOSITE_FRAGMENT) && !s.length() )
}
}
- // 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::GetValueAsString( int argFlags ) const
+wxString wxPGProperty::ValueToString( wxVariant& WXUNUSED(value),
+ int argFlags ) const
{
wxCHECK_MSG( GetChildCount() > 0,
wxString(),
- wxT("If user property does not have any children, it must override GetValueAsString") );
+ "If user property does not have any children, it must "
+ "override GetValueAsString" );
+
+ // FIXME: Currently code below only works if value is actually m_value
+ wxASSERT_MSG( argFlags & wxPG_VALUE_IS_CURRENT,
+ "Sorry, currently default wxPGProperty::ValueToString() "
+ "implementation only works if value is m_value." );
wxString text;
- GenerateComposedValue(text, argFlags);
+ DoGenerateComposedValue(text, argFlags);
return text;
}
-wxString wxPGProperty::GetValueString( int argFlags ) const
+wxString wxPGProperty::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
+
+ wxPropertyGrid* pg = GetGrid();
+
if ( IsValueUnspecified() )
- return wxEmptyString;
+ return pg->GetUnspecifiedValueText(argFlags);
if ( m_commonValue == -1 )
- return GetValueAsString(argFlags);
+ {
+ wxVariant value(GetValue());
+ return ValueToString(value, argFlags|wxPG_VALUE_IS_CURRENT);
+ }
//
// Return common value's string representation
- wxPropertyGrid* pg = GetGrid();
const wxPGCommonValue* cv = pg->GetCommonValue(m_commonValue);
if ( argFlags & wxPG_FULL_VALUE )
}
}
+wxString wxPGProperty::GetValueString( int argFlags ) const
+{
+ return GetValueAsString(argFlags);
+}
+
bool wxPGProperty::IntToValue( wxVariant& variant, int number, int WXUNUSED(argFlags) ) const
{
variant = (long)number;
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;
-#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;
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
if ( !addOnlyIfNotEmpty || len > 0 )
{
const wxPGProperty* child = Item(curChild);
- #ifdef __WXDEBUG__
- if ( debug_print )
- wxLogDebug(wxT("token = '%s', child = %s"),token.c_str(),child->GetLabel().c_str());
- #endif
+ wxVariant variant(child->GetValue());
+ wxString childName = child->GetBaseName();
- if ( len > 0 )
- {
- bool wasUnspecified = child->IsValueUnspecified();
+ wxLogTrace("propgrid",
+ wxT("token = '%s', child = %s"),
+ token, childName);
- wxVariant variant(child->GetValueRef());
- if ( child->StringToValue(variant, token, propagatedFlags|wxPG_COMPOSITE_FRAGMENT) )
+ // Add only if editable or setting programmatically
+ if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
+ (!child->HasFlag(wxPG_PROP_DISABLED) &&
+ !child->HasFlag(wxPG_PROP_READONLY)) )
+ {
+ 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 )
{
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(']') )
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) &&
+ !child->HasFlag(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
- {
- // Failed, becomes unspecified
- variant.MakeNull();
- changed = true;
+ }
+ else
+ {
+ // 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 )
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;
// 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);
}
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 )
}
}
- //
- // 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);
+ }
+ }
}
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++ )
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;
return wxVariant();
}
-void wxPGProperty::SetCell( int column, wxPGCell* cellObj )
+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() )
+ {
+ // Fill empty slots with default cells
+ wxPropertyGrid* pg = GetGrid();
+ wxPGCell defaultCell;
+
+ 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;
+
+ for ( unsigned int i=m_cells.size(); i<cellCountMax; i++ )
+ m_cells.push_back(defaultCell);
+ }
+}
+
+void wxPGProperty::SetCell( int column,
+ const wxPGCell& cell )
{
- if ( column >= (int)m_cells.size() )
- m_cells.SetCount(column+1, NULL);
+ EnsureCells(column);
- delete (wxPGCell*) m_cells[column];
- m_cells[column] = cellObj;
+ m_cells[column] = cell;
+}
+
+void wxPGProperty::AdaptiveSetCell( unsigned int firstCol,
+ unsigned int lastCol,
+ const wxPGCell& cell,
+ const wxPGCell& srcData,
+ wxPGCellData* unmodCellData,
+ FlagType ignoreWithFlags,
+ bool recursively )
+{
+ //
+ // 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);
+ }
+ }
+ }
+
+ if ( recursively )
+ {
+ for ( unsigned int i=0; i<GetChildCount(); i++ )
+ Item(i)->AdaptiveSetCell( 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::GetOrCreateCell( unsigned int column )
+{
+ EnsureCells(column);
+ return m_cells[column];
+}
+
+void wxPGProperty::SetBackgroundColour( const wxColour& colour,
+ int flags )
+{
+ wxPGProperty* firstProp = this;
+ bool recursively = flags & wxPG_RECURSE ? true : false;
+
+ //
+ // 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,
+ int flags )
+{
+ wxPGProperty* firstProp = this;
+ bool recursively = flags & wxPG_RECURSE ? true : false;
+
+ //
+ // 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
{
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"),
wxValidator* wxPGProperty::DoGetValidator() const
{
- return (wxValidator*) NULL;
+ return NULL;
}
int wxPGProperty::InsertChoice( const wxString& label, int index, int value )
}
}
-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);
{
if ( editor->IsKindOf(CLASSINFO(wxPGTextCtrlAndButtonEditor)) )
editor = wxPGEditor_ChoiceAndButton;
- // TextCtrl -> ComboBox
- else if ( editor->IsKindOf(CLASSINFO(wxPGTextCtrlEditor)) )
- editor = wxPGEditor_ComboBox;
+ // TextCtrl -> ComboBox
+ else if ( editor->IsKindOf(CLASSINFO(wxPGTextCtrlEditor)) )
+ editor = wxPGEditor_ComboBox;
+ }
+
+ 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 editor;
+ return true;
}
bool wxPGProperty::HasVisibleChildren() const
return false;
}
-bool wxPGProperty::PrepareValueForDialogEditing( wxPropertyGrid* propGrid )
-{
- return propGrid->EditorValidate();
-}
-
-
bool wxPGProperty::RecreateEditor()
{
wxPropertyGrid* pg = GetGrid();
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());
// 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;
}
wxPropertyGrid* wxPGProperty::GetGridIfDisplayed() const
{
wxPropertyGridPageState* state = GetParentState();
+ if ( !state )
+ return NULL;
wxPropertyGrid* propGrid = state->GetGrid();
if ( state == propGrid->GetState() )
return propGrid;
}
// 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() )
{
else
{
m_children.insert( m_children.begin()+index, prop);
- if ( correct_mode ) FixIndexesOfChildren( index );
+ if ( correct_mode ) FixIndicesOfChildren( index );
}
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*/ )
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;
{
if ( *it == p )
{
- m_children.erase(it);
+ children.erase(it);
break;
}
}
}
if ( allChildrenSpecified )
- ChildChanged(*value, i, childValue);
+ {
+ *value = ChildChanged(*value, i, childValue);
+ }
+
n++;
if ( n == (unsigned int)list.GetCount() )
break;
}
-void wxPGProperty::FixIndexesOfChildren( size_t starthere )
+void wxPGProperty::FixIndicesOfChildren( unsigned int starthere )
{
size_t i;
for ( i=starthere;i<GetChildCount();i++)
// 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));
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();
}
-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
{
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 )
!parent->IsCategory() && !parent->IsRoot() )
{
wxString s;
- parent->GenerateComposedValue(s, 0);
+ parent->DoGenerateComposedValue(s);
parent->m_value = s;
return parent->UpdateParentValues();
}
return true;
}
-// Call for after sub-properties added with AddChild
-void wxPGProperty::PrepareSubProperties()
-{
- wxPropertyGridPageState* state = GetParentState();
-
- wxASSERT(state);
-
- if ( !GetChildCount() )
- return;
-
- wxByte depth = m_depth + 1;
- wxByte depthBgCol = m_depthBgCol;
-
- FlagType inheritFlags = m_flags & wxPG_INHERITED_PROPFLAGS;
-
- wxByte bgColIndex = m_bgColIndex;
- wxByte fgColIndex = m_fgColIndex;
-
- //
- // Set some values to the children
- //
- size_t i = 0;
- wxPGProperty* nparent = this;
-
- while ( i < nparent->GetChildCount() )
- {
- wxPGProperty* np = nparent->Item(i);
-
- np->m_parentState = state;
- np->m_flags |= inheritFlags; // Hideable also if parent.
- np->m_depth = depth;
- np->m_depthBgCol = depthBgCol;
- np->m_bgColIndex = bgColIndex;
- np->m_fgColIndex = fgColIndex;
-
- // Also handle children of children
- if ( np->GetChildCount() > 0 )
- {
- nparent = np;
- i = 0;
-
- // Init
- nparent->SetParentalType(wxPG_PROP_AGGREGATE);
- nparent->SetExpanded(false);
- depth++;
- }
- else
- {
- // Next sibling
- i++;
- }
-
- // After reaching last sibling, go back to processing
- // siblings of the parent
- while ( i >= nparent->GetChildCount() )
- {
- // Exit the loop when top parent hit
- if ( nparent == this )
- break;
-
- depth--;
-
- i = nparent->GetIndexInParent() + 1;
- nparent = nparent->GetParent();
- }
- }
-}
-
// Call after fixed sub-properties added/removed after creation.
// if oldSelInd >= 0 and < new max items, then selection is
// moved to it. Note: oldSelInd -2 indicates that this property
wxPropertyGridPageState* state = GetParentState();
wxPropertyGrid* grid = state->GetGrid();
- PrepareSubProperties();
+ //
+ // Re-repare children (recursively)
+ for ( unsigned int i=0; i<GetChildCount(); i++ )
+ {
+ wxPGProperty* child = Item(i);
+ 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>");
-#endif
+ m_name = name;
+ m_label = m_name;
SetParentalType(0);
m_depth = 0;
}
}
-wxString wxPropertyCategory::GetValueAsString( int ) 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;
}
+// -----------------------------------------------------------------------
+// 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<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->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
// -----------------------------------------------------------------------
{
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