// Created: 2007-04-14
// RCS-ID: $Id$
// Copyright: (c) Jaakko Salli
-// Licence: wxWindows license
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// For compilers that support precompilation, includes "wx/wx.h".
#elif defined(__WXGTK__)
// tested
- #define wxPG_CHECKMARK_XADJ 0
- #define wxPG_CHECKMARK_YADJ 0
- #define wxPG_CHECKMARK_WADJ (-1)
- #define wxPG_CHECKMARK_HADJ (-1)
+ #define wxPG_CHECKMARK_XADJ 1
+ #define wxPG_CHECKMARK_YADJ 1
+ #define wxPG_CHECKMARK_WADJ (-2)
+ #define wxPG_CHECKMARK_HADJ (-2)
#define wxPG_CHECKMARK_DEFLATE 3
#define wxPG_NAT_BUTTON_BORDER_ANY 1
#elif defined(__WXMAC__)
// *not* tested
- #define wxPG_CHECKMARK_XADJ 0
- #define wxPG_CHECKMARK_YADJ 0
- #define wxPG_CHECKMARK_WADJ 0
- #define wxPG_CHECKMARK_HADJ 0
+ #define wxPG_CHECKMARK_XADJ 4
+ #define wxPG_CHECKMARK_YADJ 4
+ #define wxPG_CHECKMARK_WADJ -6
+ #define wxPG_CHECKMARK_HADJ -6
#define wxPG_CHECKMARK_DEFLATE 0
#define wxPG_NAT_BUTTON_BORDER_ANY 0
#endif
// Number added to image width for SetCustomPaintWidth
-#define ODCB_CUST_PAINT_MARGIN 9
+#define ODCB_CUST_PAINT_MARGIN 6
-// Milliseconds to wait for two mouse-ups after focus inorder
+// Milliseconds to wait for two mouse-ups after focus in order
// to trigger a double-click.
#define DOUBLE_CLICK_CONVERSION_TRESHOLD 500
return GetClassInfo()->GetClassName();
}
-void wxPGEditor::DrawValue( wxDC& dc, const wxRect& rect, wxPGProperty* property, const wxString& text ) const
+void wxPGEditor::DrawValue( wxDC& dc, const wxRect& rect,
+ wxPGProperty* WXUNUSED(property),
+ const wxString& text ) const
{
- if ( !property->IsValueUnspecified() )
- dc.DrawText( text, rect.x+wxPG_XBEFORETEXT, rect.y );
+ dc.DrawText( text, rect.x+wxPG_XBEFORETEXT, rect.y );
}
bool wxPGEditor::GetValueFromControl( wxVariant&, wxPGProperty*, wxWindow* ) const
{
}
+void wxPGEditor::SetControlAppearance( wxPropertyGrid* pg,
+ wxPGProperty* property,
+ wxWindow* ctrl,
+ const wxPGCell& cell,
+ const wxPGCell& oCell,
+ bool unspecified ) const
+{
+ // Get old editor appearance
+ wxTextCtrl* tc = NULL;
+ wxComboCtrl* cb = NULL;
+ if ( wxDynamicCast(ctrl, wxTextCtrl) )
+ {
+ tc = (wxTextCtrl*) ctrl;
+ }
+ else
+ {
+ if ( wxDynamicCast(ctrl, wxComboCtrl) )
+ {
+ cb = (wxComboCtrl*) ctrl;
+ tc = cb->GetTextCtrl();
+ }
+ }
+
+ if ( tc || cb )
+ {
+ wxString tcText;
+ bool changeText = false;
+
+ if ( cell.HasText() && !pg->IsEditorFocused() )
+ {
+ tcText = cell.GetText();
+ changeText = true;
+ }
+ else if ( oCell.HasText() )
+ {
+ tcText = property->GetValueAsString(
+ property->HasFlag(wxPG_PROP_READONLY)?0:wxPG_EDITABLE_VALUE);
+ changeText = true;
+ }
+
+ if ( changeText )
+ {
+ // This prevents value from being modified
+ if ( tc )
+ {
+ pg->SetupTextCtrlValue(tcText);
+ tc->SetValue(tcText);
+ }
+ else
+ {
+ cb->SetText(tcText);
+ }
+ }
+ }
+
+ // Do not make the mistake of calling GetClassDefaultAttributes()
+ // here. It is static, while GetDefaultAttributes() is virtual
+ // and the correct one to use.
+ wxVisualAttributes vattrs = ctrl->GetDefaultAttributes();
+
+ // Foreground colour
+ const wxColour& fgCol = cell.GetFgCol();
+ if ( fgCol.IsOk() )
+ {
+ ctrl->SetForegroundColour(fgCol);
+ }
+ else if ( oCell.GetFgCol().IsOk() )
+ {
+ ctrl->SetForegroundColour(vattrs.colFg);
+ }
+
+ // Background colour
+ const wxColour& bgCol = cell.GetBgCol();
+ if ( bgCol.IsOk() )
+ {
+ ctrl->SetBackgroundColour(bgCol);
+ }
+ else if ( oCell.GetBgCol().IsOk() )
+ {
+ ctrl->SetBackgroundColour(vattrs.colBg);
+ }
+
+ // Font
+ const wxFont& font = cell.GetFont();
+ if ( font.IsOk() )
+ {
+ ctrl->SetFont(font);
+ }
+ else if ( oCell.GetFont().IsOk() )
+ {
+ ctrl->SetFont(vattrs.font);
+ }
+
+ // Also call the old SetValueToUnspecified()
+ if ( unspecified )
+ SetValueToUnspecified(property, ctrl);
+}
+
+void wxPGEditor::SetValueToUnspecified( wxPGProperty* WXUNUSED(property),
+ wxWindow* WXUNUSED(ctrl) ) const
+{
+}
bool wxPGEditor::CanContainCustomImage() const
{
property->GetChildCount() )
return NULL;
- if ( !property->IsValueUnspecified() )
- text = property->GetValueAsString(property->HasFlag(wxPG_PROP_READONLY) ?
- 0 : wxPG_EDITABLE_VALUE);
+ int argFlags = 0;
+ if ( !property->HasFlag(wxPG_PROP_READONLY) &&
+ !property->IsValueUnspecified() )
+ argFlags |= wxPG_EDITABLE_VALUE;
+ text = property->GetValueAsString(argFlags);
int flags = 0;
if ( (property->GetFlags() & wxPG_PROP_PASSWORD) &&
- property->IsKindOf(CLASSINFO(wxStringProperty)) )
+ wxDynamicCast(property, wxStringProperty) )
flags |= wxTE_PASSWORD;
wxWindow* wnd = propGrid->GenerateEditorTextCtrl(pos,sz,text,NULL,flags,
else
s = property->GetDisplayedString();
+ wxPropertyGrid* pg = property->GetGrid();
+
+ pg->SetupTextCtrlValue(s);
tc->SetValue(s);
//
wxTextCtrl* tc = wxStaticCast(ctrl, wxTextCtrl);
wxString textVal = tc->GetValue();
- if ( property->UsesAutoUnspecified() && !textVal.length() )
+ if ( property->UsesAutoUnspecified() && textVal.empty() )
{
variant.MakeNull();
return true;
}
-void wxPGTextCtrlEditor::SetValueToUnspecified( wxPGProperty* property, wxWindow* ctrl ) const
+void wxPGTextCtrlEditor::SetControlStringValue( wxPGProperty* property, wxWindow* ctrl, const wxString& txt ) const
{
wxTextCtrl* tc = wxStaticCast(ctrl, wxTextCtrl);
wxPropertyGrid* pg = property->GetGrid();
wxASSERT(pg); // Really, property grid should exist if editor does
if ( pg )
- tc->SetValue(wxEmptyString);
+ {
+ pg->SetupTextCtrlValue(txt);
+ tc->SetValue(txt);
+ }
}
-void wxPGTextCtrlEditor::SetControlStringValue( wxPGProperty* property, wxWindow* ctrl, const wxString& txt ) const
+void wxPGTextCtrlEditor_OnFocus( wxPGProperty* property,
+ wxTextCtrl* tc )
{
- wxTextCtrl* tc = wxStaticCast(ctrl, wxTextCtrl);
+ // Make sure there is correct text (instead of unspecified value
+ // indicator or hint text)
+ int flags = property->HasFlag(wxPG_PROP_READONLY) ?
+ 0 : wxPG_EDITABLE_VALUE;
+ wxString correctText = property->GetValueAsString(flags);
- wxPropertyGrid* pg = property->GetGrid();
- wxASSERT(pg); // Really, property grid should exist if editor does
- if ( pg )
- tc->SetValue(txt);
-}
+ if ( tc->GetValue() != correctText )
+ {
+ property->GetGrid()->SetupTextCtrlValue(correctText);
+ tc->SetValue(correctText);
+ }
+ tc->SelectAll();
+}
-void wxPGTextCtrlEditor::OnFocus( wxPGProperty*, wxWindow* wnd ) const
+void wxPGTextCtrlEditor::OnFocus( wxPGProperty* property,
+ wxWindow* wnd ) const
{
wxTextCtrl* tc = wxStaticCast(wnd, wxTextCtrl);
-
- tc->SetSelection(-1,-1);
+ wxPGTextCtrlEditor_OnFocus(property, tc);
}
-
-wxPGTextCtrlEditor::~wxPGTextCtrlEditor() { }
+wxPGTextCtrlEditor::~wxPGTextCtrlEditor()
+{
+ // Reset the global pointer. Useful when wxPropertyGrid is accessed
+ // from an external main loop.
+ wxPG_EDITOR(TextCtrl) = NULL;
+}
// -----------------------------------------------------------------------
int evtType = event.GetEventType();
if ( m_property->HasFlag(wxPG_PROP_USE_DCC) &&
- m_property->IsKindOf(CLASSINFO(wxBoolProperty)) &&
+ wxDynamicCast(m_property, wxBoolProperty) &&
!m_combo->IsPopupShown() )
{
// Just check that it is in the text area
int flags ) const
{
wxPropertyGrid* pg = GetGrid();
- pg->OnComboItemPaint( this, item, &dc, (wxRect&)rect, flags );
+
+ // Handle hint text via super class
+ if ( (flags & wxODCB_PAINTING_CONTROL) &&
+ ShouldUseHintText(flags) )
+ {
+ wxOwnerDrawnComboBox::OnDrawItem(dc, rect, item, flags);
+ }
+ else
+ {
+ pg->OnComboItemPaint( this, item, &dc, (wxRect&)rect, flags );
+ }
}
virtual wxCoord OnMeasureItem( size_t item ) const
wxPropertyGrid* GetGrid() const
{
- wxPropertyGrid* pg = wxDynamicCast(GetParent()->GetParent(),
+ wxPropertyGrid* pg = wxDynamicCast(GetParent(),
wxPropertyGrid);
wxASSERT(pg);
return pg;
wxRect& rect,
int flags )
{
- // Sanity check
- wxASSERT( IsKindOf(CLASSINFO(wxPropertyGrid)) );
-
wxPGProperty* p = GetSelection();
wxString text;
const wxBitmap* itemBitmap = NULL;
- if ( item >= 0 && choices.IsOk() && choices.Item(item).GetBitmap().Ok() && comValIndex == -1 )
+ if ( item >= 0 && choices.IsOk() && choices.Item(item).GetBitmap().IsOk() && comValIndex == -1 )
itemBitmap = &choices.Item(item).GetBitmap();
//
if ( pDc )
pDc->SetBrush(*wxWHITE_BRUSH);
+ wxPGCellRenderer* renderer = NULL;
+ const wxPGChoiceEntry* cell = NULL;
+
if ( rect.x >= 0 )
{
//
rect.y + 1);
int renderFlags = wxPGCellRenderer::DontUseCellColours;
+ bool useCustomPaintProcedure;
+
+ // If custom image had some size, we will start from the assumption
+ // that custom paint procedure is required
+ if ( cis.x > 0 )
+ useCustomPaintProcedure = true;
+ else
+ useCustomPaintProcedure = false;
+
+ if ( flags & wxODCB_PAINTING_SELECTED )
+ renderFlags |= wxPGCellRenderer::Selected;
if ( flags & wxODCB_PAINTING_CONTROL )
+ {
renderFlags |= wxPGCellRenderer::Control;
+
+ // If wxPG_PROP_CUSTOMIMAGE was set, then that means any custom
+ // image will not appear on the control row (it may be too
+ // large to fit, for instance). Also do not draw custom image
+ // if no choice was selected.
+ if ( !p->HasFlag(wxPG_PROP_CUSTOMIMAGE) || item < 0 )
+ useCustomPaintProcedure = false;
+ }
else
+ {
renderFlags |= wxPGCellRenderer::ChoicePopup;
- if ( flags & wxODCB_PAINTING_SELECTED )
- renderFlags |= wxPGCellRenderer::Selected;
+ // For consistency, always use normal font when drawing drop down
+ // items
+ dc.SetFont(GetFont());
+ }
+
+ // If not drawing a selected popup item, then give property's
+ // m_valueBitmap a chance.
+ if ( p->m_valueBitmap && item != pCb->GetSelection() )
+ useCustomPaintProcedure = false;
+ // If current choice had a bitmap set by the application, then
+ // use it instead of any custom paint procedure.
+ else if ( itemBitmap )
+ useCustomPaintProcedure = false;
- if ( cis.x > 0 && (p->HasFlag(wxPG_PROP_CUSTOMIMAGE) || !(flags & wxODCB_PAINTING_CONTROL)) &&
- ( !p->m_valueBitmap || item == pCb->GetSelection() ) &&
- ( item >= 0 || (flags & wxODCB_PAINTING_CONTROL) ) &&
- !itemBitmap
- )
+ if ( useCustomPaintProcedure )
{
pt.x += wxCC_CUSTOM_IMAGE_MARGIN1;
wxRect r(pt.x,pt.y,cis.x,cis.y);
if ( comValIndex >= 0 )
{
const wxPGCommonValue* cv = GetCommonValue(comValIndex);
- wxPGCellRenderer* renderer = cv->GetRenderer();
+ renderer = cv->GetRenderer();
r.width = rect.width;
renderer->Render( dc, r, this, p, m_selColumn, comValIndex, renderFlags );
return;
if ( choices.IsOk() && item >= 0 && comValIndex < 0 )
{
- const wxPGChoiceEntry& cell = choices.Item(item);
- wxPGCellRenderer* renderer = wxPGGlobalVars->m_defaultRenderer;
- int imageOffset = renderer->PreDrawCell( dc, rect, cell, renderFlags );
+ cell = &choices.Item(item);
+ renderer = wxPGGlobalVars->m_defaultRenderer;
+ int imageOffset = renderer->PreDrawCell(dc, rect, *cell,
+ renderFlags );
if ( imageOffset )
- imageOffset += wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2;
+ imageOffset += wxCC_CUSTOM_IMAGE_MARGIN1 +
+ wxCC_CUSTOM_IMAGE_MARGIN2;
pt.x += imageOffset;
}
}
pt.x += 1;
dc.DrawText( text, pt.x + wxPG_XBEFORETEXT, pt.y );
+
+ if ( renderer )
+ renderer->PostDrawCell(dc, this, *cell, renderFlags);
}
else
{
wxPGProperty* property = propGrid->GetSelectedProperty();
wxASSERT( property );
+ wxSize imageSize;
+ bool res;
+
+ // TODO: Do this always when cell has custom text.
+ if ( property->IsValueUnspecified() )
+ {
+ cb->SetCustomPaintWidth( 0 );
+ return true;
+ }
+
if ( cmnVal >= 0 )
{
// Yes, a common value is being selected
property->SetCommonValue( cmnVal );
- wxSize imageSize = propGrid->GetCommonValue(cmnVal)->
+ imageSize = propGrid->GetCommonValue(cmnVal)->
GetRenderer()->GetImageSize(property, 1, cmnVal);
- if ( imageSize.x ) imageSize.x += ODCB_CUST_PAINT_MARGIN;
- cb->SetCustomPaintWidth( imageSize.x );
- return false;
+ res = false;
}
else
{
- wxSize imageSize = propGrid->GetImageSize(property, -1);
- if ( imageSize.x ) imageSize.x += ODCB_CUST_PAINT_MARGIN;
- cb->SetCustomPaintWidth( imageSize.x );
- return true;
+ imageSize = propGrid->GetImageSize(property, -1);
+ res = true;
}
+
+ if ( imageSize.x )
+ imageSize.x += ODCB_CUST_PAINT_MARGIN;
+ cb->SetCustomPaintWidth( imageSize.x );
+
+ return res;
}
// CreateControls calls this with CB_READONLY in extraStyle
const wxSize& sz,
long extraStyle ) const
{
+ // Since it is not possible (yet) to create a read-only combo box in
+ // the same sense that wxTextCtrl is read-only, simply do not create
+ // the control in this case.
+ if ( property->HasFlag(wxPG_PROP_READONLY) )
+ return NULL;
+
const wxPGChoices& choices = property->GetChoices();
wxString defString;
int index = property->GetChoiceSelection();
- bool isUnspecified = property->IsValueUnspecified();
-
- if ( !isUnspecified )
- defString = property->GetDisplayedString();
+ int argFlags = 0;
+ if ( !property->HasFlag(wxPG_PROP_READONLY) &&
+ !property->IsValueUnspecified() )
+ argFlags |= wxPG_EDITABLE_VALUE;
+ defString = property->GetValueAsString(argFlags);
wxArrayString labels = choices.GetLabels();
int odcbFlags = extraStyle | wxBORDER_NONE | wxTE_PROCESS_ENTER;
if ( (property->GetFlags() & wxPG_PROP_USE_DCC) &&
- (property->IsKindOf(CLASSINFO(wxBoolProperty)) ) )
+ wxDynamicCast(property, wxBoolProperty) )
odcbFlags |= wxODCB_DCLICK_CYCLES;
//
unsigned int cmnVals = property->GetDisplayedCommonValueCount();
if ( cmnVals )
{
- if ( !isUnspecified )
+ if ( !property->IsValueUnspecified() )
{
int cmnVal = property->GetCommonValue();
if ( cmnVal >= 0 )
cb->SetButtonPosition(si.y,0,wxRIGHT);
cb->SetMargins(wxPG_XBEFORETEXT-1);
- wxPGChoiceEditor_SetCustomPaintWidth( propGrid, cb, property->GetCommonValue() );
+ // Set hint text
+ cb->SetHint(property->GetHintText());
+
+ wxPGChoiceEditor_SetCustomPaintWidth( propGrid, cb,
+ property->GetCommonValue() );
if ( index >= 0 && index < (int)cb->GetCount() )
{
cb->SetSelection( index );
- if ( defString.length() )
+ if ( !defString.empty() )
cb->SetText( defString );
}
- else if ( !(extraStyle & wxCB_READONLY) && defString.length() )
+ else if ( !(extraStyle & wxCB_READONLY) && !defString.empty() )
+ {
+ propGrid->SetupTextCtrlValue(defString);
cb->SetValue( defString );
+ }
else
+ {
cb->SetSelection( -1 );
+ }
#ifdef __WXMSW__
cb->Show();
{
wxASSERT( ctrl );
wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
- wxASSERT( cb->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)));
+ wxASSERT( wxDynamicCast(cb, wxOwnerDrawnComboBox));
int ind = property->GetChoiceSelection();
cb->SetSelection(ind);
}
{
wxASSERT( ctrl );
wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
- wxASSERT( cb->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)));
+ wxASSERT( wxDynamicCast(cb, wxOwnerDrawnComboBox));
if (index < 0)
index = cb->GetCount();
{
wxASSERT( ctrl );
wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
- wxASSERT( cb->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)));
+ wxASSERT( wxDynamicCast(cb, wxOwnerDrawnComboBox));
cb->Delete(index);
}
propGrid->SetInternalFlag(wxPG_FL_VALUE_CHANGE_IN_EVENT);
property->SetValueToUnspecified();
if ( !cb->HasFlag(wxCB_READONLY) )
- cb->GetTextCtrl()->SetValue(wxEmptyString);
+ {
+ wxString unspecValueText;
+ unspecValueText = propGrid->GetUnspecifiedValueText();
+ propGrid->SetupTextCtrlValue(unspecValueText);
+ cb->GetTextCtrl()->SetValue(unspecValueText);
+ }
return false;
}
}
}
-void wxPGChoiceEditor::SetControlStringValue( wxPGProperty* WXUNUSED(property), wxWindow* ctrl, const wxString& txt ) const
+void wxPGChoiceEditor::SetControlStringValue( wxPGProperty* property,
+ wxWindow* ctrl,
+ const wxString& txt ) const
{
wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
wxASSERT( cb );
+ property->GetGrid()->SetupTextCtrlValue(txt);
cb->SetValue(txt);
}
}
-void wxPGChoiceEditor::SetValueToUnspecified( wxPGProperty* WXUNUSED(property), wxWindow* ctrl ) const
+void wxPGChoiceEditor::SetValueToUnspecified( wxPGProperty* WXUNUSED(property),
+ wxWindow* ctrl ) const
{
wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
- cb->SetSelection(-1);
+
+ if ( cb->HasFlag(wxCB_READONLY) )
+ cb->SetSelection(-1);
}
}
-wxPGChoiceEditor::~wxPGChoiceEditor() { }
+wxPGChoiceEditor::~wxPGChoiceEditor()
+{
+ wxPG_EDITOR(Choice) = NULL;
+}
// -----------------------------------------------------------------------
void wxPGComboBoxEditor::UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const
{
wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
- cb->SetValue(property->GetValueAsString(wxPG_EDITABLE_VALUE));
+ wxString s = property->GetValueAsString(wxPG_EDITABLE_VALUE);
+ property->GetGrid()->SetupTextCtrlValue(s);
+ cb->SetValue(s);
// TODO: If string matches any selection, then select that.
}
wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
wxString textVal = cb->GetValue();
- if ( property->UsesAutoUnspecified() && !textVal.length() )
+ if ( property->UsesAutoUnspecified() && textVal.empty() )
{
variant.MakeNull();
return true;
}
-void wxPGComboBoxEditor::OnFocus( wxPGProperty*, wxWindow* ctrl ) const
+void wxPGComboBoxEditor::OnFocus( wxPGProperty* property,
+ wxWindow* ctrl ) const
{
wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
- cb->GetTextCtrl()->SetSelection(-1,-1);
+ wxPGTextCtrlEditor_OnFocus(property, cb->GetTextCtrl());
}
-wxPGComboBoxEditor::~wxPGComboBoxEditor() { }
+wxPGComboBoxEditor::~wxPGComboBoxEditor()
+{
+ wxPG_EDITOR(ComboBox) = NULL;
+}
+
// -----------------------------------------------------------------------
}
-wxPGChoiceAndButtonEditor::~wxPGChoiceAndButtonEditor() { }
-
+wxPGChoiceAndButtonEditor::~wxPGChoiceAndButtonEditor()
+{
+ wxPG_EDITOR(ChoiceAndButton) = NULL;
+}
// -----------------------------------------------------------------------
// wxPGTextCtrlAndButtonEditor
}
-wxPGTextCtrlAndButtonEditor::~wxPGTextCtrlAndButtonEditor() { }
-
+wxPGTextCtrlAndButtonEditor::~wxPGTextCtrlAndButtonEditor()
+{
+ wxPG_EDITOR(TextCtrlAndButton) = NULL;
+}
// -----------------------------------------------------------------------
// wxPGCheckBoxEditor
static void DrawSimpleCheckBox( wxDC& dc, const wxRect& rect, int box_hei,
- int state, const wxColour& lineCol )
+ int state )
{
// Box rectangle.
wxRect r(rect.x+wxPG_XBEFORETEXT,rect.y+((rect.height-box_hei)/2),
box_hei,box_hei);
- wxColour useCol = lineCol;
+ wxColour useCol = dc.GetTextForeground();
if ( state & wxSCB_STATE_UNSPECIFIED )
{
wxSimpleCheckBox::~wxSimpleCheckBox()
{
- delete ms_doubleBuffer;
- ms_doubleBuffer = NULL;
+ wxDELETE(ms_doubleBuffer);
}
wxBitmap* wxSimpleCheckBox::ms_doubleBuffer = NULL;
dc.SetPen( bgcol );
dc.DrawRectangle( rect );
- wxColour txcol = GetForegroundColour();
+ dc.SetTextForeground(GetForegroundColour());
int state = m_state;
if ( !(state & wxSCB_STATE_UNSPECIFIED) &&
GetFont().GetWeight() == wxBOLD )
state |= wxSCB_STATE_BOLD;
- DrawSimpleCheckBox(dc,rect,m_boxHeight,state,txcol);
+ DrawSimpleCheckBox(dc, rect, m_boxHeight, state);
}
void wxSimpleCheckBox::OnLeftClick( wxMouseEvent& event )
wxCommandEvent evt(wxEVT_COMMAND_CHECKBOX_CLICKED,GetParent()->GetId());
- wxPropertyGrid* propGrid = (wxPropertyGrid*) GetParent()->GetParent();
- wxASSERT( propGrid->IsKindOf(CLASSINFO(wxPropertyGrid)) );
+ wxPropertyGrid* propGrid = (wxPropertyGrid*) GetParent();
+ wxASSERT( wxDynamicCast(propGrid, wxPropertyGrid) );
propGrid->HandleCustomEditorEvent(evt);
}
const wxPoint& pos,
const wxSize& size ) const
{
+ if ( property->HasFlag(wxPG_PROP_READONLY) )
+ return NULL;
+
wxPoint pt = pos;
pt.x -= wxPG_XBEFOREWIDGET;
wxSize sz = size;
// If mouse cursor was on the item, toggle the value now.
if ( propGrid->GetInternalFlags() & wxPG_FL_ACTIVATION_BY_CLICK )
{
- wxPoint pt = cb->ScreenToClient(::wxGetMousePosition());
- if ( pt.x <= (wxPG_XBEFORETEXT-2+cb->m_boxHeight) )
+ wxPoint point = cb->ScreenToClient(::wxGetMousePosition());
+ if ( point.x <= (wxPG_XBEFORETEXT-2+cb->m_boxHeight) )
{
if ( cb->m_state & wxSCB_STATE_CHECKED )
cb->m_state &= ~wxSCB_STATE_CHECKED;
const wxString& WXUNUSED(text) ) const
{
int state = wxSCB_STATE_UNCHECKED;
- wxColour rectCol = dc.GetTextForeground();
if ( !property->IsValueUnspecified() )
{
state |= wxSCB_STATE_UNSPECIFIED;
}
- DrawSimpleCheckBox(dc, rect, dc.GetCharHeight(), state, rectCol);
+ DrawSimpleCheckBox(dc, rect, dc.GetCharHeight(), state);
}
void wxPGCheckBoxEditor::UpdateControl( wxPGProperty* property,
void wxPGCheckBoxEditor::SetValueToUnspecified( wxPGProperty* WXUNUSED(property), wxWindow* ctrl ) const
{
- ((wxSimpleCheckBox*)ctrl)->m_state = 0;
+ ((wxSimpleCheckBox*)ctrl)->m_state = wxSCB_STATE_UNSPECIFIED;
ctrl->Refresh();
}
-wxPGCheckBoxEditor::~wxPGCheckBoxEditor() { }
-
+wxPGCheckBoxEditor::~wxPGCheckBoxEditor()
+{
+ wxPG_EDITOR(CheckBox) = NULL;
+}
#endif // wxPG_INCLUDE_CHECKBOX
void wxPropertyGrid::CorrectEditorWidgetSizeX()
{
int secWid = 0;
- int newSplitterx = m_pState->DoGetSplitterPosition(m_selColumn-1);
- int newWidth = newSplitterx + m_pState->m_colWidths[m_selColumn];
+
+ // Use fixed selColumn 1 for main editor widgets
+ int newSplitterx = m_pState->DoGetSplitterPosition(0);
+ int newWidth = newSplitterx + m_pState->m_colWidths[1];
if ( m_wndEditor2 )
{
#ifdef __WXMAC__
if ( m_wndEditor )
#else
- if ( m_wndEditor && m_wndEditor->IsKindOf(CLASSINFO(wxTextCtrl)) )
+ if ( wxDynamicCast(m_wndEditor, wxTextCtrl) )
#endif
secWid += wxPG_TEXTCTRL_AND_BUTTON_SPACING;
}
void wxPropertyGrid::CorrectEditorWidgetPosY()
{
- if ( GetSelection() && (m_wndEditor || m_wndEditor2) )
- {
- wxRect r = GetEditorWidgetRect(GetSelection(), m_selColumn);
+ wxPGProperty* selected = GetSelection();
- if ( m_wndEditor )
+ if ( selected )
+ {
+ if ( m_labelEditor )
{
- wxPoint pos = m_wndEditor->GetPosition();
+ wxRect r = GetEditorWidgetRect(selected, m_selColumn);
+ wxPoint pos = m_labelEditor->GetPosition();
// Calculate y offset
int offset = pos.y % m_lineHeight;
- m_wndEditor->Move(pos.x, r.y + offset);
+ m_labelEditor->Move(pos.x, r.y + offset);
}
- if ( m_wndEditor2 )
+ if ( m_wndEditor || m_wndEditor2 )
{
- wxPoint pos = m_wndEditor2->GetPosition();
+ wxRect r = GetEditorWidgetRect(selected, 1);
+
+ if ( m_wndEditor )
+ {
+ wxPoint pos = m_wndEditor->GetPosition();
+
+ // Calculate y offset
+ int offset = pos.y % m_lineHeight;
+
+ m_wndEditor->Move(pos.x, r.y + offset);
+ }
- m_wndEditor2->Move(pos.x, r.y);
+ if ( m_wndEditor2 )
+ {
+ wxPoint pos = m_wndEditor2->GetPosition();
+
+ m_wndEditor2->Move(pos.x, r.y);
+ }
}
}
}
SetupTextCtrlValue(value);
tc->Create(ctrlParent,id,value, p, s,tcFlags);
+#if defined(__WXMSW__)
+ // On Windows, we need to override read-only text ctrl's background
+ // colour to white. One problem with native 'grey' background is that
+ // tc->GetBackgroundColour() doesn't seem to return correct value
+ // for it.
+ if ( tcFlags & wxTE_READONLY )
+ {
+ wxVisualAttributes vattrs = tc->GetDefaultAttributes();
+ tc->SetBackgroundColour(vattrs.colBg);
+ }
+#endif
+
+ // This code is repeated from DoSelectProperty(). However, font boldness
+ // must be set before margin is set up below in FixPosForTextCtrl().
+ if ( forColumn == 1 &&
+ prop->HasFlag(wxPG_PROP_MODIFIED) &&
+ HasFlag(wxPG_BOLD_MODIFIED) )
+ tc->SetFont( m_captionFont );
+
// Center the control vertically
if ( !hasSpecialSize )
FixPosForTextCtrl(tc, forColumn);
tc->AutoComplete(attrVal.GetArrayString());
}
+ // Set hint text
+ tc->SetHint(prop->GetHintText());
+
return tc;
}
// -----------------------------------------------------------------------
+void wxPropertyGrid::SetEditorAppearance( const wxPGCell& cell,
+ bool unspecified )
+{
+ wxPGProperty* property = GetSelection();
+ if ( !property )
+ return;
+ wxWindow* ctrl = GetEditorControl();
+ if ( !ctrl )
+ return;
+
+ property->GetEditorClass()->SetControlAppearance( this,
+ property,
+ ctrl,
+ cell,
+ m_editorAppearance,
+ unspecified );
+
+ m_editorAppearance = cell;
+}
+
+// -----------------------------------------------------------------------
+
wxTextCtrl* wxPropertyGrid::GetEditorTextCtrl() const
{
wxWindow* wnd = GetEditorControl();
if ( !wnd )
return NULL;
- if ( wnd->IsKindOf(CLASSINFO(wxTextCtrl)) )
+ if ( wxDynamicCast(wnd, wxTextCtrl) )
return wxStaticCast(wnd, wxTextCtrl);
- if ( wnd->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) )
+ if ( wxDynamicCast(wnd, wxOwnerDrawnComboBox) )
{
wxOwnerDrawnComboBox* cb = wxStaticCast(wnd, wxOwnerDrawnComboBox);
return cb->GetTextCtrl();
Move( pos.x + m_fullEditorSize.x - m_buttonsWidth, pos.y );
}
-int wxPGMultiButton::GenId( int id ) const
+int wxPGMultiButton::GenId( int itemid ) const
{
- if ( id < -1 )
+ if ( itemid < -1 )
{
if ( m_buttons.size() )
- id = GetButton(m_buttons.size()-1)->GetId() + 1;
+ itemid = GetButton(m_buttons.size()-1)->GetId() + 1;
else
- id = wxPG_SUBID2;
+ itemid = wxPG_SUBID2;
}
- return id;
+ return itemid;
}
#if wxUSE_BMPBUTTON
-void wxPGMultiButton::Add( const wxBitmap& bitmap, int id )
+void wxPGMultiButton::Add( const wxBitmap& bitmap, int itemid )
{
- id = GenId(id);
+ itemid = GenId(itemid);
wxSize sz = GetSize();
- wxButton* button = new wxBitmapButton( this, id, bitmap,
+ wxButton* button = new wxBitmapButton( this, itemid, bitmap,
wxPoint(sz.x, 0),
wxSize(sz.y, sz.y) );
DoAddButton( button, sz );
}
#endif
-void wxPGMultiButton::Add( const wxString& label, int id )
+void wxPGMultiButton::Add( const wxString& label, int itemid )
{
- id = GenId(id);
+ itemid = GenId(itemid);
wxSize sz = GetSize();
- wxButton* button = new wxButton( this, id, label, wxPoint(sz.x, 0),
+ wxButton* button = new wxButton( this, itemid, label, wxPoint(sz.x, 0),
wxSize(sz.y, sz.y) );
DoAddButton( button, sz );
}
projects / wxWidgets.git / blobdiff