//#define wxPG_TEXT_INDENT 4 // For the wxComboControl
-#define wxPG_ALLOW_CLIPPING 1 // If 1, GetUpdateRegion() in OnPaint event handler is not ignored
+//#define wxPG_ALLOW_CLIPPING 1 // If 1, GetUpdateRegion() in OnPaint event handler is not ignored
#define wxPG_GUTTER_DIV 3 // gutter is max(iconwidth/gutter_div,gutter_min)
#define wxPG_GUTTER_MIN 3 // gutter before and after image of [+] or [-]
#define wxPG_YSPACING_MIN 1
#define wxPG_DEFAULT_VSPACING 2 // This matches .NET propertygrid's value,
// but causes normal combobox to spill out under MSW
-#define wxPG_OPTIMAL_WIDTH 200 // Arbitrary
+//#define wxPG_OPTIMAL_WIDTH 200 // Arbitrary
-#define wxPG_MIN_SCROLLBAR_WIDTH 10 // Smallest scrollbar width on any platform
+//#define wxPG_MIN_SCROLLBAR_WIDTH 10 // Smallest scrollbar width on any platform
// Must be larger than largest control border
// width * 2.
//#define wxPG_NAT_CHOICE_BORDER_ANY 0
-#define wxPG_HIDER_BUTTON_HEIGHT 25
+//#define wxPG_HIDER_BUTTON_HEIGHT 25
#define wxPG_PIXELS_PER_UNIT m_lineHeight
#define m_iconHeight m_iconWidth
#endif
-#define wxPG_TOOLTIP_DELAY 1000
+//#define wxPG_TOOLTIP_DELAY 1000
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
-const wxChar *wxPropertyGridNameStr = wxT("wxPropertyGrid");
+const char wxPropertyGridNameStr[] = "wxPropertyGrid";
// -----------------------------------------------------------------------
// Statics in one class for easy destruction.
IMPLEMENT_DYNAMIC_CLASS(wxPGGlobalVarsClassManager, wxModule)
-wxPGGlobalVarsClass* wxPGGlobalVars = (wxPGGlobalVarsClass*) NULL;
+wxPGGlobalVarsClass* wxPGGlobalVars = NULL;
wxPGGlobalVarsClass::wxPGGlobalVarsClass()
m_boolChoices.Add(_("False"));
m_boolChoices.Add(_("True"));
- m_fontFamilyChoices = (wxPGChoices*) NULL;
+ m_fontFamilyChoices = NULL;
m_defaultRenderer = new wxPGDefaultRenderer();
}
void OnPaint( wxPaintEvent& event );
-
+
// Always be focussable, even with child windows
virtual void SetCanFocus(bool WXUNUSED(canFocus))
{ wxPanel::SetCanFocus(true); }
-
+
private:
DECLARE_EVENT_TABLE()
// Update everything inside the box
wxRect r = GetUpdateRegion().GetBox();
+ // FIXME: This is just a workaround for a bug that causes splitters not
+ // to paint when other windows are being dragged over the grid.
+ wxRect fullRect = GetRect();
+ r.x = fullRect.x;
+ r.width = fullRect.width;
+
// Repaint this rectangle
pg->DrawItems( dc, r.y, r.y + r.height, &r );
const wxPoint& pos,
const wxSize& size,
long style,
- const wxChar* name )
+ const wxString& name )
: wxScrolledWindow()
{
Init1();
const wxPoint& pos,
const wxSize& size,
long style,
- const wxChar* name )
+ const wxString& name )
{
if ( !(style&wxBORDER_MASK) )
wxPropertyGrid::RegisterDefaultEditors();
m_iFlags = 0;
- m_pState = (wxPropertyGridPageState*) NULL;
- m_wndEditor = m_wndEditor2 = (wxWindow*) NULL;
- m_selected = (wxPGProperty*) NULL;
+ m_pState = NULL;
+ m_wndEditor = m_wndEditor2 = NULL;
+ m_selected = NULL;
m_selColumn = -1;
- m_propHover = (wxPGProperty*) NULL;
+ m_propHover = NULL;
m_eventObject = this;
- m_curFocused = (wxWindow*) NULL;
+ m_curFocused = NULL;
m_tlwHandler = NULL;
+ m_sortFunction = NULL;
m_inDoPropertyChanged = 0;
m_inCommitChangesFromEditor = 0;
m_inDoSelectProperty = 0;
m_canvas = NULL;
#if wxPG_DOUBLE_BUFFER
- m_doubleBuffer = (wxBitmap*) NULL;
+ m_doubleBuffer = NULL;
#endif
#ifndef wxPG_ICON_WIDTH
#ifdef __WXMAC__
// Smaller controls on Mac
SetWindowVariant(wxWINDOW_VARIANT_SMALL);
-#endif
+#endif
// Now create state, if one didn't exist already
// (wxPropertyGridManager might have created it for us).
// adjust bitmap icon y position so they are centered
m_vspacing = wxPG_DEFAULT_VSPACING;
- if ( !m_font.Ok() )
- {
- wxFont useFont = wxScrolledWindow::GetFont();
- wxScrolledWindow::SetOwnFont( useFont );
- }
- else
- {
- // This should be otherwise called by SetOwnFont
- CalculateFontAndBitmapStuff( wxPG_DEFAULT_VSPACING );
- }
+ CalculateFontAndBitmapStuff( wxPG_DEFAULT_VSPACING );
// Allocate cell datas indirectly by calling setter
m_propertyDefaultCell.SetBgCol(*wxBLACK);
delete m_doubleBuffer;
#endif
- //m_selected = (wxPGProperty*) NULL;
+ //m_selected = NULL;
if ( m_iFlags & wxPG_FL_CREATEDSTATE )
delete m_pState;
//
// Tooltips disabled
//
- m_canvas->SetToolTip( (wxToolTip*) NULL );
+ m_canvas->SetToolTip( NULL );
}
#endif
}
void wxPropertyGrid::RegainColours()
{
- wxColour def_bgcol = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOW );
-
if ( !(m_coloursCustomized & 0x0002) )
{
wxColour col = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE );
bool wxPropertyGrid::SetFont( const wxFont& font )
{
// Must disable active editor.
- if ( m_selected )
- {
- bool selRes = ClearSelection();
- wxPG_CHECK_MSG_DBG( selRes,
- false,
- wxT("failed to deselect a property (editor probably had invalid value)") );
- }
+ ClearSelection(false);
- // TODO: Following code is disabled with wxMac because
- // it is reported to fail. I (JMS) cannot debug it
- // personally right now.
- // CS: should be fixed now, leaving old code in just in case, TODO: REMOVE
-#if 1 // !defined(__WXMAC__)
bool res = wxScrolledWindow::SetFont( font );
if ( res )
{
CalculateFontAndBitmapStuff( m_vspacing );
-
- if ( m_pState )
- m_pState->CalculateFontAndBitmapStuff(m_vspacing);
-
Refresh();
}
return res;
-#else
- // ** wxMAC Only **
- // TODO: Remove after SetFont crash fixed.
- if ( m_iFlags & wxPG_FL_INITIALIZED )
- {
- wxLogDebug(wxT("WARNING: propGrid.cpp: wxPropertyGrid::SetFont has been disabled on wxMac since there has been crash reported in it. If you are willing to debug the cause, replace line '#if !defined(__WXMAC__)' with line '#if 1' in wxPropertyGrid::SetFont."));
- }
- return false;
-#endif
}
// -----------------------------------------------------------------------
Refresh();
}
-// -----------------------------------------------------------------------
-
-void wxPropertyGrid::SetPropertyBackgroundColour( wxPGPropArg id,
- const wxColour& colour,
- bool recursively )
-{
- wxPG_PROP_ARG_CALL_PROLOG()
- p->SetBackgroundColour( colour, recursively );
- DrawItemAndChildren( p );
-}
-
-// -----------------------------------------------------------------------
-
-wxColour wxPropertyGrid::GetPropertyBackgroundColour( wxPGPropArg id ) const
-{
- wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxColour())
-
- return p->GetCell(0).GetBgCol();
-}
-
-// -----------------------------------------------------------------------
-
-void wxPropertyGrid::SetPropertyTextColour( wxPGPropArg id, const wxColour& colour,
- bool recursively )
-{
- wxPG_PROP_ARG_CALL_PROLOG()
- p->SetTextColour( colour, recursively );
- DrawItemAndChildren( p );
-}
-
-// -----------------------------------------------------------------------
-
-wxColour wxPropertyGrid::GetPropertyTextColour( wxPGPropArg id ) const
-{
- wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxColour())
-
- return p->GetCell(0).GetFgCol();
-}
-
-// -----------------------------------------------------------------------
-
-void wxPropertyGrid::SetPropertyColoursToDefault( wxPGPropArg id )
-{
- wxPG_PROP_ARG_CALL_PROLOG()
-
- p->m_cells.clear();
-}
-
// -----------------------------------------------------------------------
// wxPropertyGrid property adding and removal
// -----------------------------------------------------------------------
m_pState->m_itemsAdded = 0;
if ( m_windowStyle & wxPG_AUTO_SORT )
- Sort();
+ Sort(wxPG_SORT_TOP_LEVEL_ONLY);
RecalculateVirtualSize();
}
-// -----------------------------------------------------------------------
-// wxPropertyGrid property value setting and getting
-// -----------------------------------------------------------------------
-
-void wxPropertyGrid::DoSetPropertyValueUnspecified( wxPGProperty* p )
-{
- m_pState->DoSetPropertyValueUnspecified(p);
- DrawItemAndChildren(p);
-
- wxPGProperty* parent = p->GetParent();
- while ( parent &&
- (parent->GetFlags() & wxPG_PROP_PARENTAL_FLAGS) == wxPG_PROP_MISC_PARENT )
- {
- DrawItem(parent);
- parent = parent->GetParent();
- }
-}
-
// -----------------------------------------------------------------------
// wxPropertyGrid property operations
// -----------------------------------------------------------------------
dst_str.clear();
- for ( ; i != src_str.end(); i++ )
+ for ( ; i != src_str.end(); ++i )
{
wxUniChar a = *i;
dst_str.clear();
- for ( ; i != src_str.end(); i++ )
+ for ( ; i != src_str.end(); ++i )
{
wxChar a = *i;
{
// Outside?
if ( y < 0 )
- return (wxPGProperty*) NULL;
+ return NULL;
unsigned int a = 0;
return m_pState->m_properties->GetItemAtY(y, m_lineHeight, &a);
if ( dcPtr )
{
dc.SetClippingRegion( *clipRect );
- paintFinishY = DoDrawItems( *dcPtr, NULL, NULL, clipRect, isBuffered );
+ paintFinishY = DoDrawItems( *dcPtr, clipRect, isBuffered );
}
#if wxPG_DOUBLE_BUFFER
// -----------------------------------------------------------------------
int wxPropertyGrid::DoDrawItems( wxDC& dc,
- const wxPGProperty* firstItem,
- const wxPGProperty* lastItem,
const wxRect* clipRect,
bool isBuffered ) const
{
- // TODO: This should somehow be eliminated.
- wxRect tempClipRect;
- if ( !clipRect )
- {
- wxASSERT(firstItem);
- wxASSERT(lastItem);
- tempClipRect = GetPropertyRect(firstItem, lastItem);
- clipRect = &tempClipRect;
- }
+ const wxPGProperty* firstItem;
+ const wxPGProperty* lastItem;
- if ( !firstItem )
- firstItem = DoGetItemAtY(clipRect->y);
+ firstItem = DoGetItemAtY(clipRect->y);
+ lastItem = DoGetItemAtY(clipRect->y+clipRect->height-1);
if ( !lastItem )
- {
- lastItem = DoGetItemAtY(clipRect->y+clipRect->height-1);
- if ( !lastItem )
- lastItem = GetLastItem( wxPG_ITERATE_VISIBLE );
- }
+ lastItem = GetLastItem( wxPG_ITERATE_VISIBLE );
if ( m_frozen || m_height < 1 || firstItem == NULL )
return clipRect->y;
//
// clipRect conversion
- if ( clipRect )
- {
- cr2 = *clipRect;
- cr2.x -= xRelMod;
- cr2.y -= yRelMod;
- clipRect = &cr2;
- }
+ cr2 = *clipRect;
+ cr2.x -= xRelMod;
+ cr2.y -= yRelMod;
+ clipRect = &cr2;
firstItemTopY -= yRelMod;
lastItemBottomY -= yRelMod;
}
int x = m_marginWidth - xRelMod;
- const wxFont& normalfont = m_font;
+ wxFont normalFont = GetFont();
- bool reallyFocused = (m_iFlags & wxPG_FL_FOCUSED) ? true : false;
+ bool reallyFocused = (m_iFlags & wxPG_FL_FOCUSED) != 0;
bool isEnabled = IsEnabled();
// TODO: Only render columns that are within clipping region.
- dc.SetFont(normalfont);
+ dc.SetFont(normalFont);
wxPropertyGridConstIterator it( state, wxPG_ITERATE_VISIBLE, firstItem );
int endScanBottomY = lastItemBottomY + lh;
}
else
{
- renderFlags |= wxPGCellRenderer::Selected;
+ renderFlags |= wxPGCellRenderer::Selected;
- if ( !p->IsCategory() )
- {
+ if ( !p->IsCategory() )
+ {
renderFlags |= wxPGCellRenderer::DontUseCellFgCol |
wxPGCellRenderer::DontUseCellBgCol;
unsigned int ci;
int cellX = x + 1;
- int nextCellWidth = state->m_colWidths[0];
+ int nextCellWidth = state->m_colWidths[0] -
+ (greyDepthX - m_marginWidth);
wxRect cellRect(greyDepthX+1, y, 0, rowHeight-1);
int textXAdd = textMarginHere - greyDepthX;
cellX += state->m_colWidths[ci];
if ( ci < (state->m_colWidths.size()-1) )
nextCellWidth = state->m_colWidths[ci+1];
- cellRect.x = cellX;
+ cellRect.x = cellX;
dc.DestroyClippingRegion(); // Is this really necessary?
textXAdd = 0;
}
}
if ( fontChanged )
- dc.SetFont(normalfont);
+ dc.SetFont(normalFont);
y += rowHeight;
}
if ( m_width < 10 || m_height < 10 ||
!m_pState->m_properties->GetChildCount() ||
- p1 == (wxPGProperty*) NULL )
+ p1 == NULL )
return wxRect(0,0,0,0);
int vy = 0;
if ( m_pState->m_itemsAdded || m_frozen )
return;
- wxWindow* wndPrimary = GetEditorControl();
-
// Update child control.
if ( m_selected && m_selected->GetParent() == p )
- m_selected->UpdateControl(wndPrimary);
+ RefreshEditor();
const wxPGProperty* lastDrawn = p->GetLastVisibleSubItem();
void wxPropertyGrid::Clear()
{
- if ( m_selected )
- {
- bool selRes = DoSelectProperty(NULL, wxPG_SEL_DELETING); // This must be before state clear
- wxPG_CHECK_RET_DBG( selRes,
- wxT("failed to deselect a property (editor probably had invalid value)") );
- }
-
m_pState->DoClear();
m_propHover = NULL;
bool wxPropertyGrid::EnableCategories( bool enable )
{
- if ( !ClearSelection() )
- return false;
+ ClearSelection(false);
if ( enable )
{
wxPGProperty* oldSelection = m_selected;
- // Deselect
- if ( m_selected )
- {
- bool selRes = ClearSelection();
- wxPG_CHECK_RET_DBG( selRes,
- wxT("failed to deselect a property (editor probably had invalid value)") );
- }
+ ClearSelection(false);
m_pState->m_selected = oldSelection;
pNewState->OnClientWidthChange( pgWidth, pgWidth - pNewState->m_width );
}
- m_propHover = (wxPGProperty*) NULL;
+ m_propHover = NULL;
// If necessary, convert state to correct mode.
if ( orig_mode != new_state_mode )
else if ( !m_frozen )
{
// Refresh, if not frozen.
- if ( m_pState->m_itemsAdded )
- PrepareAfterItemsAdded();
+ m_pState->PrepareAfterItemsAdded();
// Reselect
if ( m_pState->m_selected )
// -----------------------------------------------------------------------
-void wxPropertyGrid::SortChildren( wxPGPropArg id )
-{
- wxPG_PROP_ARG_CALL_PROLOG()
-
- m_pState->SortChildren( p );
-}
-
-// -----------------------------------------------------------------------
-
-void wxPropertyGrid::Sort()
-{
- bool selRes = ClearSelection(); // This must be before state clear
- wxPG_CHECK_RET_DBG( selRes,
- wxT("failed to deselect a property (editor probably had invalid value)") );
-
- m_pState->Sort();
-}
-
-// -----------------------------------------------------------------------
-
// Call to SetSplitterPosition will always disable splitter auto-centering
// if parent window is shown.
void wxPropertyGrid::DoSetSplitterPosition_( int newxpos, bool refresh, int splitterIndex, bool allPages )
// Don't do this if already processing editor event. It might
// induce recursive dialogs and crap like that.
- if ( m_iFlags & wxPG_FL_IN_ONCUSTOMEDITOREVENT )
+ if ( m_iFlags & wxPG_FL_IN_HANDLECUSTOMEDITOREVENT )
{
if ( m_inDoPropertyChanged )
return true;
// -----------------------------------------------------------------------
+bool wxPropertyGrid::OnValidationFailure( wxPGProperty* property,
+ wxVariant& invalidValue )
+{
+ wxWindow* editor = GetEditorControl();
+
+ // First call property's handler
+ property->OnValidationFailure(invalidValue);
+
+ bool res = DoOnValidationFailure(property, invalidValue);
+
+ //
+ // For non-wxTextCtrl editors, we do need to revert the value
+ if ( !editor->IsKindOf(CLASSINFO(wxTextCtrl)) &&
+ property == m_selected )
+ {
+ property->GetEditorClass()->UpdateControl(property, editor);
+ }
+
+ property->SetFlag(wxPG_PROP_INVALID_VALUE);
+
+ return res;
+}
+
bool wxPropertyGrid::DoOnValidationFailure( wxPGProperty* property, wxVariant& WXUNUSED(invalidValue) )
{
int vfb = m_validationInfo.m_failureBehavior;
// control.
if ( selFlags & wxPG_SEL_DIALOGVAL )
{
- if ( editor )
- p->GetEditorClass()->UpdateControl(p, editor);
+ RefreshEditor();
}
else
{
// -----------------------------------------------------------------------
-bool wxPropertyGrid::ProcessEvent(wxEvent& event)
-{
- wxWindow* wnd = (wxWindow*) event.GetEventObject();
- if ( wnd && wnd->IsKindOf(CLASSINFO(wxWindow)) )
- {
- wxWindow* parent = wnd->GetParent();
-
- if ( parent &&
- (parent == m_canvas ||
- parent->GetParent() == m_canvas) )
- {
- OnCustomEditorEvent(event);
- return true;
- }
- }
- return wxPanel::ProcessEvent(event);
-}
-
-// -----------------------------------------------------------------------
-
-void wxPropertyGrid::OnCustomEditorEvent( wxEvent &event )
+void wxPropertyGrid::HandleCustomEditorEvent( wxEvent &event )
{
wxPGProperty* selected = m_selected;
if ( !selected )
return;
- if ( m_iFlags & wxPG_FL_IN_ONCUSTOMEDITOREVENT )
+ if ( m_iFlags & wxPG_FL_IN_HANDLECUSTOMEDITOREVENT )
return;
wxVariant pendingValue(selected->GetValueRef());
m_prevTcValue = newTcValue;
}
- SetInternalFlag(wxPG_FL_IN_ONCUSTOMEDITOREVENT);
+ SetInternalFlag(wxPG_FL_IN_HANDLECUSTOMEDITOREVENT);
bool validationFailure = false;
bool buttonWasHandled = false;
else
{
// No value after all
-
+
// Regardless of editor type, unfocus editor on
// text-editing related enter press.
if ( event.GetEventType() == wxEVT_COMMAND_TEXT_ENTER )
}
}
- ClearInternalFlag(wxPG_FL_IN_ONCUSTOMEDITOREVENT);
+ ClearInternalFlag(wxPG_FL_IN_HANDLECUSTOMEDITOREVENT);
}
// -----------------------------------------------------------------------
}
// -----------------------------------------------------------------------
-// wxPropertyGrid property selection
+// wxPropertyGrid property selection, editor creation
// -----------------------------------------------------------------------
+//
+// This class forwards events from property editor controls to wxPropertyGrid.
+class wxPropertyGridEditorEventForwarder : public wxEvtHandler
+{
+public:
+ wxPropertyGridEditorEventForwarder( wxPropertyGrid* propGrid )
+ : wxEvtHandler(), m_propGrid(propGrid)
+ {
+ }
+
+ virtual ~wxPropertyGridEditorEventForwarder()
+ {
+ }
+
+private:
+ bool ProcessEvent( wxEvent& event )
+ {
+ // Always skip
+ event.Skip();
+
+ m_propGrid->HandleCustomEditorEvent(event);
+
+ return wxEvtHandler::ProcessEvent(event);
+ }
+
+ wxPropertyGrid* m_propGrid;
+};
+
// Setups event handling for child control
void wxPropertyGrid::SetupChildEventHandling( wxWindow* argWnd )
{
NULL, this);
}
+ wxPropertyGridEditorEventForwarder* forwarder;
+ forwarder = new wxPropertyGridEditorEventForwarder(this);
+ argWnd->PushEventHandler(forwarder);
+
argWnd->Connect(id, wxEVT_KEY_DOWN,
wxCharEventHandler(wxPropertyGrid::OnChildKeyDown),
NULL, this);
// Do not free editors immediately if processing events
if ( m_wndEditor2 )
{
+ wxEvtHandler* handler = m_wndEditor2->PopEventHandler(false);
m_wndEditor2->Hide();
+ wxPendingDelete.Append( handler );
wxPendingDelete.Append( m_wndEditor2 );
- m_wndEditor2 = (wxWindow*) NULL;
+ m_wndEditor2 = NULL;
}
if ( m_wndEditor )
{
+ wxEvtHandler* handler = m_wndEditor->PopEventHandler(false);
m_wndEditor->Hide();
+ wxPendingDelete.Append( handler );
wxPendingDelete.Append( m_wndEditor );
- m_wndEditor = (wxWindow*) NULL;
+ m_wndEditor = NULL;
}
}
wxPrintf( "Selected %s\n", m_selected->GetClassInfo()->GetClassName() );
else
wxPrintf( "None selected\n" );
-
+
if (p)
wxPrintf( "P = %s\n", p->GetClassInfo()->GetClassName() );
else
wxPrintf( "P = NULL\n" );
*/
-
+
// If we are frozen, then just set the values.
if ( m_frozen )
{
FreeEditors();
// Prevent any further selection measures in this call
- p = (wxPGProperty*) NULL;
+ p = NULL;
}
else
{
FreeEditors();
m_selColumn = -1;
- m_selected = (wxPGProperty*) NULL;
- m_pState->m_selected = (wxPGProperty*) NULL;
+ m_selected = NULL;
+ m_pState->m_selected = NULL;
// We need to always fully refresh the grid here
Refresh(false);
if ( p != prev )
m_iFlags &= ~(wxPG_FL_VALIDATION_FAILED);
- wxASSERT( m_wndEditor == (wxWindow*) NULL );
-
- // Do we need OnMeasureCalls?
- wxSize imsz = p->OnMeasureImage();
+ wxASSERT( m_wndEditor == NULL );
//
// Only create editor for non-disabled non-caption
if ( !(GetExtraStyle() & wxPG_EX_HELP_AS_TOOLTIPS) )
{
- wxStatusBar* statusbar = (wxStatusBar*) NULL;
+ wxStatusBar* statusbar = NULL;
if ( !(m_iFlags & wxPG_FL_NOSTATUSBARHELP) )
{
wxFrame* frame = wxDynamicCast(::wxGetTopLevelParent(this),wxFrame);
// -----------------------------------------------------------------------
+void wxPropertyGrid::RefreshEditor()
+{
+ wxPGProperty* p = m_selected;
+ if ( !p )
+ return;
+
+ wxWindow* wnd = GetEditorControl();
+ if ( !wnd )
+ return;
+
+ // Set editor font boldness - must do this before
+ // calling UpdateControl().
+ if ( HasFlag(wxPG_BOLD_MODIFIED) )
+ {
+ if ( p->HasFlag(wxPG_PROP_MODIFIED) )
+ wnd->SetFont(GetCaptionFont());
+ else
+ wnd->SetFont(GetFont());
+ }
+
+ const wxPGEditor* editorClass = p->GetEditorClass();
+
+ editorClass->UpdateControl(p, wnd);
+
+ if ( p->IsValueUnspecified() )
+ editorClass ->SetValueToUnspecified(p, wnd);
+}
+
+// -----------------------------------------------------------------------
+
// This method is not inline because it called dozens of times
// (i.e. two-arg function calls create smaller code size).
bool wxPropertyGrid::DoClearSelection()
{
- return DoSelectProperty((wxPGProperty*)NULL);
+ return DoSelectProperty(NULL);
}
// -----------------------------------------------------------------------
wxPGProperty* pwc = wxStaticCast(p, wxPGProperty);
// If active editor was inside collapsed section, then disable it
- if ( m_selected && m_selected->IsSomeParent (p) )
+ if ( m_selected && m_selected->IsSomeParent(p) )
{
- if ( !ClearSelection() )
- return false;
+ ClearSelection(false);
}
// Store dont-center-splitter flag 'cause we need to temporarily set it
}
// Clear dont-center-splitter flag if it wasn't set
- m_iFlags = m_iFlags & ~(wxPG_FL_DONT_CENTER_SPLITTER) | old_flag;
+ m_iFlags = (m_iFlags & ~wxPG_FL_DONT_CENTER_SPLITTER) | old_flag;
return res;
}
( m_selected == p || m_selected->IsSomeParent(p) )
)
{
- if ( !ClearSelection() )
- return false;
+ ClearSelection(false);
}
m_pState->DoHideProperty(p, hide, flags);
if ( by1 != by2 )
{
wxString s = wxString::Format(wxT("VirtualHeight=%i, ActualVirtualHeight=%i, should match!"), by1, by2);
- wxASSERT_MSG( false,
- s.c_str() );
+ wxFAIL_MSG(s.c_str());
wxLogDebug(s);
}
#endif
else if ( xPos > (xAmount-(width/wxPG_PIXELS_PER_UNIT)) )
xPos = 0;
- int yAmount = (y+wxPG_PIXELS_PER_UNIT+2)/wxPG_PIXELS_PER_UNIT;
+ int yAmount = y / wxPG_PIXELS_PER_UNIT;
int yPos = GetScrollPos( wxVERTICAL );
SetScrollbars( wxPG_PIXELS_PER_UNIT, wxPG_PIXELS_PER_UNIT,
int curPropHoverY = y - (y % ih);
// On which item it hovers
- if ( ( !m_propHover )
+ if ( !m_propHover
||
- ( m_propHover && ( sy < m_propHoverY || sy >= (m_propHoverY+ih) ) )
+ ( sy < m_propHoverY || sy >= (m_propHoverY+ih) )
)
{
// Mouse moves on another property
if ( space )
{
int tw, th;
- GetTextExtent( tipString, &tw, &th, 0, 0, &m_font );
+ GetTextExtent( tipString, &tw, &th, 0, 0 );
if ( tw > space )
{
SetToolTip( tipString );
// (also not if we were dragging and its started
// outside the splitter region)
- if ( m_propHover &&
- !m_propHover->IsCategory() &&
+ if ( !m_propHover->IsCategory() &&
!event.Dragging() )
{
wxRect r;
if ( wnd )
r = wnd->GetRect();
- if ( wnd == (wxWindow*) NULL || m_dragStatus ||
+ if ( wnd == NULL || m_dragStatus ||
(
ux <= (splitterX + wxPG_SPLITTERX_DETECTMARGIN2) ||
ux >= (r.x+r.width) ||
{
wxPGHashMapI2I::iterator it;
- for ( it = m_actionTriggers.begin(); it != m_actionTriggers.end(); it++ )
+ for ( it = m_actionTriggers.begin(); it != m_actionTriggers.end(); ++it )
{
if ( it->second == action )
{
// Handles key event when editor control is not focused.
//
- wxASSERT( !m_frozen );
- if ( m_frozen )
- return;
+ wxCHECK2(!m_frozen, return);
// Travelsal between items, collapsing/expanding, etc.
int keycode = event.GetKeyCode();
// Except for TAB and ESC, handle child control events in child control
if ( fromChild )
{
+ // Only propagate event if it had modifiers
+ if ( !event.HasModifiers() )
+ {
+ event.StopPropagation();
+ }
event.Skip();
return;
}
void wxPropertyGrid::OnKey( wxKeyEvent &event )
{
+ // If there was editor open and focused, then this event should not
+ // really be processed here.
+ if ( IsEditorFocused() )
+ {
+ // However, if event had modifiers, it is probably still best
+ // to skip it.
+ if ( event.HasModifiers() )
+ event.Skip();
+ else
+ event.StopPropagation();
+ return;
+ }
+
HandleKeyEvent(event, false);
}
// Use this in RegisterDefaultEditors.
#define wxPGRegisterDefaultEditorClass(EDITOR) \
- if ( wxPGEditor_##EDITOR == (wxPGEditor*) NULL ) \
+ if ( wxPGEditor_##EDITOR == NULL ) \
{ \
wxPGEditor_##EDITOR = wxPropertyGrid::RegisterEditorClass( \
new wxPG##EDITOR##Editor, true ); \
}
else
{
- i++;
+ ++i;
m_curPos = i;
return true;
}
prev_a = wxT('\0');
}
}
- i++;
+ ++i;
}
m_curPos = str.end();
return ownEntry;
}
-// -----------------------------------------------------------------------
-// wxPGChoices
-// -----------------------------------------------------------------------
-
-wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, int value )
-{
- EnsureData();
-
- wxPGChoiceEntry entry(label, value);
- return m_data->Insert( -1, entry );
-}
-
-// -----------------------------------------------------------------------
-
-wxPGChoiceEntry& wxPGChoices::Add( const wxString& label, const wxBitmap& bitmap, int value )
-{
- EnsureData();
-
- wxPGChoiceEntry entry(label, value);
- entry.SetBitmap(bitmap);
- return m_data->Insert( -1, entry );
-}
-
-// -----------------------------------------------------------------------
-
-wxPGChoiceEntry& wxPGChoices::Insert( const wxPGChoiceEntry& entry, int index )
-{
- EnsureData();
- return m_data->Insert( index, entry );
-}
-
-// -----------------------------------------------------------------------
-
-wxPGChoiceEntry& wxPGChoices::Insert( const wxString& label, int index, int value )
-{
- EnsureData();
-
- wxPGChoiceEntry entry(label, value);
- return m_data->Insert( index, entry );
-}
-
-// -----------------------------------------------------------------------
-
-wxPGChoiceEntry& wxPGChoices::AddAsSorted( const wxString& label, int value )
-{
- EnsureData();
-
- 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 )
-{
- EnsureData();
-
- 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 )
-{
- EnsureData();
-
- 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)
-{
- wxASSERT( m_data->m_refCount != 0xFFFFFFF );
- m_data->m_items.erase(m_data->m_items.begin()+nIndex,
- m_data->m_items.begin()+nIndex+count);
-}
-
-// -----------------------------------------------------------------------
-
-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::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;
- }
-}
-
// -----------------------------------------------------------------------
// wxPropertyGridEvent
// -----------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxPropertyGridEvent, wxCommandEvent)
-DEFINE_EVENT_TYPE( wxEVT_PG_SELECTED )
-DEFINE_EVENT_TYPE( wxEVT_PG_CHANGING )
-DEFINE_EVENT_TYPE( wxEVT_PG_CHANGED )
-DEFINE_EVENT_TYPE( wxEVT_PG_HIGHLIGHTED )
-DEFINE_EVENT_TYPE( wxEVT_PG_RIGHT_CLICK )
-DEFINE_EVENT_TYPE( wxEVT_PG_PAGE_CHANGED )
-DEFINE_EVENT_TYPE( wxEVT_PG_ITEM_EXPANDED )
-DEFINE_EVENT_TYPE( wxEVT_PG_ITEM_COLLAPSED )
-DEFINE_EVENT_TYPE( wxEVT_PG_DOUBLE_CLICK )
+wxDEFINE_EVENT( wxEVT_PG_SELECTED, wxPropertyGridEvent );
+wxDEFINE_EVENT( wxEVT_PG_CHANGING, wxPropertyGridEvent );
+wxDEFINE_EVENT( wxEVT_PG_CHANGED, wxPropertyGridEvent );
+wxDEFINE_EVENT( wxEVT_PG_HIGHLIGHTED, wxPropertyGridEvent );
+wxDEFINE_EVENT( wxEVT_PG_RIGHT_CLICK, wxPropertyGridEvent );
+wxDEFINE_EVENT( wxEVT_PG_PAGE_CHANGED, wxPropertyGridEvent );
+wxDEFINE_EVENT( wxEVT_PG_ITEM_EXPANDED, wxPropertyGridEvent );
+wxDEFINE_EVENT( wxEVT_PG_ITEM_COLLAPSED, wxPropertyGridEvent );
+wxDEFINE_EVENT( wxEVT_PG_DOUBLE_CLICK, wxPropertyGridEvent );
// -----------------------------------------------------------------------
int state = 0;
bool labelValid = false;
- for ( ; it != choicesString.end(); it++ )
+ for ( ; it != choicesString.end(); ++it )
{
wxChar c = *it;
projects / wxWidgets.git / blobdiff