\helpref{wxEvtHandler::SearchEventTable}{wxevthandlersearcheventtable}
+
+\membersection{wxEvtHandler::SafelyProcessEvent}\label{wxevthandlersafelyprocessevent}
+
+\func{bool}{SafelyProcessEvent}{\param{wxEvent\& }{event}}
+
+Processes an event by calling \helpref{ProcessEvent}{wxevthandlerprocessevent}
+and handles any exceptions that occur in the process. If an exception is
+thrown in event handler, \helpref{wxApp::OnExceptionInMainLoop}{wxapponexceptioninmainloop}
+is called.
+
+\wxheading{Parameters}
+
+\docparam{event}{Event to process.}
+
+\wxheading{Return value}
+
+\true if the event was processed, \false if no handler was found or an
+exception was thrown.
+
+\wxheading{See also}
+
+\helpref{wxWindow::HandleWindowEvent}{wxwindowhandlewindowevent}
+
+
\membersection{wxEvtHandler::SearchEventTable}\label{wxevthandlersearcheventtable}
\func{virtual bool}{SearchEventTable}{\param{wxEventTable\& }{table}, \param{wxEvent\& }{event}}
\helpref{wxWindow::SetWindowVariant}{wxwindowsetwindowvariant}.
+\membersection{wxWindow::HandleWindowEvent}\label{wxwindowhandlewindowevent}
+
+\func{bool}{HandleWindowEvent}{\param{wxEvent\& }{event}}
+
+Shorthand for \texttt{\helpref{GetEventHandler}{wxwindowgeteventhandler}()->\helpref{SafelyProcessEvent}{wxevthandlersafelyprocessevent}(event)}.
+
+
\membersection{wxWindow::HasCapture}\label{wxwindowhascapture}
\constfunc{virtual bool}{HasCapture}{\void}
// process an event right now
virtual bool ProcessEvent(wxEvent& event);
+ // Process an event by calling ProcessEvent and handling any exceptions
+ // thrown by event handlers. It's mostly useful when processing wx events
+ // when called from C code (e.g. in GTK+ callback) when the exception
+ // wouldn't correctly propagate to wxEventLoop.
+ bool SafelyProcessEvent(wxEvent& event);
+
// add an event to be processed later
virtual void AddPendingEvent(const wxEvent& event);
// be there)
bool RemoveEventHandler(wxEvtHandler *handler);
+ // Process an event by calling GetEventHandler()->ProcessEvent() and
+ // handling any exceptions thrown by event handlers. It's mostly useful
+ // when processing wx events when called from C code (e.g. in GTK+
+ // callback) when the exception wouldn't correctly propagate to
+ // wxEventLoop.
+ bool HandleWindowEvent(wxEvent& event) const;
+
// validators
// ----------
event.SetInt(index);
event.SetEventObject(this);
event.SetString(GetStringSelection());
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
void wxChoice::DoClear()
event2.SetInt(GetSelection());
event2.SetEventObject(this);
event2.SetString(GetStringSelection());
- GetEventHandler()->ProcessEvent(event2);
+ HandleWindowEvent(event2);
// For consistency with MSW and GTK, also send a text updated event
// After all, the text is updated when a selection is made
wxCommandEvent TextEvent( wxEVT_COMMAND_TEXT_UPDATED, GetId() );
TextEvent.SetString( GetStringSelection() );
TextEvent.SetEventObject( this );
- GetEventHandler()->ProcessEvent( TextEvent );
+ HandleWindowEvent( TextEvent );
}
bool wxControl::ProcessCommand(wxCommandEvent& event)
{
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
void wxControl::CocoaSetEnabled(bool enable)
wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, GetId(),
[GetNSTabView() indexOfTabViewItem:tabViewItem], GetSelection());
event.SetEventObject(this);
- return !GetEventHandler()->ProcessEvent(event) || event.IsAllowed();
+ return !HandleWindowEvent(event) || event.IsAllowed();
}
#endif // wxUSE_NOTEBOOK
wxScrollEvent event(command, GetId(), GetThumbPosition(),
HasFlag(wxSB_VERTICAL)?wxVERTICAL:wxHORIZONTAL);
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
#endif // wxUSE_SCROLLBAR
{
wxScrollEvent event(commandType, GetId(), GetValue(), HasFlag(wxSL_VERTICAL)?wxVERTICAL:wxHORIZONTAL);
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
static inline wxEventType wxSliderEventTypeForKeyFromEvent(NSEvent *theEvent)
wxSpinEvent event(wxEVT_SCROLL_THUMBTRACK, GetId());
event.SetPosition(GetValue());
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
#endif // wxUSE_SPINBTN
//event.SetString(GetValue());
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
void wxTextCtrl::AppendText(wxString const&)
wxLogTrace(wxTRACE_COCOA,wxT("wxTopLevelWindowCocoa=%p::CocoaDelegate_windowDidBecomeKey"),this);
wxActivateEvent event(wxEVT_ACTIVATE, true, GetId());
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
void wxTopLevelWindowCocoa::CocoaDelegate_windowDidResignKey(void)
wxLogTrace(wxTRACE_COCOA,wxT("wxTopLevelWindowCocoa=%p::CocoaDelegate_windowDidResignKey"),this);
wxActivateEvent event(wxEVT_ACTIVATE, false, GetId());
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
void wxTopLevelWindowCocoa::CocoaDelegate_windowDidBecomeMain(void)
// is shown. I doubt this will cause any problems though.
wxSizeEvent event(GetSize(), GetId());
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
[m_cocoaNSWindow makeKeyAndOrderFront:m_cocoaNSWindow];
}
}
wxScrollWinEvent event(commandType, scrollpos, orientation);
event.SetEventObject(m_owner);
- m_owner->GetEventHandler()->ProcessEvent(event);
+ m_owner->HandleWindowEvent(event);
}
void wxWindowCocoaScrollView::UpdateSizes()
wxLogTrace(wxTRACE_COCOA,wxT("wxWindowCocoaScrollView=%p::Cocoa_FrameChanged for wxWindow %p"), this, m_owner);
wxSizeEvent event(m_owner->GetSize(), m_owner->GetId());
event.SetEventObject(m_owner);
- m_owner->GetEventHandler()->ProcessEvent(event);
+ m_owner->HandleWindowEvent(event);
UpdateSizes();
}
wxPaintEvent event(m_windowId);
event.SetEventObject(this);
- bool ret = GetEventHandler()->ProcessEvent(event);
+ bool ret = HandleWindowEvent(event);
m_isInPaint = false;
return ret;
}
wxMouseEvent event(wxEVT_MOTION);
InitMouseEvent(event,theEvent);
wxLogTrace(wxTRACE_COCOA,wxT("wxWindow=%p::Cocoa_mouseMoved @%d,%d"),this,event.m_x,event.m_y);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
void wxWindowCocoa::Cocoa_synthesizeMouseMoved()
event.SetId(GetId());
wxLogTrace(wxTRACE_COCOA,wxT("wxwin=%p Synthesized Mouse Moved @%d,%d"),this,event.m_x,event.m_y);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
bool wxWindowCocoa::Cocoa_mouseEntered(WX_NSEvent theEvent)
wxMouseEvent event(wxEVT_ENTER_WINDOW);
InitMouseEvent(event,theEvent);
wxLogTrace(wxTRACE_COCOA_TrackingRect,wxT("wxwin=%p Mouse Entered TR#%d @%d,%d"),this,[theEvent trackingNumber], event.m_x,event.m_y);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
else
return false;
wxMouseEvent event(wxEVT_LEAVE_WINDOW);
InitMouseEvent(event,theEvent);
wxLogTrace(wxTRACE_COCOA_TrackingRect,wxT("wxwin=%p Mouse Exited TR#%d @%d,%d"),this,[theEvent trackingNumber],event.m_x,event.m_y);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
else
return false;
wxMouseEvent event([theEvent clickCount]<2?wxEVT_LEFT_DOWN:wxEVT_LEFT_DCLICK);
InitMouseEvent(event,theEvent);
wxLogTrace(wxTRACE_COCOA,wxT("Mouse Down @%d,%d num clicks=%d"),event.m_x,event.m_y,[theEvent clickCount]);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowCocoa::Cocoa_mouseDragged(WX_NSEvent theEvent)
InitMouseEvent(event,theEvent);
event.m_leftDown = true;
wxLogTrace(wxTRACE_COCOA,wxT("Mouse Drag @%d,%d"),event.m_x,event.m_y);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowCocoa::Cocoa_mouseUp(WX_NSEvent theEvent)
wxMouseEvent event(wxEVT_LEFT_UP);
InitMouseEvent(event,theEvent);
wxLogTrace(wxTRACE_COCOA,wxT("Mouse Up @%d,%d"),event.m_x,event.m_y);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowCocoa::Cocoa_rightMouseDown(WX_NSEvent theEvent)
wxMouseEvent event([theEvent clickCount]<2?wxEVT_RIGHT_DOWN:wxEVT_RIGHT_DCLICK);
InitMouseEvent(event,theEvent);
wxLogDebug(wxT("Mouse Down @%d,%d num clicks=%d"),event.m_x,event.m_y,[theEvent clickCount]);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowCocoa::Cocoa_rightMouseDragged(WX_NSEvent theEvent)
InitMouseEvent(event,theEvent);
event.m_rightDown = true;
wxLogDebug(wxT("Mouse Drag @%d,%d"),event.m_x,event.m_y);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowCocoa::Cocoa_rightMouseUp(WX_NSEvent theEvent)
wxMouseEvent event(wxEVT_RIGHT_UP);
InitMouseEvent(event,theEvent);
wxLogDebug(wxT("Mouse Up @%d,%d"),event.m_x,event.m_y);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowCocoa::Cocoa_otherMouseDown(WX_NSEvent theEvent)
m_visibleTrackingRectManager->RebuildTrackingRect();
wxSizeEvent event(GetSize(), m_windowId);
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
else
{
#endif
#include "wx/event.h"
+#include "wx/evtloop.h"
#ifndef WX_PRECOMP
#include "wx/list.h"
return TryParent(event);
}
+bool wxEvtHandler::SafelyProcessEvent(wxEvent& event)
+{
+#if wxUSE_EXCEPTIONS
+ try
+ {
+#endif
+ return ProcessEvent(event);
+#if wxUSE_EXCEPTIONS
+ }
+ catch ( ... )
+ {
+ wxEventLoopBase *loop = wxEventLoopBase::GetActive();
+ try
+ {
+ if ( !wxTheApp || !wxTheApp->OnExceptionInMainLoop() )
+ {
+ if ( loop )
+ loop->Exit();
+ }
+ //else: continue running current event loop
+
+ return false;
+ }
+ catch ( ... )
+ {
+ // OnExceptionInMainLoop() threw, possibly rethrowing the same
+ // exception again: very good, but we still need Exit() to
+ // be called
+ if ( loop )
+ loop->Exit();
+ throw;
+ }
+ }
+#endif // wxUSE_EXCEPTIONS
+}
+
bool wxEvtHandler::SearchEventTable(wxEventTable& table, wxEvent& event)
{
return false;
}
+bool wxWindowBase::HandleWindowEvent(wxEvent& event) const
+{
+ return GetEventHandler()->SafelyProcessEvent(event);
+}
+
// ----------------------------------------------------------------------------
// colours, fonts &c
// ----------------------------------------------------------------------------
m_sizeSet = true;
wxSizeEvent event(GetSize(), GetId());
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
// make sure the window is fully painted, with all pending updates, before
wxActivateEvent event(wxEVT_ACTIVATE, activate, GetId());
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
// if a frame that doesn't have wx focus inside it just got focus, we
// need to set focus to it (or its child):
// notify the parent keeping track of focus for the kbd navigation
// purposes that we got it
wxChildFocusEvent eventFocus((wxWindow*)this);
- GetEventHandler()->ProcessEvent(eventFocus);
+ HandleWindowEvent(eventFocus);
wxFocusEvent event(wxEVT_SET_FOCUS, GetId());
event.SetEventObject(this);
event.SetWindow((wxWindow*)oldFocusedWindow);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
#if wxUSE_CARET
// caret needs to be informed about focus change
wxFocusEvent event(wxEVT_KILL_FOCUS, GetId());
event.SetEventObject(this);
event.SetWindow(gs_toBeFocusedWindow);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
// ----------------------------------------------------------------------------
wxSize newSize(width, height);
wxSizeEvent event(newSize, GetId());
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
}
wxWindowDC dc((wxWindow*)this);
wxEraseEvent eventEr(m_windowId, &dc);
eventEr.SetEventObject(this);
- GetEventHandler()->ProcessEvent(eventEr);
+ HandleWindowEvent(eventEr);
wxRect clientRect(GetClientRect());
{
wxNcPaintEvent eventNc(GetId());
eventNc.SetEventObject(this);
- GetEventHandler()->ProcessEvent(eventNc);
+ HandleWindowEvent(eventNc);
}
else
{
{
wxPaintEvent eventPt(GetId());
eventPt.SetEventObject(this);
- GetEventHandler()->ProcessEvent(eventPt);
+ HandleWindowEvent(eventPt);
}
else
{
if ( e.type == DWET_KEYUP )
{
event.SetEventType(wxEVT_KEY_UP);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
else
{
event.SetEventType(wxEVT_KEY_DOWN);
- if ( GetEventHandler()->ProcessEvent(event) )
+ if ( HandleWindowEvent(event) )
return;
// only send wxEVT_CHAR event if not processed yet:
if ( event.m_keyCode != 0 )
{
event.SetEventType(wxEVT_CHAR);
- if ( GetEventHandler()->ProcessEvent(event) )
+ if ( HandleWindowEvent(event) )
return;
}
// Ctrl-TAB changes the (parent) window, i.e. switch notebook page:
navEvent.SetWindowChange(event.m_controlDown);
navEvent.SetCurrentFocus(wxStaticCast(this, wxWindow));
- GetParent()->GetEventHandler()->ProcessEvent(navEvent);
+ GetParent()->HandleWindowEvent(navEvent);
}
}
}
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, button->GetId());
event.SetEventObject(button);
- button->GetEventHandler()->ProcessEvent(event);
+ button->HandleWindowEvent(event);
}
}
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, button->GetId());
event.SetEventObject(button);
- button->GetEventHandler()->ProcessEvent(event);
+ button->HandleWindowEvent(event);
}
}
wxCommandEvent event(wxEVT_COMMAND_CHECKBOX_CLICKED, cb->GetId());
event.SetInt(cb->Get3StateValue());
event.SetEventObject(cb);
- cb->GetEventHandler()->ProcessEvent(event);
+ cb->HandleWindowEvent(event);
}
}
new_event.SetInt( gtk_tree_path_get_indices(path)[0] );
gtk_tree_path_free(path);
listbox->Check( new_event.GetInt(), !listbox->IsChecked(new_event.GetInt()));
- listbox->GetEventHandler()->ProcessEvent( new_event );
+ listbox->HandleWindowEvent( new_event );
}
}
else if ( choice->HasClientUntypedData() )
event.SetClientData( choice->GetClientData(n) );
- choice->GetEventHandler()->ProcessEvent(event);
+ choice->HandleWindowEvent(event);
}
}
// fire the colour-changed event
wxColourPickerEvent event(p, p->GetId(), p->GetColour());
- p->GetEventHandler()->ProcessEvent(event);
+ p->HandleWindowEvent(event);
}
}
{
// fire an event
wxCollapsiblePaneEvent ev(p, p->GetId(), p->IsCollapsed());
- p->GetEventHandler()->ProcessEvent(ev);
+ p->HandleWindowEvent(ev);
// the user asked to explicitely handle the resizing itself...
return;
// fire an event
wxCollapsiblePaneEvent ev(p, p->GetId(), p->IsCollapsed());
- p->GetEventHandler()->ProcessEvent(ev);
+ p->HandleWindowEvent(ev);
}
}
wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, combo->GetId() );
event.SetString( combo->GetValue() );
event.SetEventObject( combo );
- combo->GetEventHandler()->ProcessEvent( event );
+ combo->HandleWindowEvent( event );
}
static void
event.SetInt( combo->GetSelection() );
event.SetString( combo->GetStringSelection() );
event.SetEventObject( combo );
- combo->GetEventHandler()->ProcessEvent( event );
+ combo->HandleWindowEvent( event );
}
}
eventEnter.SetInt( GetSelection() );
eventEnter.SetEventObject( this );
- if ( GetEventHandler()->ProcessEvent(eventEnter) )
+ if ( HandleWindowEvent(eventEnter) )
{
// Catch GTK event so that GTK doesn't open the drop
// down list upon RETURN.
wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED, dv->GetId() );
event.SetDataViewColumn( gs_lastLeftClickHeader );
event.SetModel( dv->GetModel() );
- dv->GetEventHandler()->ProcessEvent( event );
+ dv->HandleWindowEvent( event );
}
gs_lastLeftClickHeader = NULL;
event.SetModel( dv->GetModel() );
wxDataViewItem item( s_user_data );
event.SetItem( item );
- dv->GetEventHandler()->ProcessEvent( event );
+ dv->HandleWindowEvent( event );
}
static void
gtk_tree_path_free( tree_path );
wxDataViewItem item( iter.user_data );
event.SetItem( item );
- dv->GetEventHandler()->ProcessEvent( event );
+ dv->HandleWindowEvent( event );
if (GTK_IS_CELL_EDITABLE(editable))
{
wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK, dv->GetId() );
event.SetDataViewColumn( column );
event.SetModel( dv->GetModel() );
- if (dv->GetEventHandler()->ProcessEvent( event ))
+ if (dv->HandleWindowEvent( event ))
return FALSE;
}
wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, dv->GetId() );
event.SetDataViewColumn( column );
event.SetModel( dv->GetModel() );
- if (dv->GetEventHandler()->ProcessEvent( event ))
+ if (dv->HandleWindowEvent( event ))
return FALSE;
}
event.SetEventObject( m_owner );
event.SetModel( m_owner->GetModel() );
event.SetItem( item );
- m_owner->GetEventHandler()->ProcessEvent( event );
+ m_owner->HandleWindowEvent( event );
return true;
}
event.SetColumn( col );
event.SetDataViewColumn( GetOwner()->GetColumn(col) );
event.SetItem( item );
- m_owner->GetEventHandler()->ProcessEvent( event );
+ m_owner->HandleWindowEvent( event );
return true;
}
wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED, dv->GetId() );
event.SetItem( dv->GetSelection() );
event.SetModel( dv->GetModel() );
- dv->GetEventHandler()->ProcessEvent( event );
+ dv->HandleWindowEvent( event );
}
static void
wxDataViewItem item( (void*) iter.user_data );;
event.SetItem( item );
event.SetModel( dv->GetModel() );
- dv->GetEventHandler()->ProcessEvent( event );
+ dv->HandleWindowEvent( event );
}
static gboolean
wxDataViewItem item( (void*) iter->user_data );;
event.SetItem( item );
event.SetModel( dv->GetModel() );
- dv->GetEventHandler()->ProcessEvent( event );
+ dv->HandleWindowEvent( event );
return !event.IsAllowed();
}
wxDataViewItem item( (void*) iter->user_data );;
event.SetItem( item );
event.SetModel( dv->GetModel() );
- dv->GetEventHandler()->ProcessEvent( event );
+ dv->HandleWindowEvent( event );
}
static gboolean
wxDataViewItem item( (void*) iter->user_data );;
event.SetItem( item );
event.SetModel( dv->GetModel() );
- dv->GetEventHandler()->ProcessEvent( event );
+ dv->HandleWindowEvent( event );
return !event.IsAllowed();
}
wxDataViewItem item( (void*) iter->user_data );;
event.SetItem( item );
event.SetModel( dv->GetModel() );
- dv->GetEventHandler()->ProcessEvent( event );
+ dv->HandleWindowEvent( event );
}
//-----------------------------------------------------------------------------
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, wxID_OK);
event.SetEventObject(dialog);
- dialog->GetEventHandler()->ProcessEvent(event);
+ dialog->HandleWindowEvent(event);
}
}
{
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
event.SetEventObject(dialog);
- dialog->GetEventHandler()->ProcessEvent(event);
+ dialog->HandleWindowEvent(event);
}
}
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, wxID_OK);
event.SetEventObject(dialog);
- dialog->GetEventHandler()->ProcessEvent(event);
+ dialog->HandleWindowEvent(event);
}
}
{
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
event.SetEventObject(dialog);
- dialog->GetEventHandler()->ProcessEvent(event);
+ dialog->HandleWindowEvent(event);
}
static void gtk_filedialog_response_callback(GtkWidget *w,
// ...and fire an event
wxFileDirPickerEvent event(wxEVT_COMMAND_FILEPICKER_CHANGED, this, GetId(), m_path);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
}
// ...and fire an event
wxFileDirPickerEvent event(wxEVT_COMMAND_DIRPICKER_CHANGED, p, p->GetId(), p->GetPath());
- p->GetEventHandler()->ProcessEvent(event);
+ p->HandleWindowEvent(event);
}
}
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, wxID_OK);
event.SetEventObject( dialog );
- dialog->GetEventHandler()->ProcessEvent( event );
+ dialog->HandleWindowEvent( event );
}
}
{
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
event.SetEventObject( dialog );
- dialog->GetEventHandler()->ProcessEvent( event );
+ dialog->HandleWindowEvent( event );
}
}
// fire the colour-changed event
wxFontPickerEvent event(p, p->GetId(), p->GetSelectedFont());
- p->GetEventHandler()->ProcessEvent(event);
+ p->HandleWindowEvent(event);
}
}
{
wxPaintEvent event( win->GetId() );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
win->m_exposed = false;
win->GetUpdateRegion().Clear();
wxSizeEvent event( wxSize(win->m_width,win->m_height), win->GetId() );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
}
{
wxPaintEvent event( GetId() );
event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
m_exposed = false;
GetUpdateRegion().Clear();
event.SetInt(-1);
}
- listbox->GetEventHandler()->ProcessEvent( event );
+ listbox->HandleWindowEvent( event );
}
}
event.SetExtraLong( 0 );
event.SetInt( -1 );
- listbox->GetEventHandler()->ProcessEvent( event );
+ listbox->HandleWindowEvent( event );
return;
}
event.SetExtraLong( 1 );
event.SetInt( selections[0] );
- listbox->GetEventHandler()->ProcessEvent( event );
+ listbox->HandleWindowEvent( event );
}
}
else
event.SetExtraLong( 0 );
event.SetInt( -1 );
- listbox->GetEventHandler()->ProcessEvent( event );
+ listbox->HandleWindowEvent( event );
return;
}
else if ( listbox->HasClientUntypedData() )
event.SetClientData( gtk_tree_entry_get_userdata(entry) );
- listbox->GetEventHandler()->ProcessEvent( event );
+ listbox->HandleWindowEvent( event );
g_object_unref (entry);
}
{
wxActivateEvent event1( wxEVT_ACTIVATE, false, child->GetId() );
event1.SetEventObject( child);
- child->GetEventHandler()->ProcessEvent( event1 );
+ child->HandleWindowEvent( event1 );
}
// send activate event to new child
wxActivateEvent event2( wxEVT_ACTIVATE, true, child->GetId() );
event2.SetEventObject( child);
- child->GetEventHandler()->ProcessEvent( event2 );
+ child->HandleWindowEvent( event2 );
}
}
event.SetEventObject( menu );
wxEvtHandler* handler = menu->GetEventHandler();
- if (handler && handler->ProcessEvent(event))
+ if (handler && handler->SafelyProcessEvent(event))
return;
wxWindow *win = menu->GetInvokingWindow();
if (win)
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
extern "C" {
if (item->IsCheckable())
commandEvent.SetInt(item->IsChecked());
- frame->GetEventHandler()->ProcessEvent(commandEvent);
+ frame->HandleWindowEvent(commandEvent);
}
else
{
event.SetEventObject( menu );
wxEvtHandler* handler = menu->GetEventHandler();
- if (handler && handler->ProcessEvent(event))
+ if (handler && handler->SafelyProcessEvent(event))
return;
wxWindow *win = menu->GetInvokingWindow();
- if (win) win->GetEventHandler()->ProcessEvent( event );
+ if (win) win->HandleWindowEvent( event );
}
}
event.SetEventObject( menu );
wxEvtHandler* handler = menu->GetEventHandler();
- if (handler && handler->ProcessEvent(event))
+ if (handler && handler->SafelyProcessEvent(event))
return;
wxWindow *win = menu->GetInvokingWindow();
if (win)
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
}
wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
event.SetEventObject( win );
- (void)win->GetEventHandler()->ProcessEvent( event );
+ (void)win->HandleWindowEvent( event );
return TRUE;
}
gtk_widget_set_size_request( m_widget, m_width, m_height );
wxSizeEvent event(GetSize(), GetId());
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
}
{
wxSizeEvent event(GetSize(), GetId());
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
bool ret = wxWindow::Show( show );
event.SetInt( rb->GetSelection() );
event.SetString( rb->GetStringSelection() );
event.SetEventObject( rb );
- rb->GetEventHandler()->ProcessEvent(event);
+ rb->HandleWindowEvent(event);
}
}
// CTRL-TAB changes the (parent) window, i.e. switch notebook page
new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
new_event.SetCurrentFocus( rb );
- return rb->GetParent()->GetEventHandler()->ProcessEvent( new_event );
+ return rb->GetParent()->HandleWindowEvent(new_event);
}
if ((gdk_event->keyval != GDK_Up) &&
// never stop the signal emission, it seems to break the kbd handling
// inside the radiobox
- (void)win->GetEventHandler()->ProcessEvent( event );
+ (void)win->HandleWindowEvent( event );
}
return FALSE;
wxFocusEvent event( wxEVT_KILL_FOCUS, GetId() );
event.SetEventObject( this );
- (void)GetEventHandler()->ProcessEvent( event );
+ (void)HandleWindowEvent( event );
}
}
wxCommandEvent event( wxEVT_COMMAND_RADIOBUTTON_SELECTED, rb->GetId());
event.SetInt( rb->GetValue() );
event.SetEventObject( rb );
- rb->GetEventHandler()->ProcessEvent( event );
+ rb->HandleWindowEvent( event );
}
}
// first send the specific event for the user action
wxScrollEvent evtSpec(eventType, id, value, orient);
evtSpec.SetEventObject(win);
- win->GetEventHandler()->ProcessEvent(evtSpec);
+ win->HandleWindowEvent(evtSpec);
if (!win->m_isScrolling)
{
// and if it's over also send a general "changed" event
wxScrollEvent evtChanged(wxEVT_SCROLL_CHANGED, id, value, orient);
evtChanged.SetEventObject(win);
- win->GetEventHandler()->ProcessEvent(evtChanged);
+ win->HandleWindowEvent(evtChanged);
}
}
}
wxScrollEvent evtRel(wxEVT_SCROLL_THUMBRELEASE, id, value, orient);
evtRel.SetEventObject(win);
- win->GetEventHandler()->ProcessEvent(evtRel);
+ win->HandleWindowEvent(evtRel);
wxScrollEvent evtChanged(wxEVT_SCROLL_CHANGED, id, value, orient);
evtChanged.SetEventObject(win);
- win->GetEventHandler()->ProcessEvent(evtChanged);
+ win->HandleWindowEvent(evtChanged);
}
}
}
{
wxScrollEvent event( evtType, win->GetId(), value, orient );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
// but, in any case, except if we're dragging the slider (and so the change
{
wxScrollEvent event(wxEVT_SCROLL_CHANGED, win->GetId(), value, orient);
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
// and also generate a command event for compatibility
wxCommandEvent event( wxEVT_COMMAND_SLIDER_UPDATED, win->GetId() );
event.SetEventObject( win );
event.SetInt( value );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
static inline wxEventType GtkScrollTypeToWx(int scrollType)
event.SetPosition(pos);
event.SetEventObject(win);
- if ((win->GetEventHandler()->ProcessEvent( event )) &&
+ if ((win->HandleWindowEvent( event )) &&
!event.IsAllowed() )
{
/* program has vetoed */
wxSpinEvent event2(wxEVT_SCROLL_THUMBTRACK, win->GetId());
event2.SetPosition(pos);
event2.SetEventObject(win);
- win->GetEventHandler()->ProcessEvent(event2);
+ win->HandleWindowEvent(event2);
}
}
// values in range 5..50 is then, ummm, quite challenging (hint: you can't
// enter 1!) (VZ)
event.SetInt(win->m_pos);
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
}
// see above
event.SetInt(win->m_pos);
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
}
GtkSpinButton *gsb = GTK_SPIN_BUTTON(m_widget);
wxString val = wxGTK_CONV_BACK( gtk_entry_get_text( &gsb->entry ) );
evt.SetString( val );
- if (GetEventHandler()->ProcessEvent(evt)) return;
+ if (HandleWindowEvent(evt)) return;
}
event.Skip();
if (!tool->IsEnabled()) return FALSE;
wxCommandEvent evt(wxEVT_COMMAND_TOOL_DROPDOWN_CLICKED, tool->GetId() );
- if ( tbar->GetEventHandler()->ProcessEvent(evt) )
+ if ( tbar->HandleWindowEvent(evt) )
{
return TRUE;
}
{
wxClipboardTextEvent event( eventType, win->GetId() );
event.SetEventObject( win );
- if ( win->GetEventHandler()->ProcessEvent( event ) )
+ if ( win->HandleWindowEvent( event ) )
{
// don't let the default processing to take place if we did something
// ourselves in the event handler
wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
event.SetEventObject(this);
event.SetString(GetValue());
- if ( GetEventHandler()->ProcessEvent(event) )
+ if ( HandleWindowEvent(event) )
return;
}
}
InitCommandEvent(url_event);
// Is that a good idea? Seems not (pleasure with gtk_text_view_start_selection_drag)
- //event.Skip(!GetEventHandler()->ProcessEvent(url_event));
- GetEventHandler()->ProcessEvent(url_event);
+ //event.Skip(!HandleWindowEvent(url_event));
+ HandleWindowEvent(url_event);
}
bool wxTextCtrl::GTKProcessEvent(wxEvent& event) const
wxCommandEvent event(wxEVT_COMMAND_TEXT_MAXLEN, win->GetId());
event.SetEventObject(win);
event.SetString(GetValue());
- win->GetEventHandler()->ProcessEvent(event);
+ win->HandleWindowEvent(event);
}
#endif // wxUSE_TEXTCTRL || wxUSE_COMBOBOX
wxCommandEvent event(wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, cb->GetId());
event.SetInt(cb->GetValue());
event.SetEventObject(cb);
- cb->GetEventHandler()->ProcessEvent(event);
+ cb->HandleWindowEvent(event);
}
}
wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
wxActivateEvent event(wxEVT_ACTIVATE, true, g_activeFrame->GetId());
event.SetEventObject(g_activeFrame);
- g_activeFrame->GetEventHandler()->ProcessEvent(event);
+ g_activeFrame->HandleWindowEvent(event);
return FALSE;
}
wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
wxActivateEvent event(wxEVT_ACTIVATE, false, g_activeFrame->GetId());
event.SetEventObject(g_activeFrame);
- g_activeFrame->GetEventHandler()->ProcessEvent(event);
+ g_activeFrame->HandleWindowEvent(event);
g_activeFrame = NULL;
}
{
wxSizeEvent event(size, win->GetId());
event.SetEventObject(win);
- win->GetEventHandler()->ProcessEvent(event);
+ win->HandleWindowEvent(event);
}
// else the window is currently unmapped, don't generate size events
}
win->m_y = point.y;
wxMoveEvent mevent(point, win->GetId());
mevent.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( mevent );
+ win->HandleWindowEvent( mevent );
return FALSE;
}
// top down), before the initial size_allocate signals occur.
wxSizeEvent event(GetSize(), GetId());
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
bool change = wxTopLevelWindowBase::Show(show);
GetClientSize(&m_oldClientWidth, &m_oldClientHeight);
wxSizeEvent event(GetSize(), GetId());
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
}
if( wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
{
// Emit KEY_DOWN event
- ret = win->GetEventHandler()->ProcessEvent( event );
+ ret = win->HandleWindowEvent( event );
}
else
{
if (command != -1)
{
wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
- ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
+ ret = ancestor->HandleWindowEvent( command_event );
break;
}
if (ancestor->IsTopLevel())
if (parent)
{
event.SetEventType( wxEVT_CHAR_HOOK );
- ret = parent->GetEventHandler()->ProcessEvent( event );
+ ret = parent->HandleWindowEvent( event );
}
if (!ret)
{
event.SetEventType(wxEVT_CHAR);
- ret = win->GetEventHandler()->ProcessEvent( event );
+ ret = win->HandleWindowEvent( event );
}
}
}
if (parent)
{
event.SetEventType( wxEVT_CHAR_HOOK );
- ret = parent->GetEventHandler()->ProcessEvent( event );
+ ret = parent->HandleWindowEvent( event );
}
if (!ret)
{
event.SetEventType(wxEVT_CHAR);
- ret = window->GetEventHandler()->ProcessEvent( event );
+ ret = window->HandleWindowEvent( event );
}
}
}
bool wxWindowGTK::GTKProcessEvent(wxEvent& event) const
{
// nothing special at this level
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny *event) const
// Notify the parent keeping track of focus for the kbd navigation
// purposes that we got it.
wxChildFocusEvent eventChildFocus(win);
- (void)win->GetEventHandler()->ProcessEvent(eventChildFocus);
+ (void)win->HandleWindowEvent(eventChildFocus);
wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
eventFocus.SetEventObject(win);
- return win->GetEventHandler()->ProcessEvent(eventFocus);
+ return win->HandleWindowEvent(eventFocus);
}
// all event handlers must have C linkage as they're called from GTK+ C code
{
wxMouseCaptureLostEvent evt( win->GetId() );
evt.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( evt );
+ win->HandleWindowEvent( evt );
}
return false;
}
{
wxSizeEvent event( wxSize(m_width,m_height), GetId() );
event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
}
}
}
gtk_widget_show( m_widget );
wxShowEvent eventShow(GetId(), true);
eventShow.SetEventObject(this);
- GetEventHandler()->ProcessEvent(eventShow);
+ HandleWindowEvent(eventShow);
m_showOnIdle = false;
return true;
}
gtk_widget_show( m_widget );
wxShowEvent eventShow(GetId(), show);
eventShow.SetEventObject(this);
- GetEventHandler()->ProcessEvent(eventShow);
+ HandleWindowEvent(eventShow);
}
}
else
gtk_widget_hide( m_widget );
wxShowEvent eventShow(GetId(), show);
eventShow.SetEventObject(this);
- GetEventHandler()->ProcessEvent(eventShow);
+ HandleWindowEvent(eventShow);
}
return true;
wxEraseEvent erase_event( GetId(), &dc );
erase_event.SetEventObject( this );
- GetEventHandler()->ProcessEvent(erase_event);
+ HandleWindowEvent(erase_event);
}
wxNcPaintEvent nc_paint_event( GetId() );
nc_paint_event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( nc_paint_event );
+ HandleWindowEvent( nc_paint_event );
wxPaintEvent paint_event( GetId() );
paint_event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( paint_event );
+ HandleWindowEvent( paint_event );
m_clipPaintRegion = false;
DoReleaseMouse();
wxMouseCaptureLostEvent evt(GetId());
evt.SetEventObject( this );
- GetEventHandler()->ProcessEvent( evt );
+ HandleWindowEvent( evt );
}
/* static */
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, button->GetId());
event.SetEventObject(button);
- button->GetEventHandler()->ProcessEvent(event);
+ button->HandleWindowEvent(event);
}
}
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, button->GetId());
event.SetEventObject(button);
- button->GetEventHandler()->ProcessEvent(event);
+ button->HandleWindowEvent(event);
}
}
wxCommandEvent event(wxEVT_COMMAND_CHECKBOX_CLICKED, cb->GetId());
event.SetInt(cb->GetValue());
event.SetEventObject(cb);
- cb->GetEventHandler()->ProcessEvent(event);
+ cb->HandleWindowEvent(event);
}
}
else if ( choice->HasClientUntypedData() )
event.SetClientData( choice->GetClientData(n) );
- choice->GetEventHandler()->ProcessEvent(event);
+ choice->HandleWindowEvent(event);
}
}
wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, combo->GetId() );
event.SetString( combo->GetValue() );
event.SetEventObject( combo );
- combo->GetEventHandler()->ProcessEvent( event );
+ combo->HandleWindowEvent( event );
}
}
event.SetInt( curSelection );
event.SetString( combo->GetStringSelection() );
event.SetEventObject( combo );
- combo->GetEventHandler()->ProcessEvent( event );
+ combo->HandleWindowEvent( event );
// for consistency with the other ports, send TEXT event
wxCommandEvent event2( wxEVT_COMMAND_TEXT_UPDATED, combo->GetId() );
event2.SetString( combo->GetStringSelection() );
event2.SetEventObject( combo );
- combo->GetEventHandler()->ProcessEvent( event2 );
+ combo->HandleWindowEvent( event2 );
}
}
}
event.SetInt( curSelection );
event.SetString( combo->GetStringSelection() );
event.SetEventObject( combo );
- combo->GetEventHandler()->ProcessEvent( event );
+ combo->HandleWindowEvent( event );
// for consistency with the other ports, don't generate text update
// events while the user is browsing the combobox neither
wxCommandEvent event2( wxEVT_COMMAND_TEXT_UPDATED, combo->GetId() );
event2.SetString( combo->GetValue() );
event2.SetEventObject( combo );
- combo->GetEventHandler()->ProcessEvent( event2 );
+ combo->HandleWindowEvent( event2 );
}
}
}
eventEnter.SetInt( GetSelection() );
eventEnter.SetEventObject( this );
- if (!GetEventHandler()->ProcessEvent( eventEnter ))
+ if (!HandleWindowEvent( eventEnter ))
{
// This will invoke the dialog default action, such
// as the clicking the default button.
wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
cancelEvent.SetEventObject( this );
- GetEventHandler()->ProcessEvent(cancelEvent);
+ HandleWindowEvent(cancelEvent);
s_closing.DeleteObject(this);
}
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, wxID_OK);
event.SetEventObject( dialog );
- dialog->GetEventHandler()->ProcessEvent( event );
+ dialog->HandleWindowEvent( event );
}
}
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
event.SetEventObject( dialog );
- dialog->GetEventHandler()->ProcessEvent( event );
+ dialog->HandleWindowEvent( event );
}
}
// send size event to frame
wxSizeEvent event( wxSize(m_width,m_height), GetId() );
event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
#if wxUSE_STATUSBAR
// send size event to status bar
{
wxSizeEvent event2( wxSize(m_frameStatusBar->m_width,m_frameStatusBar->m_height), m_frameStatusBar->GetId() );
event2.SetEventObject( m_frameStatusBar );
- m_frameStatusBar->GetEventHandler()->ProcessEvent( event2 );
+ m_frameStatusBar->HandleWindowEvent( event2 );
}
#endif // wxUSE_STATUSBAR
{
wxPaintEvent event( win->GetId() );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
win->GetUpdateRegion().Clear();
wxSizeEvent event( wxSize(win->m_width,win->m_height), win->GetId() );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
}
{
wxPaintEvent event( GetId() );
event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
GetUpdateRegion().Clear();
}
win->m_hasFocus = true;
wxChildFocusEvent eventChildFocus(win);
- (void)win->GetEventHandler()->ProcessEvent(eventChildFocus);
+ (void)win->HandleWindowEvent(eventChildFocus);
wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
eventFocus.SetEventObject(win);
- (void)win->GetEventHandler()->ProcessEvent(eventFocus);
+ (void)win->HandleWindowEvent(eventFocus);
}
return FALSE;
// process it too as otherwise bad things happen, especially in GTK2
// where the text control simply aborts the program if it doesn't get
// the matching focus out event
- (void)win->GetEventHandler()->ProcessEvent( event );
+ (void)win->HandleWindowEvent( event );
}
return FALSE;
event.SetInt(n);
- listbox->GetEventHandler()->ProcessEvent( event );
+ listbox->HandleWindowEvent( event );
return FALSE;
}
wxCommandEvent event( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, listbox->GetId() );
event.SetEventObject( listbox );
event.SetInt( sel );
- listbox->GetEventHandler()->ProcessEvent( event );
+ listbox->HandleWindowEvent( event );
}
#endif // wxUSE_CHECKLISTBOX
/* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
new_event.SetCurrentFocus( listbox );
- ret = listbox->GetEventHandler()->ProcessEvent( new_event );
+ ret = listbox->HandleWindowEvent( new_event );
}
if ((gdk_event->keyval == GDK_Return) && (!ret))
wxCommandEvent new_event( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, listbox->GetId() );
new_event.SetEventObject( listbox );
new_event.SetInt( sel );
- ret = listbox->GetEventHandler()->ProcessEvent( new_event );
+ ret = listbox->HandleWindowEvent( new_event );
}
#endif // wxUSE_CHECKLISTBOX
n = -1;
}
new_event.SetInt(n);
- listbox->GetEventHandler()->ProcessEvent( new_event );
+ listbox->HandleWindowEvent( new_event );
}
}
// No longer required with new code in wxLB_SINGLE
// listbox->GetEventHandler()->AddPendingEvent( event );
- listbox->GetEventHandler()->ProcessEvent( event );
+ listbox->HandleWindowEvent( event );
}
extern "C" {
{
wxActivateEvent event1( wxEVT_ACTIVATE, false, child->GetId() );
event1.SetEventObject( child);
- child->GetEventHandler()->ProcessEvent( event1 );
+ child->HandleWindowEvent( event1 );
}
// send activate event to new child
wxActivateEvent event2( wxEVT_ACTIVATE, true, child->GetId() );
event2.SetEventObject( child);
- child->GetEventHandler()->ProcessEvent( event2 );
+ child->HandleWindowEvent( event2 );
}
}
wxWindow *win = menu->GetInvokingWindow();
if (win)
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
extern "C" {
commandEvent.SetInt(item->IsChecked());
commandEvent.SetEventObject(menu);
- frame->GetEventHandler()->ProcessEvent(commandEvent);
+ frame->HandleWindowEvent(commandEvent);
}
else
{
return;
wxWindow *win = menu->GetInvokingWindow();
- if (win) win->GetEventHandler()->ProcessEvent( event );
+ if (win) win->HandleWindowEvent( event );
}
}
wxWindow *win = menu->GetInvokingWindow();
if (win)
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
}
event.SetCurrentFocus( notebook );
wxNotebookPage *client = notebook->GetPage(sel);
- if ( !client->GetEventHandler()->ProcessEvent( event ) )
+ if ( !client->HandleWindowEvent( event ) )
{
client->SetFocus();
}
wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
event.SetEventObject( win );
- (void)win->GetEventHandler()->ProcessEvent( event );
+ (void)win->HandleWindowEvent( event );
return TRUE;
}
wxSizeEvent event( wxSize(m_width,m_height), GetId() );
event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
}
void wxPopupWindow::OnInternalIdle()
event.SetInt( rb->GetSelection() );
event.SetString( rb->GetStringSelection() );
event.SetEventObject( rb );
- rb->GetEventHandler()->ProcessEvent(event);
+ rb->HandleWindowEvent(event);
}
}
// never stop the signal emission, it seems to break the kbd handling
// inside the radiobox
- (void)win->GetEventHandler()->ProcessEvent( event );
+ (void)win->HandleWindowEvent( event );
}
return FALSE;
wxFocusEvent event( wxEVT_KILL_FOCUS, GetId() );
event.SetEventObject( this );
- (void)GetEventHandler()->ProcessEvent( event );
+ (void)HandleWindowEvent( event );
}
if (g_delayedFocus == this)
wxCommandEvent event( wxEVT_COMMAND_RADIOBUTTON_SELECTED, rb->GetId());
event.SetInt( rb->GetValue() );
event.SetEventObject( rb );
- rb->GetEventHandler()->ProcessEvent( event );
+ rb->HandleWindowEvent( event );
}
}
{
wxScrollEvent event( g_currentUpDownEvent, win->GetId(), value, orient );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
// throw other event (wxEVT_SCROLL_THUMBTRACK)
wxScrollEvent event( command, win->GetId(), value, orient );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
/*
wxCommandEvent cevent( wxEVT_COMMAND_SCROLLBAR_UPDATED, win->GetId() );
wxScrollEvent event( command, win->GetId(), value, orient );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
win->m_isScrolling = false;
int value = (int)(dvalue < 0 ? dvalue - 0.5 : dvalue + 0.5);
wxScrollEvent event( evtType, win->GetId(), value, orient );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
if ( evtType != wxEVT_SCROLL_THUMBTRACK )
{
wxScrollEvent event2(wxEVT_SCROLL_CHANGED, win->GetId(), value, orient);
event2.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event2 );
+ win->HandleWindowEvent( event2 );
}
wxCommandEvent cevent( wxEVT_COMMAND_SLIDER_UPDATED, win->GetId() );
cevent.SetEventObject( win );
cevent.SetInt( value );
- win->GetEventHandler()->ProcessEvent( cevent );
+ win->HandleWindowEvent( cevent );
}
//-----------------------------------------------------------------------------
event.SetPosition( value );
event.SetEventObject( win );
- if ((win->GetEventHandler()->ProcessEvent( event )) &&
+ if ((win->HandleWindowEvent( event )) &&
!event.IsAllowed() )
{
/* program has vetoed */
wxSpinEvent event2( command, win->GetId());
event2.SetPosition( value );
event2.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event2 );
+ win->HandleWindowEvent( event2 );
}
}
}
// values in range 5..50 is then, ummm, quite challenging (hint: you can't
// enter 1!) (VZ)
event.SetInt( (int)ceil(win->m_adjust->value) );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
}
// see above
event.SetInt( (int)ceil(win->m_adjust->value) );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
}
GtkSpinButton *gsb = GTK_SPIN_BUTTON(m_widget);
wxString val = wxGTK_CONV_BACK( gtk_entry_get_text( &gsb->entry ) );
evt.SetString( val );
- if (GetEventHandler()->ProcessEvent(evt)) return;
+ if (HandleWindowEvent(evt)) return;
}
event.Skip();
wxCommandEvent event(wxEVT_COMMAND_TEXT_MAXLEN, win->GetId());
event.SetEventObject(win);
event.SetString(win->GetValue());
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
}
}
wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, win->GetId() );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
}
wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
event.SetEventObject(this);
event.SetString(GetValue());
- if (GetEventHandler()->ProcessEvent(event)) return;
+ if (HandleWindowEvent(event)) return;
}
if ((key_event.GetKeyCode() == WXK_RETURN) && !(m_windowStyle & wxTE_MULTILINE))
wxCommandEvent event(wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, cb->GetId());
event.SetInt(cb->GetValue());
event.SetEventObject(cb);
- cb->GetEventHandler()->ProcessEvent(event);
+ cb->HandleWindowEvent(event);
}
}
wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
wxActivateEvent event(wxEVT_ACTIVATE, true, g_activeFrame->GetId());
event.SetEventObject(g_activeFrame);
- g_activeFrame->GetEventHandler()->ProcessEvent(event);
+ g_activeFrame->HandleWindowEvent(event);
return FALSE;
}
wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
wxActivateEvent event(wxEVT_ACTIVATE, false, g_activeFrame->GetId());
event.SetEventObject(g_activeFrame);
- g_activeFrame->GetEventHandler()->ProcessEvent(event);
+ g_activeFrame->HandleWindowEvent(event);
g_activeFrame = NULL;
}
wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
mevent.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( mevent );
+ win->HandleWindowEvent( mevent );
return FALSE;
}
// send size event to frame
wxSizeEvent event( wxSize(m_width,m_height), GetId() );
event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
m_resizing = false;
}
if ( wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
{
// Emit KEY_DOWN event
- ret = win->GetEventHandler()->ProcessEvent( event );
+ ret = win->HandleWindowEvent( event );
}
else
{
if (parent)
{
event.SetEventType( wxEVT_CHAR_HOOK );
- ret = parent->GetEventHandler()->ProcessEvent( event );
+ ret = parent->HandleWindowEvent( event );
}
if (!ret)
{
event.SetEventType(wxEVT_CHAR);
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
}
return true;
if (command != -1)
{
wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
- ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
+ ret = ancestor->HandleWindowEvent( command_event );
break;
}
if (ancestor->IsTopLevel())
if (parent)
{
event.SetEventType( wxEVT_CHAR_HOOK );
- ret = parent->GetEventHandler()->ProcessEvent( event );
+ ret = parent->HandleWindowEvent( event );
}
if (!ret)
{
event.SetEventType(wxEVT_CHAR);
- ret = win->GetEventHandler()->ProcessEvent( event );
+ ret = win->HandleWindowEvent( event );
}
}
}
// CTRL-TAB changes the (parent) window, i.e. switch notebook page
new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
new_event.SetCurrentFocus( win );
- ret = win->GetParent()->GetEventHandler()->ProcessEvent( new_event );
+ ret = win->GetParent()->HandleWindowEvent( new_event );
}
// generate wxID_CANCEL if <esc> has been pressed (typically in dialogs)
{
wxCommandEvent eventClick(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
eventClick.SetEventObject(btnCancel);
- ret = btnCancel->GetEventHandler()->ProcessEvent(eventClick);
+ ret = btnCancel->HandleWindowEvent(eventClick);
}
}
return FALSE;
}
- if ( !win->GetEventHandler()->ProcessEvent( event ) )
+ if ( !win->HandleWindowEvent( event ) )
return FALSE;
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_release_event" );
}
}
- if (win->GetEventHandler()->ProcessEvent( event ))
+ if (win->HandleWindowEvent( event ))
{
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
g_lastMouseEvent = NULL;
win->GetId(),
win->ClientToScreen(event.GetPosition()));
evtCtx.SetEventObject(win);
- return win->GetEventHandler()->ProcessEvent(evtCtx);
+ return win->HandleWindowEvent(evtCtx);
}
return FALSE;
if ( !g_captureWindow )
win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
- if (win->GetEventHandler()->ProcessEvent( event ))
+ if (win->HandleWindowEvent( event ))
{
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
return TRUE;
: wxEVT_LEAVE_WINDOW);
InitMouseEvent(win, eventM, gdk_event);
eventM.SetEventObject(win);
- win->GetEventHandler()->ProcessEvent(eventM);
+ win->HandleWindowEvent(eventM);
}
}
else // no capture
win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
}
- bool ret = win->GetEventHandler()->ProcessEvent( event );
+ bool ret = win->HandleWindowEvent( event );
g_lastMouseEvent = NULL;
if ( ret )
// Notify the parent keeping track of focus for the kbd navigation
// purposes that we got it.
wxChildFocusEvent eventChildFocus(win);
- (void)win->GetEventHandler()->ProcessEvent(eventChildFocus);
+ (void)win->HandleWindowEvent(eventChildFocus);
wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
eventFocus.SetEventObject(win);
- return win->GetEventHandler()->ProcessEvent(eventFocus);
+ return win->HandleWindowEvent(eventFocus);
}
extern "C" {
// process it too as otherwise bad things happen, especially in GTK2
// where the text control simply aborts the program if it doesn't get
// the matching focus out event
- (void)win->GetEventHandler()->ProcessEvent( event );
+ (void)win->HandleWindowEvent( event );
}
return FALSE;
event.m_x = x + pt.x;
event.m_y = y + pt.y;
- if (win->GetEventHandler()->ProcessEvent( event ))
+ if (win->HandleWindowEvent( event ))
{
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
return TRUE;
event.m_x = x + pt.x;
event.m_y = y + pt.y;
- if (win->GetEventHandler()->ProcessEvent( event ))
+ if (win->HandleWindowEvent( event ))
{
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
return TRUE;
wxScrollWinEvent event( command, value, wxVERTICAL );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
}
wxScrollWinEvent event( command, value, wxHORIZONTAL );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
}
wxScrollWinEvent event( command, value, dir );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
win->m_isScrolling = false;
wxWindowCreateEvent event( win );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
return FALSE;
}
{
wxSizeEvent event( win->GetSize(), win->GetId() );
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( event );
+ win->HandleWindowEvent( event );
}
}
}
{
wxSizeEvent event( wxSize(m_width,m_height), GetId() );
event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
}
m_resizing = false;
wxShowEvent eventShow(GetId(), show);
eventShow.SetEventObject(this);
- GetEventHandler()->ProcessEvent(eventShow);
+ HandleWindowEvent(eventShow);
return true;
}
wxEraseEvent erase_event( GetId(), &dc );
erase_event.SetEventObject( this );
- if (!GetEventHandler()->ProcessEvent(erase_event) && GetBackgroundStyle() != wxBG_STYLE_CUSTOM)
+ if (!HandleWindowEvent(erase_event) && GetBackgroundStyle() != wxBG_STYLE_CUSTOM)
{
if (!g_eraseGC)
{
wxNcPaintEvent nc_paint_event( GetId() );
nc_paint_event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( nc_paint_event );
+ HandleWindowEvent( nc_paint_event );
wxPaintEvent paint_event( GetId() );
paint_event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( paint_event );
+ HandleWindowEvent( paint_event );
m_clipPaintRegion = false;
{
wxWindow *win = menu->GetInvokingWindow();
if (win)
- win->GetEventHandler()->ProcessEvent(wxevent);
+ win->HandleWindowEvent(wxevent);
}
}
}
wxKeyEvent event(wxEVT_KEY_DOWN) ;
MacCreateKeyEvent( event, focus , keymessage , modifiers , when , wherex , wherey , uniChar ) ;
- handled = focus->GetEventHandler()->ProcessEvent( event ) ;
+ handled = focus->HandleWindowEvent( event ) ;
if ( handled && event.GetSkipped() )
handled = false ;
bool handled;
wxKeyEvent event( wxEVT_KEY_UP ) ;
MacCreateKeyEvent( event, focus , keymessage , modifiers , when , wherex , wherey , uniChar ) ;
- handled = focus->GetEventHandler()->ProcessEvent( event ) ;
+ handled = focus->HandleWindowEvent( event ) ;
return handled ;
}
if (tlw)
{
event.SetEventType( wxEVT_CHAR_HOOK );
- handled = tlw->GetEventHandler()->ProcessEvent( event );
+ handled = tlw->HandleWindowEvent( event );
if ( handled && event.GetSkipped() )
handled = false ;
}
{
event.SetEventType( wxEVT_CHAR );
event.Skip( false ) ;
- handled = focus->GetEventHandler()->ProcessEvent( event ) ;
+ handled = focus->HandleWindowEvent( event ) ;
}
if ( !handled && (keyval == WXK_TAB) )
/* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
new_event.SetWindowChange( event.ControlDown() );
new_event.SetCurrentFocus( focus );
- handled = focus->GetParent()->GetEventHandler()->ProcessEvent( new_event );
+ handled = focus->GetParent()->HandleWindowEvent( new_event );
if ( handled && new_event.GetSkipped() )
handled = false ;
}
// generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs)
wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
new_event.SetEventObject( focus );
- handled = focus->GetEventHandler()->ProcessEvent( new_event );
+ handled = focus->HandleWindowEvent( new_event );
}
}
#endif
wxCommandEvent event( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, checklist->GetId() );
event.SetInt( owner->GetLineFromItem( this ) );
event.SetEventObject( checklist );
- checklist->GetEventHandler()->ProcessEvent( event );
+ checklist->HandleWindowEvent( event );
}
break;
NavEvent.SetWindowChange(false);
// Get the parent of the combo and have it process the navigation?
- if (m_cb->GetParent()->GetEventHandler()->ProcessEvent(NavEvent))
+ if (m_cb->GetParent()->HandleWindowEvent(NavEvent))
return;
}
// send the event to the combobox class in case the user has bound EVT_CHAR
wxKeyEvent kevt(event);
kevt.SetEventObject(m_cb);
- if (m_cb->GetEventHandler()->ProcessEvent(kevt))
+ if (m_cb->HandleWindowEvent(kevt))
// If the event was handled and not skipped then we're done
return;
// This will invoke the dialog default action,
// such as the clicking the default button.
- if (!m_cb->GetEventHandler()->ProcessEvent( event ))
+ if (!m_cb->HandleWindowEvent( event ))
{
wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
if ( tlw && tlw->GetDefaultItem() )
{
event.SetEventObject(m_cb);
event.SetId(m_cb->GetId());
- if (! m_cb->GetEventHandler()->ProcessEvent(event))
+ if (! m_cb->HandleWindowEvent(event))
event.Skip();
}
{
event.SetEventObject(m_cb);
event.SetId(m_cb->GetId());
- if (! m_cb->GetEventHandler()->ProcessEvent(event))
+ if (! m_cb->HandleWindowEvent(event))
event.Skip();
}
{
event.SetEventObject(m_cb);
event.SetId(m_cb->GetId());
- if (! m_cb->GetEventHandler()->ProcessEvent(event))
+ if (! m_cb->HandleWindowEvent(event))
event.Skip();
}
event.SetInt( cb->GetSelection() );
event.SetString( cb->GetStringSelection() );
event.SetEventObject( cb );
- cb->GetEventHandler()->ProcessEvent( event );
+ cb->HandleWindowEvent( event );
}
break;
default :
event.SetInt( 0 );
event.SetString( value );
event.SetEventObject( m_cb );
- m_cb->GetEventHandler()->ProcessEvent( event );
+ m_cb->HandleWindowEvent( event );
}
else
{
event.SetInt( m_cb->GetCount() - 1 );
event.SetString( value );
event.SetEventObject( m_cb );
- m_cb->GetEventHandler()->ProcessEvent( event );
+ m_cb->HandleWindowEvent( event );
}
// This will invoke the dialog default action, such
// Tries:
// 1) OnCommand, starting at this window and working up parent hierarchy
// 2) OnCommand then calls ProcessEvent to search the event tables.
- return GetEventHandler()->ProcessEvent( event );
+ return HandleWindowEvent( event );
}
void wxControl::OnKeyDown( wxKeyEvent &WXUNUSED(event) )
dataViewEvent.SetEventObject(dataViewCtrlPtr);
dataViewEvent.SetItem(wxDataViewItem(reinterpret_cast<void*>(itemID)));
// finally send the equivalent wxWidget event:
- dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
+ dataViewCtrlPtr->HandleWindowEvent(dataViewEvent);
// opening the container is allowed if not vetoed:
return ::SetDataBrowserItemDataBooleanValue(itemData,dataViewEvent.IsAllowed());
} /* block */
dataViewEvent.SetEventObject(dataViewCtrlPtr);
dataViewEvent.SetItem(wxDataViewItem(reinterpret_cast<void*>(itemID)));
// finally send the equivalent wxWidget event:
- dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
+ dataViewCtrlPtr->HandleWindowEvent(dataViewEvent);
// opening the container is allowed if not vetoed:
return ::SetDataBrowserItemDataBooleanValue(itemData,dataViewEvent.IsAllowed());
} /* block */
dataViewEvent.SetEventObject(dataViewCtrlPtr);
dataViewEvent.SetItem(wxDataViewItem(reinterpret_cast<void*>(itemID)));
// finally send the equivalent wxWidget event:
- dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
+ dataViewCtrlPtr->HandleWindowEvent(dataViewEvent);
} /* block */
break;
case kDataBrowserContainerOpened:
dataViewEvent.SetEventObject(dataViewCtrlPtr);
dataViewEvent.SetItem(wxDataViewItem(reinterpret_cast<void*>(itemID)));
// finally send the equivalent wxWidget event:
- dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
+ dataViewCtrlPtr->HandleWindowEvent(dataViewEvent);
// add children to the expanded container:
dataViewCtrlPtr->AddChildrenLevel(wxDataViewItem(reinterpret_cast<void*>(itemID)));
} /* block */
dataViewEvent.SetDataViewColumn(dataViewCtrlPtr->GetColumnPtr(propertyID));
} /* if */
// finally send the equivalent wxWidget event:
- dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
+ dataViewCtrlPtr->HandleWindowEvent(dataViewEvent);
} /* block */
break;
case kDataBrowserEditStopped:
dataViewEvent.SetDataViewColumn(dataViewCtrlPtr->GetColumnPtr(propertyID));
} /* if */
// finally send the equivalent wxWidget event:
- dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
+ dataViewCtrlPtr->HandleWindowEvent(dataViewEvent);
} /* block */
break;
case kDataBrowserItemAdded:
dataViewEvent.SetEventObject(dataViewCtrlPtr);
dataViewEvent.SetItem(wxDataViewItem(reinterpret_cast<void*>(itemID)));
// finally send the equivalent wxWidget event:
- dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
+ dataViewCtrlPtr->HandleWindowEvent(dataViewEvent);
} /* block */
break;
case kDataBrowserItemRemoved:
dataViewEvent.SetEventObject(dataViewCtrlPtr);
dataViewEvent.SetModel (dataViewCtrlPtr->GetModel());
// finally send the equivalent wxWidget event:
- dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
+ dataViewCtrlPtr->HandleWindowEvent(dataViewEvent);
} /* block */
break;
case kDataBrowserUserStateChanged:
dataViewEvent.SetColumn(columnIndex);
dataViewEvent.SetDataViewColumn(columnPtr);
// finally send the equivalent wxWidget event:
- dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
+ dataViewCtrlPtr->HandleWindowEvent(dataViewEvent);
} /* if */
} /* if */
} /* if */
DataViewEvent.SetColumn(columnIndex);
DataViewEvent.SetDataViewColumn(DataViewCtrlPtr->GetColumn(columnIndex));
// finally sent the equivalent wxWidget event:
- DataViewCtrlPtr->GetEventHandler()->ProcessEvent(DataViewEvent);
+ DataViewCtrlPtr->HandleWindowEvent(DataViewEvent);
return ::CallNextEventHandler(handler,EventReference);
} /* if */
else
dataViewEvent.SetEventObject(dataViewCtrlPtr);
dataViewEvent.SetItem(item);
// sent the equivalent wxWidget event:
- dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
+ dataViewCtrlPtr->HandleWindowEvent(dataViewEvent);
// done
return true;
} /* if */
for (size_t i=0; i<noOfEntries; ++i)
{
dataViewEvent.SetItem(reinterpret_cast<void*>(itemIDs[i]));
- dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
+ dataViewCtrlPtr->HandleWindowEvent(dataViewEvent);
} /* for */
} /* if */
// release allocated array space:
dataViewEvent.SetColumn(col);
dataViewEvent.SetItem(item);
// send the equivalent wxWidget event:
- dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
+ dataViewCtrlPtr->HandleWindowEvent(dataViewEvent);
// done
return true;
} /* if */
Refresh();
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, GetId());
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
}
// direct notification is not always having the listbox GetSelection()
// having in synch with event, so use wxPostEvent instead
- // list->GetEventHandler()->ProcessEvent(event);
+ // list->HandleWindowEvent(event);
wxPostEvent( list->GetEventHandler(), event );
}
// FIXME: we can't use the sort property for virtual listctrls
// so we need to find a better way to determine which column was clicked...
if (!window->IsVirtual())
- window->GetEventHandler()->ProcessEvent( le );
+ window->HandleWindowEvent( le );
}
result = CallNextEventHandler(handler, event);
break;
if ( !event.IsKindOf( CLASSINFO( wxCommandEvent ) ) )
{
- if (m_list->GetEventHandler()->ProcessEvent( event ))
+ if (m_list->HandleWindowEvent( event ))
return true;
}
return wxEvtHandler::ProcessEvent(event);
le.m_itemIndex = item;
le.m_item.m_itemId = item;
GetItem(le.m_item);
- GetEventHandler()->ProcessEvent(le);
+ HandleWindowEvent(le);
}
}
le.m_itemIndex = m_current;
le.m_item.m_itemId = m_current;
GetItem(le.m_item);
- GetEventHandler()->ProcessEvent(le);
+ HandleWindowEvent(le);
}
}
event.Skip();
wxListEvent event( wxEVT_COMMAND_LIST_DELETE_ITEM, GetId() );
event.SetEventObject( this );
event.m_itemIndex = item;
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
}
return true;
m_dbImpl->MacClear();
wxListEvent event( wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS, GetId() );
event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
}
return true;
}
le.m_col = 0;
GetItem( le.m_item );
- if ( GetParent()->GetEventHandler()->ProcessEvent( le ) && !le.IsAllowed() )
+ if ( GetParent()->HandleWindowEvent( le ) && !le.IsAllowed() )
{
// vetoed by user code
return NULL;
wxListEvent event( wxEVT_COMMAND_LIST_INSERT_ITEM, GetId() );
event.SetEventObject( this );
event.m_itemIndex = info.m_itemId;
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
return info.m_itemId;
}
return -1;
GetItem( le.m_item );
le.m_item.m_text = value;
- return !GetEventHandler()->ProcessEvent( le ) ||
+ return !HandleWindowEvent( le ) ||
le.IsAllowed();
}
le.m_itemIndex = itemEdit;
GetItem( le.m_item );
- GetEventHandler()->ProcessEvent( le );
+ HandleWindowEvent( le );
}
// ----------------------------------------------------------------------------
// Try the menu's event handler
if ( /* !processed && */ GetEventHandler())
- processed = GetEventHandler()->ProcessEvent(event);
+ processed = HandleWindowEvent(event);
// Try the window the menu was popped up from
// (and up through the hierarchy)
wxWindow *win = GetInvokingWindow();
if ( !processed && win )
- processed = win->GetEventHandler()->ProcessEvent(event);
+ processed = win->HandleWindowEvent(event);
return processed;
}
event.SetEventObject(targetWindow);
event.SetInt(item->IsCheckable() ? item->IsChecked() : -1);
- if ( targetWindow->GetEventHandler()->ProcessEvent(event) )
+ if ( targetWindow->HandleWindowEvent(event) )
result = noErr ;
}
}
wxWindow *win = menu->GetInvokingWindow();
if ( win )
{
- processed = win->GetEventHandler()->ProcessEvent(event);
+ processed = win->HandleWindowEvent(event);
break;
}
if ( !processed && targetWindow != NULL)
{
- processed = targetWindow->GetEventHandler()->ProcessEvent(event);
+ processed = targetWindow->HandleWindowEvent(event);
}
if ( processed )
event.SetEventObject( this );
wxWindow *page = m_pages[m_nSelection];
- if ( !page->GetEventHandler()->ProcessEvent( event ) )
+ if ( !page->HandleWindowEvent( event ) )
{
page->SetFocus();
}
if ( parent )
{
event.SetCurrentFocus( this );
- parent->GetEventHandler()->ProcessEvent( event );
+ parent->HandleWindowEvent( event );
}
}
}
wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, m_windowId,
newSel , m_nSelection );
changing.SetEventObject( this );
- GetEventHandler()->ProcessEvent( changing );
+ HandleWindowEvent( changing );
if ( changing.IsAllowed() )
{
wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, m_windowId,
newSel, m_nSelection );
event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
}
else
{
// because apps expect a size event to occur at this moment
wxSizeEvent event(GetSize() , m_windowId);
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
else
{
// this is hardcoded
window->MacOnScroll( event );
else
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
}
wxInt32 wxScrollBar::MacControlHit( WXEVENTHANDLERREF WXUNUSED(handler), WXEVENTREF mevent )
// this is hardcoded
window->MacOnScroll( event );
else
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
return noErr;
}
wxScrollEvent event( wxEVT_SCROLL_THUMBTRACK, m_windowId );
event.SetPosition( value );
event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
wxCommandEvent cevent( wxEVT_COMMAND_SLIDER_UPDATED, m_windowId );
cevent.SetInt( value );
cevent.SetEventObject( this );
- GetEventHandler()->ProcessEvent( cevent );
+ HandleWindowEvent( cevent );
}
wxInt32 wxSlider::MacControlHit(WXEVENTHANDLERREF WXUNUSED(handler),
wxScrollEvent event( wxEVT_SCROLL_THUMBRELEASE, m_windowId );
event.SetPosition( value );
event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
wxCommandEvent cevent( wxEVT_COMMAND_SLIDER_UPDATED, m_windowId );
cevent.SetInt( value );
cevent.SetEventObject( this );
- GetEventHandler()->ProcessEvent( cevent );
+ HandleWindowEvent( cevent );
return noErr;
}
event.SetPosition( m_value );
event.SetEventObject( this );
- if ((GetEventHandler()->ProcessEvent( event )) && !event.IsAllowed())
+ if ((HandleWindowEvent( event )) && !event.IsAllowed())
m_value = oldValue;
m_peer->SetValue( m_value );
wxSpinEvent event2( scrollEvent, GetId() );
event2.SetPosition( m_value );
event2.SetEventObject( this );
- GetEventHandler()->ProcessEvent( event2 );
+ HandleWindowEvent( event2 );
}
}
wxCommandEvent event(wxEVT_COMMAND_SPINCTRL_UPDATED, m_spin->GetId());
event.SetEventObject(m_spin);
event.SetInt(l);
- m_spin->GetEventHandler()->ProcessEvent(event);
+ m_spin->HandleWindowEvent(event);
m_spin->m_oldValue = l;
}
event.SetString(m_spin->GetText()->GetValue());
event.SetInt(val);
- m_spin->GetEventHandler()->ProcessEvent(event);
+ m_spin->HandleWindowEvent(event);
}
event.Skip();
event.SetEventObject(m_spin);
event.SetInt(pos);
- m_spin->GetEventHandler()->ProcessEvent(event);
+ m_spin->HandleWindowEvent(event);
m_spin->m_oldValue = pos;
}
wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, m_windowId );
event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
}
}
wxCommandEvent event( wxEVT_COMMAND_TEXT_UPDATED, m_windowId );
event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
}
}
wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
event.SetEventObject( this );
event.SetString( GetValue() );
- if ( GetEventHandler()->ProcessEvent(event) )
+ if ( HandleWindowEvent(event) )
return;
}
{
event.m_keyCode = WXK_CONTROL ;
event.SetEventType( ( modifiers & controlKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
- focus->GetEventHandler()->ProcessEvent( event ) ;
+ focus->HandleWindowEvent( event ) ;
}
if ( /* focus && */ (modifiers ^ wxApp::s_lastModifiers ) & shiftKey )
{
event.m_keyCode = WXK_SHIFT ;
event.SetEventType( ( modifiers & shiftKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
- focus->GetEventHandler()->ProcessEvent( event ) ;
+ focus->HandleWindowEvent( event ) ;
}
if ( /* focus && */ (modifiers ^ wxApp::s_lastModifiers ) & optionKey )
{
event.m_keyCode = WXK_ALT ;
event.SetEventType( ( modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
- focus->GetEventHandler()->ProcessEvent( event ) ;
+ focus->HandleWindowEvent( event ) ;
}
if ( /* focus && */ (modifiers ^ wxApp::s_lastModifiers ) & cmdKey )
{
event.m_keyCode = WXK_COMMAND ;
event.SetEventType( ( modifiers & cmdKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
- focus->GetEventHandler()->ProcessEvent( event ) ;
+ focus->HandleWindowEvent( event ) ;
}
wxApp::s_lastModifiers = modifiers ;
wxToolTip::RelayEvent( g_MacLastWindow , eventleave);
#endif
- g_MacLastWindow->GetEventHandler()->ProcessEvent(eventleave);
+ g_MacLastWindow->HandleWindowEvent(eventleave);
}
if ( currentMouseWindow )
wxToolTip::RelayEvent( currentMouseWindow , evententer );
#endif
- currentMouseWindow->GetEventHandler()->ProcessEvent(evententer);
+ currentMouseWindow->HandleWindowEvent(evententer);
}
g_MacLastWindow = currentMouseWindow ;
wxToolTip::RelayEvent( currentMouseWindow , wxevent );
#endif
- if ( currentMouseWindow->GetEventHandler()->ProcessEvent(wxevent) )
+ if ( currentMouseWindow->HandleWindowEvent(wxevent) )
{
if ((currentMouseWindowParent != NULL) &&
(currentMouseWindowParent->GetChildren().Find(currentMouseWindow) == NULL))
wxActivateEvent wxevent(wxEVT_ACTIVATE, true , toplevelWindow->GetId());
wxevent.SetTimestamp( cEvent.GetTicks() ) ;
wxevent.SetEventObject(toplevelWindow);
- toplevelWindow->GetEventHandler()->ProcessEvent(wxevent);
+ toplevelWindow->HandleWindowEvent(wxevent);
// we still sending an eventNotHandledErr in order to allow for default processing
}
break ;
wxActivateEvent wxevent(wxEVT_ACTIVATE, false , toplevelWindow->GetId());
wxevent.SetTimestamp( cEvent.GetTicks() ) ;
wxevent.SetEventObject(toplevelWindow);
- toplevelWindow->GetEventHandler()->ProcessEvent(wxevent);
+ toplevelWindow->HandleWindowEvent(wxevent);
// we still sending an eventNotHandledErr in order to allow for default processing
}
break ;
wxSizeEvent event( r.GetSize() , toplevelWindow->GetId() ) ;
event.SetEventObject( toplevelWindow ) ;
- toplevelWindow->GetEventHandler()->ProcessEvent(event) ;
+ toplevelWindow->HandleWindowEvent(event) ;
toplevelWindow->wxWindowMac::MacSuperChangedPosition() ; // like this only children will be notified
}
{
wxMoveEvent event( r.GetLeftTop() , toplevelWindow->GetId() ) ;
event.SetEventObject( toplevelWindow ) ;
- toplevelWindow->GetEventHandler()->ProcessEvent(event) ;
+ toplevelWindow->HandleWindowEvent(event) ;
}
result = noErr ;
wxSizeEvent wxevent( r , toplevelWindow->GetId() ) ;
wxevent.SetEventObject( toplevelWindow ) ;
wxRect adjustR = r ;
- if ( toplevelWindow->GetEventHandler()->ProcessEvent(wxevent) )
+ if ( toplevelWindow->HandleWindowEvent(wxevent) )
adjustR = wxevent.GetRect() ;
if ( toplevelWindow->GetMaxWidth() != -1 && adjustR.GetWidth() > toplevelWindow->GetMaxWidth() )
}
wxWindowCreateEvent event(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
void wxTopLevelWindowMac::ClearBackground()
// because apps expect a size event to occur at this moment
wxSizeEvent event(GetSize() , m_windowId);
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
else
{
// because apps expect a size event to occur at this moment
wxSizeEvent event(GetSize() , m_windowId);
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
return true;
}
bIsExpanded
? wxEVT_COMMAND_TREE_ITEM_EXPANDING
: wxEVT_COMMAND_TREE_ITEM_COLLAPSING);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
event.SetEventType(
bIsExpanded
? wxEVT_COMMAND_TREE_ITEM_EXPANDED
: wxEVT_COMMAND_TREE_ITEM_COLLAPSED);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
return bOk;
inKillFocusEvent = true ;
wxFocusEvent event( wxEVT_KILL_FOCUS, thisWindow->GetId());
event.SetEventObject(thisWindow);
- thisWindow->GetEventHandler()->ProcessEvent(event) ;
+ thisWindow->HandleWindowEvent(event) ;
inKillFocusEvent = false ;
}
}
// panel wants to track the window which was the last to have focus in it
wxLogTrace(_T("Focus"), _T("focus set(%p)"), wx_static_cast(void*, thisWindow));
wxChildFocusEvent eventFocus((wxWindow*)thisWindow);
- thisWindow->GetEventHandler()->ProcessEvent(eventFocus);
+ thisWindow->HandleWindowEvent(eventFocus);
#if wxUSE_CARET
if ( thisWindow->GetCaret() )
wxFocusEvent event(wxEVT_SET_FOCUS, thisWindow->GetId());
event.SetEventObject(thisWindow);
- thisWindow->GetEventHandler()->ProcessEvent(event) ;
+ thisWindow->HandleWindowEvent(event) ;
}
}
break;
inKillFocusEvent = true ;
wxFocusEvent event( wxEVT_KILL_FOCUS, thisWindow->GetId());
event.SetEventObject(thisWindow);
- thisWindow->GetEventHandler()->ProcessEvent(event) ;
+ thisWindow->HandleWindowEvent(event) ;
inKillFocusEvent = false ;
}
}
// panel wants to track the window which was the last to have focus in it
wxLogTrace(_T("Focus"), _T("focus set(%p)"), wx_static_cast(void*, thisWindow));
wxChildFocusEvent eventFocus((wxWindow*)thisWindow);
- thisWindow->GetEventHandler()->ProcessEvent(eventFocus);
+ thisWindow->HandleWindowEvent(eventFocus);
#if wxUSE_CARET
if ( thisWindow->GetCaret() )
wxFocusEvent event(wxEVT_SET_FOCUS, thisWindow->GetId());
event.SetEventObject(thisWindow);
- thisWindow->GetEventHandler()->ProcessEvent(event) ;
+ thisWindow->HandleWindowEvent(event) ;
}
#endif
}
wxPoint point(actualX, actualY);
wxMoveEvent event(point, m_windowId);
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event) ;
+ HandleWindowEvent(event) ;
}
if ( doResize )
wxSize size(actualWidth, actualHeight);
wxSizeEvent event(size, m_windowId);
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
}
}
{
wxSizeEvent event(GetSize(), m_windowId);
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
}
else if (event.GetEventType() == wxEVT_SCROLL_THUMBRELEASE)
wevent.SetEventType( wxEVT_SCROLLWIN_THUMBRELEASE );
- GetEventHandler()->ProcessEvent(wevent);
+ HandleWindowEvent(wevent);
}
}
{
wxSetCursorEvent event( pt.x , pt.y );
- bool processedEvtSetCursor = GetEventHandler()->ProcessEvent(event);
+ bool processedEvtSetCursor = HandleWindowEvent(event);
if ( processedEvtSetCursor && event.HasCursor() )
{
cursor = event.GetCursor() ;
wxEraseEvent eevent( GetId(), dc );
eevent.SetEventObject( this );
- GetEventHandler()->ProcessEvent( eevent );
+ HandleWindowEvent( eevent );
delete dc ;
}
wxPaintEvent event;
event.SetTimestamp(time);
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
handled = true ;
}
// paint custom borders
wxNcPaintEvent eventNc( child->GetId() );
eventNc.SetEventObject( child );
- if ( !child->GetEventHandler()->ProcessEvent( eventNc ) )
+ if ( !child->HandleWindowEvent( eventNc ) )
{
child->MacPaintBorders(0, 0) ;
}
wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU,
this->GetId(),
this->ClientToScreen(event.GetPosition()));
- if ( ! GetEventHandler()->ProcessEvent(evtCtx) )
+ if ( ! HandleWindowEvent(evtCtx) )
event.Skip() ;
}
else
m_sizeSet = true;
wxSizeEvent event(GetSize(), GetId());
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
if ( ret && show && CanAcceptFocus() )
event2.SetEventObject(gs_windowUnderMouse);
event2.SetEventType(wxEVT_LEAVE_WINDOW);
- gs_windowUnderMouse->GetEventHandler()->ProcessEvent(event2);
+ gs_windowUnderMouse->HandleWindowEvent(event2);
}
wxMouseEvent event3(event);
event3.SetEventType(wxEVT_ENTER_WINDOW);
- win->GetEventHandler()->ProcessEvent(event3);
+ win->HandleWindowEvent(event3);
gs_windowUnderMouse = win;
}
wxMouseEvent evt(inside ?
wxEVT_ENTER_WINDOW : wxEVT_LEAVE_WINDOW);
evt.SetEventObject(win);
- win->GetEventHandler()->ProcessEvent(evt);
+ win->HandleWindowEvent(evt);
gs_windowUnderMouse = inside ? win : NULL;
}
}
else
{
event.SetEventType(type);
- return win->GetEventHandler()->ProcessEvent(event);
+ return win->HandleWindowEvent(event);
}
}
if ( e->what == EVT_KEYUP )
{
event.SetEventType(wxEVT_KEY_UP);
- return win->GetEventHandler()->ProcessEvent(event);
+ return win->HandleWindowEvent(event);
}
else
{
event.SetEventType(wxEVT_KEY_DOWN);
event2 = event;
- ret = win->GetEventHandler()->ProcessEvent(event);
+ ret = win->HandleWindowEvent(event);
// wxMSW doesn't send char events with Alt pressed
// Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
if ( !ret && event2.m_keyCode != 0 )
{
event2.SetEventType(wxEVT_CHAR);
- ret = win->GetEventHandler()->ProcessEvent(event2);
+ ret = win->HandleWindowEvent(event2);
}
// Synthetize navigation key event, but do it only if the TAB key
// Ctrl-TAB changes the (parent) window, i.e. switch notebook page:
navEvent.SetWindowChange(event.m_controlDown);
navEvent.SetCurrentFocus(wxStaticCast(win, wxWindow));
- ret = win->GetParent()->GetEventHandler()->ProcessEvent(navEvent);
+ ret = win->HandleWindowEvent(navEvent);
}
// Finally, process special meaning keys that are usually
{
wxActivateEvent event(wxEVT_ACTIVATE, false, gs_activeFrame->GetId());
event.SetEventObject(gs_activeFrame);
- gs_activeFrame->GetEventHandler()->ProcessEvent(event);
+ gs_activeFrame->HandleWindowEvent(event);
}
gs_activeFrame = active;
wxActivateEvent event(wxEVT_ACTIVATE, true, gs_activeFrame->GetId());
event.SetEventObject(gs_activeFrame);
- gs_activeFrame->GetEventHandler()->ProcessEvent(event);
+ gs_activeFrame->HandleWindowEvent(event);
}
// notify the parent keeping track of focus for the kbd navigation
// purposes that we got it
wxChildFocusEvent eventFocus((wxWindow*)this);
- GetEventHandler()->ProcessEvent(eventFocus);
+ HandleWindowEvent(eventFocus);
wxFocusEvent event(wxEVT_SET_FOCUS, GetId());
event.SetEventObject(this);
event.SetWindow((wxWindow*)oldFocusedWindow);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
#if wxUSE_CARET
// caret needs to be informed about focus change
wxFocusEvent event(wxEVT_KILL_FOCUS, GetId());
event.SetEventObject(this);
event.SetWindow(gs_toBeFocusedWindow);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
// ----------------------------------------------------------------------------
wxSize newSize(width, height);
wxSizeEvent event(newSize, GetId());
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
}
wxWindowDC dc((wxWindow*)this);
wxEraseEvent eventEr(m_windowId, &dc);
eventEr.SetEventObject(this);
- GetEventHandler()->ProcessEvent(eventEr);
+ HandleWindowEvent(eventEr);
}
m_eraseBackground = -1;
wxNcPaintEvent eventNc(GetId());
eventNc.SetEventObject(this);
- GetEventHandler()->ProcessEvent(eventNc);
+ HandleWindowEvent(eventNc);
wxPaintEvent eventPt(GetId());
eventPt.SetEventObject(this);
- GetEventHandler()->ProcessEvent(eventPt);
+ HandleWindowEvent(eventPt);
#if wxUSE_CARET
if ( caret )
event.SetEventObject(this);
event.SetString(GetString(n));
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
}
event.SetClientData( item->GetClientData(idx) );
event.SetExtraLong(true);
event.SetEventObject(item);
- item->GetEventHandler()->ProcessEvent(event);
+ item->HandleWindowEvent(event);
break;
}
case XmCR_VALUE_CHANGED:
event.SetString( item->GetValue() );
event.SetExtraLong(true);
event.SetEventObject(item);
- item->GetEventHandler()->ProcessEvent(event);
+ item->HandleWindowEvent(event);
break;
}
default:
bool wxControl::ProcessCommand(wxCommandEvent & event)
{
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
wxSize wxControl::DoGetBestSize() const
wxKeyEvent keyEvent(wxEVT_KEY_DOWN);
wxTranslateKeyEvent(keyEvent, win, (Widget) 0, event);
- return win->GetEventHandler()->ProcessEvent( keyEvent );
+ return win->HandleWindowEvent( keyEvent );
}
return false;
wxKeyEvent keyEvent(wxEVT_KEY_UP);
wxTranslateKeyEvent(keyEvent, win, (Widget) 0, event);
- return win->GetEventHandler()->ProcessEvent( keyEvent );
+ return win->HandleWindowEvent( keyEvent );
}
return false;
wxSizeEvent sizeEvent(newSize, GetId());
sizeEvent.SetEventObject(this);
- GetEventHandler()->ProcessEvent(sizeEvent);
+ HandleWindowEvent(sizeEvent);
return true;
}
wxSizeEvent sizeEvent(newSize, GetId());
sizeEvent.SetEventObject(this);
- GetEventHandler()->ProcessEvent(sizeEvent);
+ HandleWindowEvent(sizeEvent);
}
{
wxSysColourChangedEvent event2;
event2.SetEventObject( m_frameStatusBar );
- m_frameStatusBar->GetEventHandler()->ProcessEvent(event2);
+ m_frameStatusBar->HandleWindowEvent(event2);
}
// Propagate the event to the non-top-level children
item->DoToggleItem( n, x );
#endif
case XmCR_DEFAULT_ACTION:
- item->GetEventHandler()->ProcessEvent(event);
+ item->HandleWindowEvent(event);
break;
case XmCR_EXTENDED_SELECT:
switch (cbs->selection_type)
case XmADDITION:
case XmMODIFICATION:
item->DoToggleItem( n, x );
- item->GetEventHandler()->ProcessEvent(event);
+ item->HandleWindowEvent(event);
break;
}
break;
bool res = false;
if (m_activeChild && event.IsKindOf(CLASSINFO(wxCommandEvent)))
{
- res = m_activeChild->GetEventHandler()->ProcessEvent(event);
+ res = m_activeChild->HandleWindowEvent(event);
}
if (!res)
{
wxActivateEvent event(wxEVT_ACTIVATE, false, oldActiveChild->GetId());
event.SetEventObject( oldActiveChild );
- oldActiveChild->GetEventHandler()->ProcessEvent(event);
+ oldActiveChild->HandleWindowEvent(event);
}
// This is the currently active child
{
wxActivateEvent event(wxEVT_ACTIVATE, false, oldActiveChild->GetId());
event.SetEventObject( oldActiveChild );
- oldActiveChild->GetEventHandler()->ProcessEvent(event);
+ oldActiveChild->HandleWindowEvent(event);
}
wxActivateEvent event(wxEVT_ACTIVATE, true, this->GetId());
event.SetEventObject( this );
- this->GetEventHandler()->ProcessEvent(event);
+ this->HandleWindowEvent(event);
}
void wxMDIChildFrame::OnLower()
{
wxActivateEvent event(wxEVT_ACTIVATE, false, oldActiveChild->GetId());
event.SetEventObject( oldActiveChild );
- oldActiveChild->GetEventHandler()->ProcessEvent(event);
+ oldActiveChild->HandleWindowEvent(event);
}
// TODO: unfortunately we don't now know which is the top-most child,
// so make the active child NULL.
{
wxActivateEvent event(wxEVT_ACTIVATE, false, oldChild->GetId());
event.SetEventObject( oldChild );
- oldChild->GetEventHandler()->ProcessEvent(event);
+ oldChild->HandleWindowEvent(event);
}
}
if (event.GetSelection() != -1)
{
wxActivateEvent event(wxEVT_ACTIVATE, true, activeChild->GetId());
event.SetEventObject( activeChild );
- activeChild->GetEventHandler()->ProcessEvent(event);
+ activeChild->HandleWindowEvent(event);
if (activeChild->GetMDIParentFrame())
{
// Try the menu's event handler
if ( !processed && GetEventHandler())
{
- processed = GetEventHandler()->ProcessEvent(event);
+ processed = HandleWindowEvent(event);
}
// Try the window the menu was popped up from (and up
// through the hierarchy)
event.SetEventObject(item->GetMenuBar()->GetMenuBarFrame());
item->GetMenuBar()->GetMenuBarFrame()
- ->GetEventHandler()->ProcessEvent(event);
+ ->HandleWindowEvent(event);
}
// this is the child of a popup menu
else if (item->GetTopMenu())
menuEvent.SetEventObject(item->GetMenuBar()->GetMenuBarFrame());
item->GetMenuBar()->GetMenuBarFrame()
- ->GetEventHandler()->ProcessEvent(menuEvent);
+ ->HandleWindowEvent(menuEvent);
}
}
}
menuEvent.SetEventObject(item->GetMenuBar()->GetMenuBarFrame());
item->GetMenuBar()->GetMenuBarFrame()
- ->GetEventHandler()->ProcessEvent(menuEvent);
+ ->HandleWindowEvent(menuEvent);
}
}
}
wxScrollEvent event(eventType, scrollBar->GetId(),
cbs->value, orientation);
event.SetEventObject(scrollBar);
- scrollBar->GetEventHandler()->ProcessEvent(event);
+ scrollBar->HandleWindowEvent(event);
}
XtVaGetValues (widget, XmNvalue, &commandInt, NULL);
event.SetInt(commandInt);
event.SetEventObject(slider);
- slider->GetEventHandler()->ProcessEvent(event);
+ slider->HandleWindowEvent(event);
// Also send a wxCommandEvent for compatibility.
wxCommandEvent event2(wxEVT_COMMAND_SLIDER_UPDATED, slider->GetId());
event2.SetEventObject(slider);
event2.SetInt( event.GetInt() );
- slider->GetEventHandler()->ProcessEvent(event2);
+ slider->HandleWindowEvent(event2);
}
#endif // wxUSE_SLIDER
event.SetPosition( npos );
event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
if( event.IsAllowed() )
{
event.SetEventType( wxEVT_SCROLL_THUMBTRACK );
event.SetPosition( m_pos );
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
}
}
// the character passed through)
cbs->doit = False;
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
if ( !InSetValue() && m_processedDefault )
{
wxTextCtrl *tw = (wxTextCtrl *) clientData;
wxFocusEvent event(wxEVT_SET_FOCUS, tw->GetId());
event.SetEventObject(tw);
- tw->GetEventHandler()->ProcessEvent(event);
+ tw->HandleWindowEvent(event);
}
static void
wxTextCtrl *tw = (wxTextCtrl *) clientData;
wxFocusEvent event(wxEVT_KILL_FOCUS, tw->GetId());
event.SetEventObject(tw);
- tw->GetEventHandler()->ProcessEvent(event);
+ tw->HandleWindowEvent(event);
}
static void wxTextWindowActivateProc(Widget w, XtPointer clientData,
closeEvent.SetEventObject( tlw );
// May delete the dialog (with delayed deletion)
- tlw->GetEventHandler()->ProcessEvent(closeEvent);
+ tlw->HandleWindowEvent(closeEvent);
}
void wxTLWEventHandler( Widget wid,
{
wxevent.SetEventObject( tlw );
wxevent.SetId( tlw->GetId() );
- tlw->GetEventHandler()->ProcessEvent( wxevent );
+ tlw->HandleWindowEvent( wxevent );
}
else
{
keyEvent.SetEventObject( tlw );
keyEvent.SetId( tlw->GetId() );
keyEvent.SetEventType( wxEVT_CHAR_HOOK );
- if( tlw->GetEventHandler()->ProcessEvent( keyEvent ) )
+ if( tlw->HandleWindowEvent( keyEvent ) )
{
*continueToDispatch = False;
return;
keyEvent.SetEventType( wxEVT_KEY_DOWN );
// Only process OnChar if OnKeyDown didn't swallow it
- if( !tlw->GetEventHandler()->ProcessEvent( keyEvent ) )
+ if( !tlw->HandleWindowEvent( keyEvent ) )
{
keyEvent.SetEventType( wxEVT_CHAR );
- tlw->GetEventHandler()->ProcessEvent( keyEvent );
+ tlw->HandleWindowEvent( keyEvent );
}
}
}
// Set an erase event first
wxEraseEvent eraseEvent(GetId(), &dc);
eraseEvent.SetEventObject(this);
- GetEventHandler()->ProcessEvent(eraseEvent);
+ HandleWindowEvent(eraseEvent);
wxPaintEvent event(GetId());
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
m_needsRefresh = false;
}
{
wxSysColourChangedEvent event2;
event.SetEventObject(win);
- win->GetEventHandler()->ProcessEvent(event2);
+ win->HandleWindowEvent(event2);
}
node = node->GetNext();
// If ProcessEvent returns true (it was handled), then
// the calling code will skip the event handling.
- return frame->GetEventHandler()->ProcessEvent(commandEvent);
+ return frame->HandleWindowEvent(commandEvent);
}
}
#endif
{
wxCommandEvent commandEvent (wxEVT_COMMAND_BUTTON_CLICKED, child->GetId());
commandEvent.SetEventObject(child);
- return child->GetEventHandler()->ProcessEvent(commandEvent);
+ return child->HandleWindowEvent(commandEvent);
}
return false;
wxSize newSize(win->GetSize());
wxSizeEvent sizeEvent(newSize, win->GetId());
sizeEvent.SetEventObject(win);
- win->GetEventHandler()->ProcessEvent(sizeEvent);
+ win->HandleWindowEvent(sizeEvent);
}
}
wxMouseEvent wxevent(0);
if (wxTranslateMouseEvent(wxevent, canvas, drawingArea, xevent))
{
- canvas->GetEventHandler()->ProcessEvent(wxevent);
+ canvas->HandleWindowEvent(wxevent);
}
break;
}
if (parent)
{
event.SetEventType(wxEVT_CHAR_HOOK);
- if (parent->GetEventHandler()->ProcessEvent(event))
+ if (parent->HandleWindowEvent(event))
return;
}
event.SetEventType(wxEVT_KEY_DOWN);
// Only process OnChar if OnKeyDown didn't swallow it
- if (!canvas->GetEventHandler()->ProcessEvent (event))
+ if (!canvas->HandleWindowEvent (event))
{
event.SetEventType(wxEVT_CHAR);
- canvas->GetEventHandler()->ProcessEvent (event);
+ canvas->HandleWindowEvent (event);
}
}
break;
wxKeyEvent event (wxEVT_KEY_UP);
if (wxTranslateKeyEvent (event, canvas, (Widget) 0, xevent))
{
- canvas->GetEventHandler()->ProcessEvent (event);
+ canvas->HandleWindowEvent (event);
}
break;
}
{
wxFocusEvent event(wxEVT_SET_FOCUS, canvas->GetId());
event.SetEventObject(canvas);
- canvas->GetEventHandler()->ProcessEvent(event);
+ canvas->HandleWindowEvent(event);
}
break;
}
{
wxFocusEvent event(wxEVT_KILL_FOCUS, canvas->GetId());
event.SetEventObject(canvas);
- canvas->GetEventHandler()->ProcessEvent(event);
+ canvas->HandleWindowEvent(event);
}
break;
}
wxMouseEvent wxevent(0);
if (wxTranslateMouseEvent(wxevent, window, wid, event))
{
- window->GetEventHandler()->ProcessEvent(wxevent);
+ window->HandleWindowEvent(wxevent);
}
}
cbs->value,
orientation);
event.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent(event);
+ win->HandleWindowEvent(event);
}
// For repainting arbitrary windows
bool wxControl::ProcessCommand(wxCommandEvent& event)
{
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxControl::MSWOnNotify(int idCtrl,
event.SetEventType(eventType);
event.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
WXHBRUSH wxControl::DoMSWControlColor(WXHDC pDC, wxColour colBg, WXHWND hWnd)
{
m_date = dt;
wxDateEvent event(this, dt, wxEVT_DATE_CHANGED);
- if ( GetEventHandler()->ProcessEvent(event) )
+ if ( HandleWindowEvent(event) )
{
*result = 0;
return true;
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, GetAffirmativeId());
event.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
#endif // __POCKETPC__
{
wxSysColourChangedEvent event2;
event2.SetEventObject( m_frameStatusBar );
- m_frameStatusBar->GetEventHandler()->ProcessEvent(event2);
+ m_frameStatusBar->HandleWindowEvent(event2);
}
#endif // wxUSE_STATUSBAR
wxMenuEvent event(wxEVT_MENU_HIGHLIGHT, item);
event.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxFrame::HandleMenuLoop(const wxEventType& evtType, WXWORD isPopup)
wxMenuEvent event(evtType, isPopup ? -1 : 0);
event.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxFrame::HandleInitMenuPopup(WXHMENU hMenu)
wxMenuEvent event(wxEVT_MENU_OPEN, 0, menu);
event.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
#endif // wxUSE_MENUS
event.SetInt(n);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
// ----------------------------------------------------------------------------
// focus event from here and the selection one
// below
event.SetEventType(eventType);
- (void)GetEventHandler()->ProcessEvent(event);
+ (void)HandleWindowEvent(event);
}
else // no focus event to send
{
event.SetEventType(eventType);
- bool processed = GetEventHandler()->ProcessEvent(event);
+ bool processed = HandleWindowEvent(event);
// post processing
// ---------------
{
wxActivateEvent event(wxEVT_ACTIVATE, true, m_currentChild->GetId());
event.SetEventObject( m_currentChild );
- if ( m_currentChild->GetEventHandler()->ProcessEvent(event) )
+ if ( m_currentChild->HandleWindowEvent(event) )
processed = true;
}
wxSize size(width, height);
wxSizeEvent event(size, m_windowId);
event.SetEventObject( this );
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
// Unlike other wxTopLevelWindowBase, the mdi child's "GetPosition" is not the
ResetWindowStyle((void *)NULL);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxMDIChildFrame::HandleWindowPosChanging(void *pos)
event.SetEventObject(this);
wxWindow *page = m_pages[m_nSelection];
- if ( !page->GetEventHandler()->ProcessEvent(event) )
+ if ( !page->HandleWindowEvent(event) )
{
page->SetFocus();
}
else if ( parent )
{
event.SetCurrentFocus(this);
- parent->GetEventHandler()->ProcessEvent(event);
+ parent->HandleWindowEvent(event);
}
}
}
event.SetEventObject(this);
event.SetInt(idCtrl);
- bool processed = GetEventHandler()->ProcessEvent(event);
+ bool processed = HandleWindowEvent(event);
*result = !event.IsAllowed();
return processed;
}
event.SetPosition(position);
event.SetEventObject( this );
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
void wxScrollBar::SetThumbPosition(int viewStart)
wxScrollEvent event(scrollEvent, m_windowId);
event.SetPosition(newPos);
event.SetEventObject( this );
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
wxCommandEvent cevent( wxEVT_COMMAND_SLIDER_UPDATED, GetId() );
cevent.SetInt( newPos );
cevent.SetEventObject( this );
- return GetEventHandler()->ProcessEvent( cevent );
+ return HandleWindowEvent( cevent );
}
void wxSlider::Command (wxCommandEvent & event)
event.SetPosition((short)pos); // cast is important for negative values!
event.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxSpinButton::MSWOnNotify(int WXUNUSED(idCtrl), WXLPARAM lParam, WXLPARAM *result)
event.SetPosition(lpnmud->iPos + lpnmud->iDelta);
event.SetEventObject(this);
- bool processed = GetEventHandler()->ProcessEvent(event);
+ bool processed = HandleWindowEvent(event);
*result = event.IsAllowed() ? 0 : 1;
wxString val = wxGetWindowText(m_hwndBuddy);
event.SetString(val);
event.SetInt(GetValue());
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
// not processed
wxString val = wxGetWindowText(m_hwndBuddy);
event.SetString(val);
event.SetInt(GetValue());
- if ( GetEventHandler()->ProcessEvent(event) )
+ if ( HandleWindowEvent(event) )
return;
break;
}
eventNav.SetWindowChange(event.ControlDown());
eventNav.SetEventObject(this);
- if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav) )
+ if ( GetParent()->HandleWindowEvent(eventNav) )
return;
}
break;
event.SetEventObject(this);
event.SetInt(value);
- (void)GetEventHandler()->ProcessEvent(event);
+ (void)HandleWindowEvent(event);
m_oldValue = value;
}
{
wxSizeEvent event(GetClientSize(), m_windowId);
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
}
event.SetInt(idCtrl) ;
event.SetSelection(idCtrl);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
// Responds to colour changes, and passes event on to children.
LPNMTOOLBAR tbhdr = (LPNMTOOLBAR)lParam;
wxCommandEvent evt(wxEVT_COMMAND_TOOL_DROPDOWN_CLICKED, tbhdr->iItem);
- if ( GetEventHandler()->ProcessEvent(evt) )
+ if ( HandleWindowEvent(evt) )
{
// Event got handled, don't display default popup menu
return false;
wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
InitCommandEvent(event);
event.SetString(GetValue());
- if ( GetEventHandler()->ProcessEvent(event) )
+ if ( HandleWindowEvent(event) )
if ( !HasFlag(wxTE_MULTILINE) )
return;
//else: multiline controls need Enter for themselves
: wxEVT_SET_FOCUS,
m_windowId);
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
break;
// finally send an event allowing the window to relayout itself &c
wxSizeEvent event(rect.GetSize(), GetId());
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
}
else // stop showing full screen
{
: IDX_COLLAPSE]
[IDX_DONE],
this, item);
- (void)GetEventHandler()->ProcessEvent(event);
+ (void)HandleWindowEvent(event);
}
//else: change didn't took place, so do nothing at all
}
_T("SelectItem(false) works only for multiselect") );
wxTreeEvent event(wxEVT_COMMAND_TREE_SEL_CHANGING, this, item);
- if ( !GetEventHandler()->ProcessEvent(event) || event.IsAllowed() )
+ if ( !HandleWindowEvent(event) || event.IsAllowed() )
{
if ( HasFlag(wxTR_MULTIPLE) )
{
}
event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
- (void)GetEventHandler()->ProcessEvent(event);
+ (void)HandleWindowEvent(event);
}
//else: program vetoed the change
}
event.m_pointDrag = pt;
- if ( GetEventHandler()->ProcessEvent(event) )
+ if ( HandleWindowEvent(event) )
processed = true;
//else: continue with generating wxEVT_CONTEXT_MENU in base class code
}
wxTreeEvent event(wxEVT_COMMAND_TREE_END_DRAG, this, htItem);
event.m_pointDrag = wxPoint(x, y);
- (void)GetEventHandler()->ProcessEvent(event);
+ (void)HandleWindowEvent(event);
// if we don't do it, the tree seems to think that 2 items
// are selected simultaneously which is quite weird
wxTreeEvent event2(wxEVT_COMMAND_TREE_ITEM_ACTIVATED,
this, item);
- (void)GetEventHandler()->ProcessEvent(event2);
+ (void)HandleWindowEvent(event2);
}
}
break;
if ( event.m_item.IsOk() )
event.SetClientObject(GetItemData(event.m_item));
- bool processed = GetEventHandler()->ProcessEvent(event);
+ bool processed = HandleWindowEvent(event);
// post processing
switch ( hdr->code )
// we're officially created now, send the event
wxWindowCreateEvent event((wxWindow *)this);
- (void)GetEventHandler()->ProcessEvent(event);
+ (void)HandleWindowEvent(event);
}
void wxWindowMSW::UnsubclassWin()
// map Enter presses into button presses on PDAs
wxJoystickEvent event(wxEVT_JOY_BUTTON_DOWN);
event.SetEventObject(this);
- if ( GetEventHandler()->ProcessEvent(event) )
+ if ( HandleWindowEvent(event) )
return true;
#endif // __WXWINCE__
}
event.SetFromTab(bFromTab);
event.SetEventObject(this);
- if ( GetEventHandler()->ProcessEvent(event) )
+ if ( HandleWindowEvent(event) )
{
// as we don't call IsDialogMessage(), which would take of
// this by default, we need to manually send this message
wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU, GetId(), pt);
evtCtx.SetEventObject(this);
- if (GetEventHandler()->ProcessEvent(evtCtx))
+ if (HandleWindowEvent(evtCtx))
{
processed = true;
return true;
);
helpEvent.SetEventObject(this);
- GetEventHandler()->ProcessEvent(helpEvent);
+ HandleWindowEvent(helpEvent);
#ifndef __WXWINCE__
}
else if ( info->iContextType == HELPINFO_MENUITEM )
{
wxHelpEvent helpEvent(wxEVT_HELP, info->iCtrlId);
helpEvent.SetEventObject(this);
- GetEventHandler()->ProcessEvent(helpEvent);
+ HandleWindowEvent(helpEvent);
}
else // unknown help event?
win = this;
evtCtx.SetEventObject(win);
- processed = win->GetEventHandler()->ProcessEvent(evtCtx);
+ processed = win->HandleWindowEvent(evtCtx);
}
break;
#endif
m_windowId);
event.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowMSW::HandleSetFocus(WXHWND hwnd)
// notify the parent keeping track of focus for the kbd navigation
// purposes that we got it
wxChildFocusEvent eventFocus((wxWindow *)this);
- (void)GetEventHandler()->ProcessEvent(eventFocus);
+ (void)HandleWindowEvent(eventFocus);
#if wxUSE_CARET
// Deal with caret
// wxFindWinFromHandle() may return NULL, it is ok
event.SetWindow(wxFindWinFromHandle(hwnd));
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowMSW::HandleKillFocus(WXHWND hwnd)
// wxFindWinFromHandle() may return NULL, it is ok
event.SetWindow(wxFindWinFromHandle(hwnd));
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
// ---------------------------------------------------------------------------
wxShowEvent event(GetId(), show);
event.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowMSW::HandleInitDialog(WXHWND WXUNUSED(hWndFocus))
wxInitDialogEvent event(GetId());
event.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam)
event.m_pos.x = dropPoint.x;
event.m_pos.y = dropPoint.y;
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
#endif
}
ScreenToClient(&x, &y);
wxSetCursorEvent event(x, y);
- bool processedEvtSetCursor = GetEventHandler()->ProcessEvent(event);
+ bool processedEvtSetCursor = HandleWindowEvent(event);
if ( processedEvtSetCursor && event.HasCursor() )
{
hcursor = GetHcursorOf(event.GetCursor());
// TODO: notify about PBTF_APMRESUMEFROMFAILURE in case of resume events?
wxPowerEvent event(evtType);
- if ( !GetEventHandler()->ProcessEvent(event) )
+ if ( !HandleWindowEvent(event) )
return false;
*vetoed = event.IsVetoed();
wxSysColourChangedEvent event;
event.SetEventObject(this);
- (void)GetEventHandler()->ProcessEvent(event);
+ (void)HandleWindowEvent(event);
// always let the system carry on the default processing to allow the
// native controls to react to the colours update
wxDisplayChangedEvent event;
event.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
#ifndef __WXMICROWIN__
event.SetEventObject(this);
event.SetChangedWindow(wxFindWinFromHandle(hWndPalChange));
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture)
wxWindow *win = wxFindWinFromHandle(hWndGainedCapture);
wxMouseCaptureChangedEvent event(GetId(), win);
event.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowMSW::HandleSettingChange(WXWPARAM wParam, WXLPARAM lParam)
wxQueryNewPaletteEvent event(GetId());
event.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(event) && event.GetPaletteRealized();
+ return HandleWindowEvent(event) && event.GetPaletteRealized();
}
// Responds to colour changes: passes event on to children.
wxPaintEvent event(m_windowId);
event.SetEventObject(this);
- bool processed = GetEventHandler()->ProcessEvent(event);
+ bool processed = HandleWindowEvent(event);
// note that we must generate NC event after the normal one as otherwise
// BeginPaint() will happily overwrite our decorations with the background
// colour
wxNcPaintEvent eventNc(m_windowId);
eventNc.SetEventObject(this);
- GetEventHandler()->ProcessEvent(eventNc);
+ HandleWindowEvent(eventNc);
// don't keep an HRGN we don't need any longer (GetUpdateRegion() can only
// be called from inside the event handlers called above)
wxEraseEvent event(m_windowId, &dc);
event.SetEventObject(this);
- bool rc = GetEventHandler()->ProcessEvent(event);
+ bool rc = HandleWindowEvent(event);
// must be called manually as ~wxDC doesn't do anything for wxDCTemp
dc.SelectOldObjects(hdc);
wxIconizeEvent event(m_windowId);
event.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowMSW::HandleMaximize()
wxMaximizeEvent event(m_windowId);
event.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowMSW::HandleMove(int x, int y)
wxMoveEvent event(point, m_windowId);
event.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowMSW::HandleMoving(wxRect& rect)
wxMoveEvent event(rect, m_windowId);
event.SetEventObject(this);
- bool rc = GetEventHandler()->ProcessEvent(event);
+ bool rc = HandleWindowEvent(event);
if (rc)
rect = event.GetRect();
return rc;
event.SetEventType(wxEVT_MOVE_START);
event.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowMSW::HandleExitSizeMove()
event.SetEventType(wxEVT_MOVE_END);
event.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowMSW::HandleSize(int WXUNUSED(w), int WXUNUSED(h), WXUINT wParam)
wxSizeEvent event(GetSize(), m_windowId);
event.SetEventObject(this);
- processed = GetEventHandler()->ProcessEvent(event);
+ processed = HandleWindowEvent(event);
}
#if USE_DEFERRED_SIZING
wxSizeEvent event(rect, m_windowId);
event.SetEventObject(this);
- bool rc = GetEventHandler()->ProcessEvent(event);
+ bool rc = HandleWindowEvent(event);
if (rc)
rect = event.GetRect();
return rc;
event.SetId(id);
event.SetInt(id);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
else
{
wxMouseEvent event(eventsMouse[msg - WM_MOUSEMOVE]);
InitMouseEvent(event, x, y, flags);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowMSW::HandleMouseMove(int x, int y, WXUINT flags)
wxMouseEvent event(wxEVT_ENTER_WINDOW);
InitMouseEvent(event, x, y, flags);
- (void)GetEventHandler()->ProcessEvent(event);
+ (void)HandleWindowEvent(event);
}
}
#ifdef HAVE_TRACKMOUSEEVENT
}
event.m_linesPerAction = s_linesPerRotation;
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
#else // !wxUSE_MOUSEWHEEL
wxUnusedVar(wParam);
wxMouseEvent event(wxEVT_LEAVE_WINDOW);
InitMouseEvent(event, pt.x, pt.y, state);
- (void)GetEventHandler()->ProcessEvent(event);
+ (void)HandleWindowEvent(event);
}
// ---------------------------------------------------------------------------
event.m_altDown = false;
}
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam)
}
wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_DOWN, id, lParam, wParam));
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
}
wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_UP, id, lParam, wParam));
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
#if wxUSE_MENUS
evt.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(evt);
+ return HandleWindowEvent(evt);
}
#endif // wxUSE_MENUS
event.SetPosition(wxPoint(x, y));
event.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
#else
wxUnusedVar(msg);
wxUnusedVar(x);
return false;
}
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
// ----------------------------------------------------------------------------
event.m_altDown = (win_modifiers & MOD_ALT) != 0;
event.m_metaDown = (win_modifiers & MOD_WIN) != 0;
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
#endif // wxUSE_ACCEL
bool wxControl::ProcessCommand(wxCommandEvent& event)
{
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
WXHBRUSH wxControl::OnCtlColor(WXHDC hWxDC,
wxSysColourChangedEvent vEvent2;
vEvent2.SetEventObject(m_frameStatusBar);
- m_frameStatusBar->GetEventHandler()->ProcessEvent(vEvent2);
+ m_frameStatusBar->HandleWindowEvent(vEvent2);
}
#endif //wxUSE_STATUSBAR
wxSize sz( nWidth, nHeight );
wxSizeEvent vEvent( sz, GetId() );
- GetEventHandler()->ProcessEvent(vEvent);
+ HandleWindowEvent(vEvent);
return true;
}
else
wxMenuEvent vEvent(wxEVT_MENU_HIGHLIGHT, nItem);
vEvent.SetEventObject(this);
- GetEventHandler()->ProcessEvent(vEvent); // return value would be ignored by PM
+ HandleWindowEvent(vEvent); // return value would be ignored by PM
}
else
{
n = -1;
}
vEvent.SetInt(n);
- return GetEventHandler()->ProcessEvent(vEvent);
+ return HandleWindowEvent(vEvent);
} // end of wxListBox::OS2Command
// ----------------------------------------------------------------------------
//
}
vEvent.SetEventType(vEventType);
- bProcessed = GetEventHandler()->ProcessEvent(vEvent);
+ bProcessed = HandleWindowEvent(vEvent);
break;
}
if (!bProcessed)
vEvent.SetSelection(nPage);
vEvent.SetOldSelection(m_nSelection);
vEvent.SetEventObject(this);
- if (!GetEventHandler()->ProcessEvent(vEvent) || vEvent.IsAllowed())
+ if (!HandleWindowEvent(vEvent) || vEvent.IsAllowed())
{
//
// Program allows the page change
//
vEvent.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED);
- GetEventHandler()->ProcessEvent(vEvent);
+ HandleWindowEvent(vEvent);
::WinSendMsg( GetHWND()
,BKM_TURNTOPAGE
wxWindow* pPage = m_pages[m_nSelection];
- if (!pPage->GetEventHandler()->ProcessEvent(rEvent))
+ if (!pPage->HandleWindowEvent(rEvent))
{
pPage->SetFocus();
}
if (pParent)
{
rEvent.SetCurrentFocus(this);
- pParent->GetEventHandler()->ProcessEvent(rEvent);
+ pParent->HandleWindowEvent(rEvent);
}
}
}
vEvent.SetOrientation(IsVertical() ? wxVERTICAL : wxHORIZONTAL);
vEvent.SetPosition(nPosition);
vEvent.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(vEvent);
+ return HandleWindowEvent(vEvent);
} // end of wxScrollBar::OS2OnScroll
void wxScrollBar::SetThumbPosition ( int nViewStart )
vEvent.SetPosition(nNewPos);
vEvent.SetEventObject(this);
- GetEventHandler()->ProcessEvent(vEvent);
+ HandleWindowEvent(vEvent);
wxCommandEvent vCevent( wxEVT_COMMAND_SLIDER_UPDATED, GetId() );
vCevent.SetInt(nNewPos);
vCevent.SetEventObject(this);
- return (GetEventHandler()->ProcessEvent(vCevent));
+ return (HandleWindowEvent(vCevent));
} // end of wxSlider::OS2OnScroll
void wxSlider::SetLineSize( int nLineSize )
vEvent.SetPosition(nVal);
vEvent.SetEventObject(this);
- return(GetEventHandler()->ProcessEvent(vEvent));
+ return(HandleWindowEvent(vEvent));
} // end of wxSpinButton::OS2OnScroll
bool wxSpinButton::OS2Command( WXUINT WXUNUSED(uCmd),
InitCommandEvent(vEvent);
vEvent.SetString(sVal);
vEvent.SetInt(GetValue());
- if (GetEventHandler()->ProcessEvent(vEvent))
+ if (HandleWindowEvent(vEvent))
return;
break;
}
vEventNav.SetDirection(!rEvent.ShiftDown());
vEventNav.SetWindowChange(rEvent.ControlDown());
vEventNav.SetEventObject(this);
- if (GetParent()->GetEventHandler()->ProcessEvent(vEventNav))
+ if (GetParent()->HandleWindowEvent(vEventNav))
return;
}
break;
vEvent.SetEventObject(this);
vEvent.SetInt(rEventSpin.GetPosition());
- (void)GetEventHandler()->ProcessEvent(vEvent);
+ (void)HandleWindowEvent(vEvent);
if (rEventSpin.GetSkipped())
{
vEvent.Skip();
vEvent.SetString(sVal);
vEvent.SetInt(GetValue());
- return (GetEventHandler()->ProcessEvent(vEvent));
+ return (HandleWindowEvent(vEvent));
}
case SPBN_SETFOCUS:
);
vEvent.SetEventObject(this);
- return(GetEventHandler()->ProcessEvent(vEvent));
+ return(HandleWindowEvent(vEvent));
}
default:
break;
wxCommandEvent vEvent(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
vEvent.SetEventObject(this);
- if ( GetEventHandler()->ProcessEvent(vEvent))
+ if ( HandleWindowEvent(vEvent))
return;
}
//else: multiline controls need Enter for themselves
vEventNav.SetWindowChange(false);
vEventNav.SetEventObject(this);
- if ( GetEventHandler()->ProcessEvent(vEventNav) )
+ if ( HandleWindowEvent(vEventNav) )
return;
}
break;
);
vEvent.SetEventObject(this);
- GetEventHandler()->ProcessEvent(vEvent);
+ HandleWindowEvent(vEvent);
}
break;
::WinEnableWindow(m_hFrame, TRUE);
vEvent.SetEventObject(this);
- GetEventHandler()->ProcessEvent(vEvent);
+ HandleWindowEvent(vEvent);
}
else
{
wxSize full( nWidth, nHeight );
wxSizeEvent vEvent( full, GetId() );
- GetEventHandler()->ProcessEvent(vEvent);
+ HandleWindowEvent(vEvent);
return true;
}
else
delete (wxTreeItemAttr *)m_vAttrs.Delete((long)rItem.m_pItem);
}
vEvent.SetEventType(vEventType);
- GetEventHandler()->ProcessEvent(vEvent);
+ HandleWindowEvent(vEvent);
} // end of wxTreeCtrl::Delete
// delete all children (but don't delete the item itself)
break;
}
vEvent.SetEventType(vEventType);
- bProcessed = GetEventHandler()->ProcessEvent(vEvent);
+ bProcessed = HandleWindowEvent(vEvent);
break;
}
if (!bProcessed)
,vPoint.y
,nState
);
- (void)GetEventHandler()->ProcessEvent(rEvent);
+ (void)HandleWindowEvent(rEvent);
}
}
if (wxUpdateUIEvent::CanUpdate(this))
wxSize size( nWidth, nHeight );
wxSizeEvent vEvent( size, m_windowId );
vEvent.SetEventObject(this);
- GetEventHandler()->ProcessEvent(vEvent);
+ HandleWindowEvent(vEvent);
} // end of wxWindowOS2::DoSetClientSize
// ---------------------------------------------------------------------------
vEvent.SetWindowChange(bWindowChange);
vEvent.SetEventObject(this);
- if (GetEventHandler()->ProcessEvent(vEvent))
+ if (HandleWindowEvent(vEvent))
{
wxButton* pBtn = wxDynamicCast(FindFocus(), wxButton);
{
wxWindowCreateEvent vEvent((wxWindow*)this);
- (void)GetEventHandler()->ProcessEvent(vEvent);
+ (void)HandleWindowEvent(vEvent);
*pbMayCreate = true;
return true;
} // end of wxWindowOS2::HandleCreate
{
wxWindowDestroyEvent vEvent((wxWindow*)this);
vEvent.SetId(GetId());
- (void)GetEventHandler()->ProcessEvent(vEvent);
+ (void)HandleWindowEvent(vEvent);
//
// Delete our drop target if we've got one
,m_windowId
);
vEvent.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(vEvent);
+ return HandleWindowEvent(vEvent);
} // end of wxWindowOS2::HandleActivate
bool wxWindowOS2::HandleSetFocus( WXHWND WXUNUSED(hWnd) )
// purposes that we got it
//
wxChildFocusEvent vEventFocus((wxWindow *)this);
- (void)GetEventHandler()->ProcessEvent(vEventFocus);
+ (void)HandleWindowEvent(vEventFocus);
#if wxUSE_CARET
//
wxFocusEvent vEvent(wxEVT_SET_FOCUS, m_windowId);
vEvent.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(vEvent);
+ return HandleWindowEvent(vEvent);
} // end of wxWindowOS2::HandleSetFocus
bool wxWindowOS2::HandleKillFocus( WXHWND hWnd )
// wxFindWinFromHandle() may return NULL, it is ok
//
vEvent.SetWindow(wxFindWinFromHandle(hWnd));
- return GetEventHandler()->ProcessEvent(vEvent);
+ return HandleWindowEvent(vEvent);
} // end of wxWindowOS2::HandleKillFocus
// ---------------------------------------------------------------------------
wxShowEvent vEvent(GetId(), bShow);
vEvent.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(vEvent);
+ return HandleWindowEvent(vEvent);
} // end of wxWindowOS2::HandleShow
bool wxWindowOS2::HandleInitDialog( WXHWND WXUNUSED(hWndFocus) )
wxInitDialogEvent vEvent(GetId());
vEvent.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(vEvent);
+ return HandleWindowEvent(vEvent);
} // end of wxWindowOS2::HandleInitDialog
bool wxWindowOS2::HandleEndDrag(WXWPARAM WXUNUSED(wParam))
wxSysColourChangedEvent vEvent;
vEvent.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(vEvent);
+ return HandleWindowEvent(vEvent);
} // end of wxWindowOS2::HandleSysColorChange
bool wxWindowOS2::HandleCtlColor( WXHBRUSH* WXUNUSED(phBrush) )
vEvent.SetEventObject(this);
vEvent.SetChangedWindow(wxFindWinFromHandle(hWndPalChange));
- return GetEventHandler()->ProcessEvent(vEvent);
+ return HandleWindowEvent(vEvent);
} // end of wxWindowOS2::HandlePaletteChanged
//
wxSysColourChangedEvent vEvent;
rEvent.SetEventObject(pWin);
- pWin->GetEventHandler()->ProcessEvent(vEvent);
+ pWin->HandleWindowEvent(vEvent);
}
node = node->GetNext();
}
m_updateRegion = wxRegion(hRgn, hPS);
vEvent.SetEventObject(this);
- bProcessed = GetEventHandler()->ProcessEvent(vEvent);
+ bProcessed = HandleWindowEvent(vEvent);
if (!bProcessed &&
IsKindOf(CLASSINFO(wxPanel)) &&
vEvent.SetEventObject(this);
- rc = GetEventHandler()->ProcessEvent(vEvent);
+ rc = HandleWindowEvent(vEvent);
vDC.m_hPS = NULLHANDLE;
return true;
wxIconizeEvent vEvent(m_windowId);
vEvent.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(vEvent);
+ return HandleWindowEvent(vEvent);
} // end of wxWindowOS2::HandleMinimize
bool wxWindowOS2::HandleMaximize()
wxMaximizeEvent vEvent(m_windowId);
vEvent.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(vEvent);
+ return HandleWindowEvent(vEvent);
} // end of wxWindowOS2::HandleMaximize
bool wxWindowOS2::HandleMove( int nX, int nY )
wxMoveEvent vEvent(pt, m_windowId);
vEvent.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(vEvent);
+ return HandleWindowEvent(vEvent);
} // end of wxWindowOS2::HandleMove
bool wxWindowOS2::HandleSize( int nWidth,
wxSizeEvent vEvent(sz, m_windowId);
vEvent.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(vEvent);
+ return HandleWindowEvent(vEvent);
} // end of wxWindowOS2::HandleSize
bool wxWindowOS2::HandleGetMinMaxInfo( PSWP pSwp )
,uFlags
);
- bProcessed = GetEventHandler()->ProcessEvent(vEvent);
+ bProcessed = HandleWindowEvent(vEvent);
if (!bProcessed)
{
HPOINTER hCursor = (HPOINTER)GetCursor().GetHCURSOR();
,uFlags
);
- (void)GetEventHandler()->ProcessEvent(vEvent);
+ (void)HandleWindowEvent(vEvent);
}
return HandleMouseEvent( WM_MOUSEMOVE
,nX
vEvent.m_controlDown = true;
}
- return (GetEventHandler()->ProcessEvent(vEvent));
+ return (HandleWindowEvent(vEvent));
}
bool wxWindowOS2::HandleKeyDown( WXWPARAM wParam,
,(MPARAM)wParam
));
- if (GetEventHandler()->ProcessEvent(vEvent))
+ if (HandleWindowEvent(vEvent))
{
return true;
}
,(MPARAM)wParam
));
- if (GetEventHandler()->ProcessEvent(vEvent))
+ if (HandleWindowEvent(vEvent))
return true;
}
return false;
default:
return false;
}
- return GetEventHandler()->ProcessEvent(vEvent);
+ return HandleWindowEvent(vEvent);
} // end of wxWindowOS2::OS2OnScroll
//
bool wxControl::ProcessCommand(wxCommandEvent& event)
{
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
void wxControl::OnEraseBackground(wxEraseEvent& event)
wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, item);
commandEvent.SetEventObject(this);
- GetEventHandler()->ProcessEvent(commandEvent);
+ HandleWindowEvent(commandEvent);
return true;
}
wxScrollEvent eventWxTrack(wxEVT_SCROLL_THUMBRELEASE, GetId());
eventWxTrack.SetPosition(m_oldPos);
eventWxTrack.SetEventObject(this);
- bool handled = GetEventHandler()->ProcessEvent(eventWxTrack);
+ bool handled = HandleWindowEvent(eventWxTrack);
// then slider event if position changed
if( m_oldValue != m_oldPos )
wxScrollEvent eventWx(wxEVT_SCROLL_THUMBTRACK, GetId());
eventWx.SetPosition(newPos);
eventWx.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(eventWx);
+ return HandleWindowEvent(eventWx);
}
void wxSlider::Command (wxCommandEvent & event)
wxPaintEvent event(m_windowId);
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
return true;
}
palmEvent->data.winResized.newBounds.extent.y);
wxSizeEvent eventWx(newSize,GetId());
eventWx.SetEventObject(this);
- return GetEventHandler()->ProcessEvent(eventWx);
+ return HandleWindowEvent(eventWx);
}
void wxTopLevelWindowPalm::OnActivate(wxActivateEvent& event)
// wxLogDebug( "OnKey from %s", win->GetName().c_str() );
// We didn't process wxEVT_KEY_DOWN, so send wxEVT_CHAR
- if (win->GetEventHandler()->ProcessEvent( keyEvent ))
+ if (win->HandleWindowEvent( keyEvent ))
return true;
keyEvent.SetEventType(wxEVT_CHAR);
// Do the translation again, retaining the ASCII
// code.
if (wxTranslateKeyEvent(keyEvent, win, window, event, true) &&
- win->GetEventHandler()->ProcessEvent( keyEvent ))
+ win->HandleWindowEvent( keyEvent ))
return true;
if ( (keyEvent.m_keyCode == WXK_TAB) &&
/* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
new_event.SetWindowChange( keyEvent.ControlDown() );
new_event.SetCurrentFocus( win );
- return win->GetParent()->GetEventHandler()->ProcessEvent( new_event );
+ return win->GetParent()->HandleWindowEvent( new_event );
}
return false;
wxKeyEvent keyEvent(wxEVT_KEY_UP);
wxTranslateKeyEvent(keyEvent, win, window, event);
- return win->GetEventHandler()->ProcessEvent( keyEvent );
+ return win->HandleWindowEvent( keyEvent );
}
case ConfigureNotify:
{
wxSizeEvent sizeEvent( wxSize(XConfigureEventGetWidth(event), XConfigureEventGetHeight(event)), win->GetId() );
sizeEvent.SetEventObject( win );
- return win->GetEventHandler()->ProcessEvent( sizeEvent );
+ return win->HandleWindowEvent( sizeEvent );
}
}
return false;
wxSizeEvent sizeEvent(sz, win->GetId());
sizeEvent.SetEventObject(win);
- return win->GetEventHandler()->ProcessEvent( sizeEvent );
+ return win->HandleWindowEvent( sizeEvent );
}
#endif
#endif
#endif
wxMouseEvent wxevent;
wxTranslateMouseEvent(wxevent, win, window, event);
- return win->GetEventHandler()->ProcessEvent( wxevent );
+ return win->HandleWindowEvent( wxevent );
}
case FocusIn:
#if !wxUSE_NANOX
focusEvent.SetWindow( g_prevFocus );
g_prevFocus = NULL;
- return win->GetEventHandler()->ProcessEvent(focusEvent);
+ return win->HandleWindowEvent(focusEvent);
}
}
return false;
focusEvent.SetEventObject(win);
focusEvent.SetWindow( g_nextFocus );
g_nextFocus = NULL;
- return win->GetEventHandler()->ProcessEvent(focusEvent);
+ return win->HandleWindowEvent(focusEvent);
}
return false;
wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
event.SetEventObject(this);
event.SetString(GetValue());
- if (GetEventHandler()->ProcessEvent(event)) return;
+ if (HandleWindowEvent(event)) return;
}
if (IsSingleLine())
{
wxSizeEvent event( GetClientSize(), GetId() );
event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( event );
+ HandleWindowEvent( event );
m_needResizeInIdle = false;
}
wxSizeEvent event(GetSize(), GetId());
event.SetEventObject(this);
- GetEventHandler()->ProcessEvent(event);
+ HandleWindowEvent(event);
m_needResizeInIdle = false;
}
wxEraseEvent erase_event( GetId(), &dc );
erase_event.SetEventObject( this );
- if (!GetEventHandler()->ProcessEvent(erase_event) )
+ if (!HandleWindowEvent(erase_event) )
{
Display *xdisplay = wxGlobalDisplay();
Window xwindow = (Window) GetClientAreaWindow();
wxPaintEvent paint_event( GetId() );
paint_event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( paint_event );
+ HandleWindowEvent( paint_event );
m_updateRegion.Clear();
wxNcPaintEvent nc_paint_event( GetId() );
nc_paint_event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( nc_paint_event );
+ HandleWindowEvent( nc_paint_event );
m_updateNcArea = false;
}
{
wxSysColourChangedEvent event2;
event.SetEventObject(win);
- win->GetEventHandler()->ProcessEvent(event2);
+ win->HandleWindowEvent(event2);
}
node = node->GetNext();
projects / wxWidgets.git / commitdiff
