// Author: Jaakko Salli
// Modified by:
// Created: 2004-09-25
-// RCS-ID: $Id:
+// RCS-ID: $Id$
// Copyright: (c) Jaakko Salli
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
#include "wx/stattext.h"
#include "wx/scrolwin.h"
#include "wx/dirdlg.h"
- #include "wx/layout.h"
#include "wx/sizer.h"
#include "wx/textdlg.h"
#include "wx/filedlg.h"
// This define is necessary to prevent macro clearing
#define __wxPG_SOURCE_FILE__
-#include <wx/propgrid/propgrid.h>
-#include <wx/propgrid/editors.h>
+#include "wx/propgrid/propgrid.h"
+#include "wx/propgrid/editors.h"
#if wxPG_USE_RENDERER_NATIVE
- #include <wx/renderer.h>
+ #include "wx/renderer.h"
#endif
-#include <wx/odcombo.h>
+#include "wx/odcombo.h"
#include "wx/timer.h"
#include "wx/dcbuffer.h"
-#include <wx/clipbrd.h>
-#include <wx/dataobj.h>
+#include "wx/clipbrd.h"
+#include "wx/dataobj.h"
#ifdef __WXMSW__
- #include <wx/msw/private.h>
+ #include "wx/msw/private.h"
#endif
// Two pics for the expand / collapse buttons.
// -----------------------------------------------------------------------
// Statics in one class for easy destruction.
-// NB: We prefer to use wxModule, as it offers more consistent behavior
-// across platforms. However, for those rare problem situations, we
-// also need to offer option to use simpler approach.
// -----------------------------------------------------------------------
-#ifndef wxPG_USE_WXMODULE
- #define wxPG_USE_WXMODULE 1
-#endif
-
-#if wxPG_USE_WXMODULE
-
-#include <wx/module.h>
+#include "wx/module.h"
class wxPGGlobalVarsClassManager : public wxModule
{
IMPLEMENT_DYNAMIC_CLASS(wxPGGlobalVarsClassManager, wxModule)
-#else // !wxPG_USE_WXMODULE
-
-class wxPGGlobalVarsClassManager
-{
-public:
- wxPGGlobalVarsClassManager() {}
- ~wxPGGlobalVarsClassManager() { delete wxPGGlobalVars; }
-};
-
-static wxPGGlobalVarsClassManager gs_pgGlobalVarsClassManager;
-
-#endif
-
wxPGGlobalVarsClass* wxPGGlobalVars = (wxPGGlobalVarsClass*) NULL;
delete wxPGProperty::sm_wxPG_LABEL;
}
+void wxPropertyGridInitGlobalsIfNeeded()
+{
+}
+
// -----------------------------------------------------------------------
// wxPGBrush
// -----------------------------------------------------------------------
pg->OnKeyUp( event );
}
- void OnNavigationKey( wxNavigationKeyEvent& event )
- {
- wxPropertyGrid* pg = wxStaticCast(GetParent(), wxPropertyGrid);
- pg->OnNavigationKey( event );
- }
-
void OnPaint( wxPaintEvent& event );
+
+ // Always be focussable, even with child windows
+ virtual void SetCanFocus(bool WXUNUSED(canFocus))
+ { wxPanel::SetCanFocus(true); }
+
private:
DECLARE_EVENT_TABLE()
+ DECLARE_ABSTRACT_CLASS(wxPGCanvas)
};
+IMPLEMENT_ABSTRACT_CLASS(wxPGCanvas,wxPanel)
+
BEGIN_EVENT_TABLE(wxPGCanvas, wxPanel)
EVT_MOTION(wxPGCanvas::OnMouseMove)
EVT_PAINT(wxPGCanvas::OnPaint)
EVT_KEY_DOWN(wxPGCanvas::OnKey)
EVT_KEY_UP(wxPGCanvas::OnKeyUp)
EVT_CHAR(wxPGCanvas::OnKey)
- EVT_NAVIGATION_KEY(wxPGCanvas::OnNavigationKey)
END_EVENT_TABLE()
EVT_CHILD_FOCUS(wxPropertyGrid::OnChildFocusEvent)
EVT_SET_FOCUS(wxPropertyGrid::OnFocusEvent)
EVT_KILL_FOCUS(wxPropertyGrid::OnFocusEvent)
- EVT_TEXT_ENTER(wxPG_SUBID1,wxPropertyGrid::OnCustomEditorEvent)
EVT_SYS_COLOUR_CHANGED(wxPropertyGrid::OnSysColourChanged)
END_EVENT_TABLE()
//
void wxPropertyGrid::Init1()
{
-#if !wxPG_USE_WXMODULE
- if ( !wxPGGlobalVars )
- wxPGGlobalVars = new wxPGGlobalVarsClass();
-#endif
-
// Register editor classes, if necessary.
if ( wxPGGlobalVars->m_mapEditorClasses.empty() )
- RegisterDefaultEditors();
+ wxPropertyGrid::RegisterDefaultEditors();
m_iFlags = 0;
m_pState = (wxPropertyGridPageState*) NULL;
AddActionTrigger( wxPG_ACTION_COPY, WXK_INSERT, wxMOD_CONTROL );
AddActionTrigger( wxPG_ACTION_PASTE, 'V', wxMOD_CONTROL );
AddActionTrigger( wxPG_ACTION_PASTE, WXK_INSERT, wxMOD_SHIFT );
+ AddActionTrigger( wxPG_ACTION_PRESS_BUTTON, WXK_DOWN, wxMOD_ALT );
+ AddActionTrigger( wxPG_ACTION_PRESS_BUTTON, WXK_F4 );
m_coloursCustomized = 0;
m_frozen = 0;
m_doubleBuffer = (wxBitmap*) NULL;
#endif
- m_windowsToDelete = NULL;
-
#ifndef wxPG_ICON_WIDTH
m_expandbmp = NULL;
m_collbmp = NULL;
m_width = m_height = 0;
- SetButtonShortcut(0);
-
- m_keyComboConsumed = 0;
-
m_commonValues.push_back(new wxPGCommonValue(_("Unspecified"), wxPGGlobalVars->m_defaultRenderer) );
m_cvUnspecified = 0;
delete m_doubleBuffer;
#endif
- delete m_windowsToDelete;
-
//m_selected = (wxPGProperty*) NULL;
if ( m_iFlags & wxPG_FL_CREATEDSTATE )
// TODO: Following code is disabled with wxMac because
// it is reported to fail. I (JMS) cannot debug it
// personally right now.
-#if !defined(__WXMAC__)
+ // 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 )
{
// wxPropertyGrid property operations
// -----------------------------------------------------------------------
-void wxPropertyGrid::DoSetPropertyName( wxPGProperty* p, const wxString& newname )
-{
- wxCHECK_RET( p, wxT("invalid property id") );
-
- if ( p->GetBaseName().Len() ) m_pState->m_dictName.erase( p->GetBaseName() );
- if ( newname.Len() ) m_pState->m_dictName[newname] = (void*) p;
-
- p->DoSetName(newname);
-}
-
-// -----------------------------------------------------------------------
-
bool wxPropertyGrid::EnsureVisible( wxPGPropArg id )
{
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
}
-// -----------------------------------------------------------------------
-
-void wxPropertyGrid::SetButtonShortcut( int keycode, bool ctrlDown, bool altDown )
-{
- if ( keycode )
- {
- m_pushButKeyCode = keycode;
- m_pushButKeyCodeNeedsCtrl = ctrlDown ? 1 : 0;
- m_pushButKeyCodeNeedsAlt = altDown ? 1 : 0;
- }
- else
- {
- m_pushButKeyCode = WXK_DOWN;
- m_pushButKeyCodeNeedsCtrl = 0;
- m_pushButKeyCodeNeedsAlt = 1;
- }
-}
-
// -----------------------------------------------------------------------
// Methods related to change in value, value modification and sending events
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
-bool wxPropertyGrid::PerformValidation( wxPGProperty* p, wxVariant& pendingValue )
+bool wxPropertyGrid::PerformValidation( wxPGProperty* p, wxVariant& pendingValue,
+ int flags )
{
//
// Runs all validation functionality.
wxVariant evtChangingValue = value;
- // FIXME: After proper ValueToString()s added, remove
- // this. It is just a temporary fix, as evt_changing
- // will simply not work for wxPG_PROP_COMPOSED_VALUE
- // (unless it is selected, and textctrl editor is open).
- if ( changedProperty->HasFlag(wxPG_PROP_COMPOSED_VALUE) )
+ if ( flags & SendEvtChanging )
{
- evtChangingProperty = baseChangedProperty;
- if ( evtChangingProperty != p )
+ // FIXME: After proper ValueToString()s added, remove
+ // this. It is just a temporary fix, as evt_changing
+ // will simply not work for wxPG_PROP_COMPOSED_VALUE
+ // (unless it is selected, and textctrl editor is open).
+ if ( changedProperty->HasFlag(wxPG_PROP_COMPOSED_VALUE) )
{
- evtChangingProperty->AdaptListToValue( bcpPendingList, &evtChangingValue );
- }
- else
- {
- evtChangingValue = pendingValue;
+ evtChangingProperty = baseChangedProperty;
+ if ( evtChangingProperty != p )
+ {
+ evtChangingProperty->AdaptListToValue( bcpPendingList, &evtChangingValue );
+ }
+ else
+ {
+ evtChangingValue = pendingValue;
+ }
}
- }
- if ( evtChangingProperty->HasFlag(wxPG_PROP_COMPOSED_VALUE) )
- {
- if ( changedProperty == m_selected )
- {
- wxASSERT( m_wndEditor->IsKindOf(CLASSINFO(wxTextCtrl)) );
- evtChangingValue = ((wxTextCtrl*)m_wndEditor)->GetValue();
- }
- else
+ if ( evtChangingProperty->HasFlag(wxPG_PROP_COMPOSED_VALUE) )
{
- wxLogDebug(wxT("WARNING: wxEVT_PG_CHANGING is about to happen with old value."));
+ if ( changedProperty == m_selected )
+ {
+ wxWindow* editor = GetEditorControl();
+ wxASSERT( editor->IsKindOf(CLASSINFO(wxTextCtrl)) );
+ evtChangingValue = wxStaticCast(editor, wxTextCtrl)->GetValue();
+ }
+ else
+ {
+ wxLogDebug(wxT("WARNING: wxEVT_PG_CHANGING is about to happen with old value."));
+ }
}
}
return false;
}
- // SendEvent returns true if event was vetoed
- if ( SendEvent( wxEVT_PG_CHANGING, evtChangingProperty, &evtChangingValue, 0 ) )
- return false;
+ if ( flags & SendEvtChanging )
+ {
+ // SendEvent returns true if event was vetoed
+ if ( SendEvent( wxEVT_PG_CHANGING, evtChangingProperty, &evtChangingValue, 0 ) )
+ return false;
+ }
+
+ if ( flags & IsStandaloneValidation )
+ {
+ // If called in 'generic' context, we need to reset
+ // m_chgInfo_changedProperty and write back translated value.
+ m_chgInfo_changedProperty = NULL;
+ pendingValue = value;
+ }
return true;
}
// -----------------------------------------------------------------------
-// Runs wxValidator for the selected property
-bool wxPropertyGrid::DoEditorValidate()
+wxVariant wxPropertyGrid::GetUncommittedPropertyValue()
{
-#if wxUSE_VALIDATORS
- // With traditional validator style, we dont need to more
- if ( !(GetExtraStyle() & wxPG_EX_LEGACY_VALIDATORS) )
- return true;
+ wxPGProperty* prop = GetSelectedProperty();
- if ( m_iFlags & wxPG_FL_VALIDATION_FAILED )
- {
- return false;
- }
+ if ( !prop )
+ return wxNullVariant;
- wxWindow* wnd = GetEditorControl();
+ wxTextCtrl* tc = GetEditorTextCtrl();
+ wxVariant value = prop->GetValue();
- wxValidator* validator = m_selected->GetValidator();
- if ( validator && wnd )
- {
- // Use TextCtrl of ODComboBox instead
- if ( wnd->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) )
- {
- wnd = ((wxOwnerDrawnComboBox*)wnd)->GetTextCtrl();
+ if ( !tc || !IsEditorsValueModified() )
+ return value;
- if ( !wnd )
- return true;
- }
+ if ( !prop->StringToValue(value, tc->GetValue()) )
+ return value;
- validator->SetWindow(wnd);
+ if ( !PerformValidation(prop, value, IsStandaloneValidation) )
+ return prop->GetValue();
- // Instead setting the flag after the failure, we set
- // it before checking and then clear afterwards if things
- // went fine. This trick is necessary since focus events
- // may be triggered while in Validate.
- m_iFlags |= wxPG_FL_VALIDATION_FAILED;
- if ( !validator->Validate(this) )
- {
- // If you dpm't want to display message multiple times per change,
- // comment the following line.
- m_iFlags &= ~(wxPG_FL_VALIDATION_FAILED);
- return false;
- }
- m_iFlags &= ~(wxPG_FL_VALIDATION_FAILED);
- }
-#endif
+ return value;
+}
+
+// -----------------------------------------------------------------------
+
+// Runs wxValidator for the selected property
+bool wxPropertyGrid::DoEditorValidate()
+{
return true;
}
{
wxPGProperty* selected = m_selected;
- //
// Somehow, event is handled after property has been deselected.
// Possibly, but very rare.
if ( !selected )
}
}
- if ( wnd && !buttonWasHandled )
+ if ( !buttonWasHandled )
{
- // First call editor class' event handler.
- const wxPGEditor* editor = selected->GetEditorClass();
-
- if ( editor->OnEvent( this, selected, wnd, event ) )
+ if ( wnd )
{
- // If changes, validate them
- if ( DoEditorValidate() )
- {
- if ( editor->GetValueFromControl( pendingValue, m_selected, wnd ) )
- valueIsPending = true;
- }
- else
+ // First call editor class' event handler.
+ const wxPGEditor* editor = selected->GetEditorClass();
+
+ if ( editor->OnEvent( this, selected, wnd, event ) )
{
- validationFailure = true;
+ // If changes, validate them
+ if ( DoEditorValidate() )
+ {
+ if ( editor->GetValueFromControl( pendingValue, m_selected, wnd ) )
+ valueIsPending = true;
+ }
+ else
+ {
+ validationFailure = true;
+ }
}
}
if ( !PerformValidation(m_selected, pendingValue) )
validationFailure = true;
- if ( validationFailure )
+ if ( validationFailure)
{
OnValidationFailure(selected, pendingValue);
}
DoPropertyChanged(selected, selFlags);
EditorsValueWasNotModified();
+
+ // Regardless of editor type, unfocus editor on
+ // text-editing related enter press.
+ if ( event.GetEventType() == wxEVT_COMMAND_TEXT_ENTER )
+ {
+ SetFocusOnCanvas();
+ }
}
else
{
// No value after all
+
+ // Regardless of editor type, unfocus editor on
+ // text-editing related enter press.
+ if ( event.GetEventType() == wxEVT_COMMAND_TEXT_ENTER )
+ {
+ SetFocusOnCanvas();
+ }
// Let unhandled button click events go to the parent
if ( !buttonWasHandled && event.GetEventType() == wxEVT_COMMAND_BUTTON_CLICKED )
// wxPropertyGrid property selection
// -----------------------------------------------------------------------
-#define CONNECT_CHILD(EVT,FUNCTYPE,FUNC) \
- wnd->Connect(id, EVT, \
- (wxObjectEventFunction) (wxEventFunction) \
- FUNCTYPE (&wxPropertyGrid::FUNC), \
- NULL, this );
-
// Setups event handling for child control
-void wxPropertyGrid::SetupEventHandling( wxWindow* argWnd, int id )
+void wxPropertyGrid::SetupChildEventHandling( wxWindow* argWnd )
{
- wxWindow* wnd = argWnd;
+ wxWindowID id = argWnd->GetId();
if ( argWnd == m_wndEditor )
{
- CONNECT_CHILD(wxEVT_MOTION,(wxMouseEventFunction),OnMouseMoveChild)
- CONNECT_CHILD(wxEVT_LEFT_UP,(wxMouseEventFunction),OnMouseUpChild)
- CONNECT_CHILD(wxEVT_LEFT_DOWN,(wxMouseEventFunction),OnMouseClickChild)
- CONNECT_CHILD(wxEVT_RIGHT_UP,(wxMouseEventFunction),OnMouseRightClickChild)
- CONNECT_CHILD(wxEVT_ENTER_WINDOW,(wxMouseEventFunction),OnMouseEntry)
- CONNECT_CHILD(wxEVT_LEAVE_WINDOW,(wxMouseEventFunction),OnMouseEntry)
- }
- else
- {
- CONNECT_CHILD(wxEVT_NAVIGATION_KEY,(wxNavigationKeyEventFunction),OnNavigationKey)
+ argWnd->Connect(id, wxEVT_MOTION,
+ wxMouseEventHandler(wxPropertyGrid::OnMouseMoveChild),
+ NULL, this);
+ argWnd->Connect(id, wxEVT_LEFT_UP,
+ wxMouseEventHandler(wxPropertyGrid::OnMouseUpChild),
+ NULL, this);
+ argWnd->Connect(id, wxEVT_LEFT_DOWN,
+ wxMouseEventHandler(wxPropertyGrid::OnMouseClickChild),
+ NULL, this);
+ argWnd->Connect(id, wxEVT_RIGHT_UP,
+ wxMouseEventHandler(wxPropertyGrid::OnMouseRightClickChild),
+ NULL, this);
+ argWnd->Connect(id, wxEVT_ENTER_WINDOW,
+ wxMouseEventHandler(wxPropertyGrid::OnMouseEntry),
+ NULL, this);
+ argWnd->Connect(id, wxEVT_LEAVE_WINDOW,
+ wxMouseEventHandler(wxPropertyGrid::OnMouseEntry),
+ NULL, this);
+ argWnd->Connect(id, wxEVT_KEY_DOWN,
+ wxCharEventHandler(wxPropertyGrid::OnChildKeyDown),
+ NULL, this);
}
- CONNECT_CHILD(wxEVT_KEY_DOWN,(wxCharEventFunction),OnChildKeyDown)
- CONNECT_CHILD(wxEVT_KEY_UP,(wxCharEventFunction),OnChildKeyUp)
- CONNECT_CHILD(wxEVT_KILL_FOCUS,(wxFocusEventFunction),OnFocusEvent)
}
void wxPropertyGrid::FreeEditors()
{
// Do not free editors immediately if processing events
- if ( !m_windowsToDelete )
- m_windowsToDelete = new wxArrayPtrVoid;
-
if ( m_wndEditor2 )
{
- m_windowsToDelete->push_back(m_wndEditor2);
m_wndEditor2->Hide();
+ wxPendingDelete.Append( m_wndEditor2 );
m_wndEditor2 = (wxWindow*) NULL;
}
if ( m_wndEditor )
{
- m_windowsToDelete->push_back(m_wndEditor);
m_wndEditor->Hide();
+ wxPendingDelete.Append( m_wndEditor );
m_wndEditor = (wxWindow*) NULL;
}
}
wxPGProperty* prev = m_selected;
- //
- // Delete windows pending for deletion
- if ( m_windowsToDelete && !m_inDoPropertyChanged && m_windowsToDelete->size() )
- {
- unsigned int i;
-
- for ( i=0; i<m_windowsToDelete->size(); i++ )
- delete ((wxWindow*)((*m_windowsToDelete)[i]));
-
- m_windowsToDelete->clear();
- }
-
if ( !m_pState )
{
m_inDoSelectProperty = 0;
return false;
}
- //
+/*
+ if (m_selected)
+ 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 )
{
m_wndEditor = wndList.m_primary;
m_wndEditor2 = wndList.m_secondary;
+ wxWindow* primaryCtrl = GetEditorControl();
+
+ //
+ // Essentially, primaryCtrl == m_wndEditor
+ //
// NOTE: It is allowed for m_wndEditor to be NULL - in this case
// value is drawn as normal, and m_wndEditor2 is assumed
- // to be a right-aligned button that triggers a separate editor
+ // to be a right-aligned button that triggers a separate editorCtrl
// window.
if ( m_wndEditor )
// Set validator, if any
#if wxUSE_VALIDATORS
- if ( !(GetExtraStyle() & wxPG_EX_LEGACY_VALIDATORS) )
- {
- wxValidator* validator = p->GetValidator();
- if ( validator )
- m_wndEditor->SetValidator(*validator);
- }
+ wxValidator* validator = p->GetValidator();
+ if ( validator )
+ primaryCtrl->SetValidator(*validator);
#endif
if ( m_wndEditor->GetSize().y > (m_lineHeight+6) )
// Fix TextCtrl indentation
#if defined(__WXMSW__) && !defined(__WXWINCE__)
wxTextCtrl* tc = NULL;
- if ( m_wndEditor->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) )
- tc = ((wxOwnerDrawnComboBox*)m_wndEditor)->GetTextCtrl();
+ if ( primaryCtrl->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) )
+ tc = ((wxOwnerDrawnComboBox*)primaryCtrl)->GetTextCtrl();
else
- tc = wxDynamicCast(m_wndEditor, wxTextCtrl);
+ tc = wxDynamicCast(primaryCtrl, wxTextCtrl);
if ( tc )
::SendMessage(GetHwndOf(tc), EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(0, 0));
#endif
m_wndEditor->Move( goodPos );
#endif
- wxWindow* primaryCtrl = GetEditorControl();
- SetupEventHandling(primaryCtrl, wxPG_SUBID1);
+ SetupChildEventHandling(primaryCtrl);
// Focus and select all (wxTextCtrl, wxComboBox etc)
if ( flags & wxPG_SEL_FOCUS )
#endif
m_wndEditor2->Show();
- SetupEventHandling(m_wndEditor2,wxPG_SUBID2);
+ SetupChildEventHandling(m_wndEditor2);
// If no primary editor, focus to button to allow
// it to interprete ENTER etc.
m_pState->SetVirtualWidth( width );
}
+void wxPropertyGrid::SetFocusOnCanvas()
+{
+ m_canvas->SetFocusIgnoringChildren();
+ m_editorFocused = 0;
+}
+
// -----------------------------------------------------------------------
// wxPropertyGrid mouse event handling
// -----------------------------------------------------------------------
int ux = event.m_x;
int uy = event.m_y;
- wxWindow* wnd = m_wndEditor;
+ wxWindow* wnd = GetEditorControl();
// Hide popup on clicks
if ( event.GetEventType() != wxEVT_MOTION )
if ( wnd && wnd->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) )
{
- ((wxOwnerDrawnComboBox*)m_wndEditor)->HidePopup();
+ ((wxOwnerDrawnComboBox*)wnd)->HidePopup();
}
wxRect r;
int x, y;
event.GetPosition(&x,&y);
- AdjustPosForClipperWindow( topCtrlWnd, &x, &y );
-
int splitterX = GetSplitterPosition();
wxRect r = topCtrlWnd->GetRect();
// wxPropertyGrid keyboard event handling
// -----------------------------------------------------------------------
-void wxPropertyGrid::SendNavigationKeyEvent( int dir )
-{
- wxNavigationKeyEvent evt;
- evt.SetFlags(wxNavigationKeyEvent::FromTab|
- (dir?wxNavigationKeyEvent::IsForward:
- wxNavigationKeyEvent::IsBackward));
- evt.SetEventObject(this);
- m_canvas->GetEventHandler()->AddPendingEvent(evt);
-}
-
-
int wxPropertyGrid::KeyEventToActions(wxKeyEvent &event, int* pSecond) const
{
// Translates wxKeyEvent to wxPG_ACTION_XXX
if ( keycode == WXK_TAB )
{
- SendNavigationKeyEvent( event.ShiftDown()?0:1 );
+ if (m_selected)
+ DoSelectProperty( m_selected, wxPG_SEL_FOCUS );
return;
}
{
// Show dialog?
- if ( ButtonTriggerKeyTest(event) )
+ if ( ButtonTriggerKeyTest(action, event) )
return;
wxPGProperty* p = m_selected;
// Update the control as well
m_selected->GetEditorClass()->SetControlStringValue( m_selected,
- m_wndEditor,
+ GetEditorControl(),
m_selected->GetDisplayedString() );
}
OnValidationFailureReset(m_selected);
res = false;
-
UnfocusEditor();
}
else if ( action == wxPG_ACTION_COPY )
void wxPropertyGrid::OnKey( wxKeyEvent &event )
{
-
- //
- // Events to editor controls should get relayed here.
- //
- wxWindow* focused = wxWindow::FindFocus();
-
- wxWindow* primaryCtrl = GetEditorControl();
-
- if ( primaryCtrl &&
- (focused==primaryCtrl
- || m_editorFocused) )
- {
- // Child key must be processed here, since it can
- // destroy the control which is referred by its own
- // event handling.
- HandleChildKey( event );
- }
- else
- HandleKeyEvent( event );
+ HandleKeyEvent( event );
}
// -----------------------------------------------------------------------
void wxPropertyGrid::OnKeyUp(wxKeyEvent &event)
{
- m_keyComboConsumed = 0;
-
event.Skip();
}
// -----------------------------------------------------------------------
-void wxPropertyGrid::OnNavigationKey( wxNavigationKeyEvent& event )
+bool wxPropertyGrid::ButtonTriggerKeyTest( int action, wxKeyEvent& event )
{
- // Ignore events that occur very close to focus set
- if ( m_iFlags & wxPG_FL_IGNORE_NEXT_NAVKEY )
- {
- m_iFlags &= ~(wxPG_FL_IGNORE_NEXT_NAVKEY);
- event.Skip();
- return;
- }
-
- wxPGProperty* next = (wxPGProperty*) NULL;
-
- int dir = event.GetDirection()?1:-1;
-
- if ( m_selected )
+ if ( action == -1 )
{
- if ( dir == 1 && (m_wndEditor || m_wndEditor2) )
- {
- wxWindow* focused = wxWindow::FindFocus();
-
- wxWindow* wndToCheck = GetEditorControl();
-
- // ODComboBox focus goes to its text ctrl, so we need to use it instead
- if ( wndToCheck && wndToCheck->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) )
- {
- wxTextCtrl* comboTextCtrl = ((wxOwnerDrawnComboBox*)wndToCheck)->GetTextCtrl();
- if ( comboTextCtrl )
- wndToCheck = comboTextCtrl;
- }
-
- /*
- // Because of problems navigating from wxButton, do not go to it.
- if ( !wndToCheck )
- {
- // No primary, use secondary
- wndToCheck = m_wndEditor2;
- }
- // If it has editor button, focus to it after the primary editor.
- // NB: Doesn't work since wxButton on wxMSW doesn't seem to propagate
- // key events (yes, I'm using wxWANTS_CHARS with it, and yes I
- // have somewhat debugged in window.cpp itself).
- else if ( focused == wndToCheck &&
- m_wndEditor2 &&
- !(GetExtraStyle() & wxPG_EX_NO_TAB_TO_BUTTON) )
- {
- wndToCheck = m_wndEditor2;
- wxLogDebug(wxT("Exp1"));
- }
- */
-
- if ( focused != wndToCheck &&
- wndToCheck )
- {
- wndToCheck->SetFocus();
-
- // Select all text in wxTextCtrl etc.
- if ( m_wndEditor && wndToCheck == m_wndEditor )
- m_selected->GetEditorClass()->OnFocus(m_selected,wndToCheck);
-
- m_editorFocused = 1;
- next = m_selected;
- }
- }
-
- if ( !next )
- {
- next = wxPropertyGridIterator::OneStep(m_pState, wxPG_ITERATE_VISIBLE, m_selected, dir);
-
- if ( next )
- {
- // This allows preventing NavigateOut to occur
- DoSelectProperty( next, wxPG_SEL_FOCUS );
- }
- }
+ int secondAction;
+ action = KeyEventToActions(event, &secondAction);
}
- if ( !next )
- event.Skip();
-}
-
-// -----------------------------------------------------------------------
-
-bool wxPropertyGrid::ButtonTriggerKeyTest( wxKeyEvent &event )
-{
- int keycode = event.GetKeyCode();
-
// Does the keycode trigger button?
- if ( keycode == m_pushButKeyCode &&
- m_wndEditor2 &&
- (!m_pushButKeyCodeNeedsAlt || event.AltDown()) &&
- (!m_pushButKeyCodeNeedsCtrl || event.ControlDown()) )
+ if ( action == wxPG_ACTION_PRESS_BUTTON &&
+ m_wndEditor2 )
{
- m_keyComboConsumed = 1;
-
- wxCommandEvent evt(wxEVT_COMMAND_BUTTON_CLICKED,m_wndEditor2->GetId());
+ wxCommandEvent evt(wxEVT_COMMAND_BUTTON_CLICKED, m_wndEditor2->GetId());
GetEventHandler()->AddPendingEvent(evt);
return true;
}
return;
}
- if ( ButtonTriggerKeyTest(event) )
+ if ( ButtonTriggerKeyTest(-1, event) )
return;
if ( HandleChildKey(event) == true )
void wxPropertyGrid::OnChildKeyUp( wxKeyEvent &event )
{
- m_keyComboConsumed = 0;
-
GetEventHandler()->AddPendingEvent(event);
event.Skip();
if ( (m_iFlags & wxPG_FL_FOCUSED) !=
(oldFlags & wxPG_FL_FOCUSED) )
{
- // On each focus kill, mark the next nav key event
- // to be ignored (can't do on set focus since the
- // event would occur before it).
if ( !(m_iFlags & wxPG_FL_FOCUSED) )
{
- m_iFlags |= wxPG_FL_IGNORE_NEXT_NAVKEY;
-
// Need to store changed value
CommitChangesFromEditor();
}
}
*/
-
- m_iFlags &= ~(wxPG_FL_IGNORE_NEXT_NAVKEY);
}
// Redraw selected
// -----------------------------------------------------------------------
// noDefCheck = true prevents infinite recursion.
-wxPGEditor* wxPropertyGrid::RegisterEditorClass( wxPGEditor* editorclass,
- const wxString& name,
+wxPGEditor* wxPropertyGrid::RegisterEditorClass( wxPGEditor* editorClass,
bool noDefCheck )
{
- wxASSERT( editorclass );
+ wxASSERT( editorClass );
if ( !noDefCheck && wxPGGlobalVars->m_mapEditorClasses.empty() )
RegisterDefaultEditors();
- wxPGGlobalVars->m_mapEditorClasses[name] = (void*)editorclass;
+ wxString name = editorClass->GetName();
+
+ // Existing editor under this name?
+ wxPGHashMapS2P::iterator vt_it = wxPGGlobalVars->m_mapEditorClasses.find(name);
+
+ if ( vt_it != wxPGGlobalVars->m_mapEditorClasses.end() )
+ {
+ // If this name was already used, try class name.
+ name = editorClass->GetClassInfo()->GetClassName();
+ vt_it = wxPGGlobalVars->m_mapEditorClasses.find(name);
+ }
- return editorclass;
+ wxCHECK_MSG( vt_it == wxPGGlobalVars->m_mapEditorClasses.end(),
+ (wxPGEditor*) vt_it->second,
+ "Editor with given name was already registered" );
+
+ wxPGGlobalVars->m_mapEditorClasses[name] = (void*)editorClass;
+
+ return editorClass;
}
+// Use this in RegisterDefaultEditors.
+#define wxPGRegisterDefaultEditorClass(EDITOR) \
+ if ( wxPGEditor_##EDITOR == (wxPGEditor*) NULL ) \
+ { \
+ wxPGEditor_##EDITOR = wxPropertyGrid::RegisterEditorClass( \
+ new wxPG##EDITOR##Editor, true ); \
+ }
+
// Registers all default editor classes
void wxPropertyGrid::RegisterDefaultEditors()
{
delete Item(i);
}
-#if wxUSE_STL
- m_items.resize(0);
-#else
- m_items.Empty();
-#endif
+ m_items.clear();
}
void wxPGChoicesData::CopyDataFrom( wxPGChoicesData* data )
unsigned int i;
for ( i=nIndex; i<(nIndex+count); i++)
delete m_data->Item(i);
- m_data->m_items.RemoveAt(nIndex, count);
+ m_data->m_items.erase(m_data->m_items.begin()+nIndex,
+ m_data->m_items.begin()+nIndex+count);
}
// -----------------------------------------------------------------------
projects / wxWidgets.git / blobdiff