\wxheading{Event handling}
To respond to a menu selection, provide a handler for EVT\_MENU, in the frame
-that contains the menu bar.
+that contains the menu bar. If you have a toolbar which uses the same identifiers
+as your EVT\_MENU entries, events from the toolbar will also be processed by your
+EVT\_MENU event handlers.
+
+Note that menu commands (and UI update events for menus) are first sent to
+the focus window within the frame. If no window within the frame has the focus,
+then the events are sent directly to the frame. This allows command and UI update
+handling to be processed by specific windows and controls, and not necessarily
+by the application frame.
\wxheading{See also}
Note that your application may wish to override ProcessEvent to redirect processing of
events. This is done in the document/view framework, for example, to allow event handlers
-to be defined in the document or view.
+to be defined in the document or view. To test for command events (which will probably
+be the only events you wish to redirect), you may use wxEvent::IsCommandEvent for
+efficiency, instead of using the slower run-time type system.
As mentioned above, only command events are recursively applied to the parents event
handler. As this quite often causes confusion for users, here is a list of system
of system events in a parent window, for example all key events sent to, but not
used by, the native controls in a dialog. In this case, a special event handler
will have to be written that will override ProcessEvent() in order to pass
-all events (or any selection of them) to the parent window. See next section.
+all events (or any selection of them) to the parent window.
+
+\subsection{Redirection of command events to the window with the focus}
+
+The usual upward search through the window hierarchy for command event
+handlers does not always meet an application's requirements. Say you have two
+wxTextCtrl windows in a frame, plus a toolbar with Cut, Copy and Paste
+buttons. To avoid the need to define event handlers in the frame
+and redirect them explicitly to the window with the focus, command events
+are sent to the window with the focus first, for
+menu and toolbar command and UI update events only. This means that
+each window can handle its own commands and UI updates independently. In
+fact wxTextCtrl can handle Cut, Copy, Paste, Undo and Redo commands and UI update
+requests, so no extra coding is required to support them in your menus and
+toolbars.
\subsection{Pluggable event handlers}
\wxheading{Event handling}
+The following commands are processed by default event handlers in wxTextCtrl: wxID\_CUT, wxID\_COPY,
+wxID\_PASTE, wxID\_UNDO, wxID\_REDO. The associated UI update events are also processed
+automatically, when the control has the focus.
+
To process input from a text control, use these event handler macros to direct input to member
functions that take a \helpref{wxCommandEvent}{wxcommandevent} argument.
This is because the id may be -1 when the mouse moves off a tool, and -1 is not
allowed as an identifier in the event system.
+Note that tool commands (and UI update events for tools) are first sent to
+the focus window within the frame that contains the toolbar. If no window within the frame has the focus,
+then the events are sent directly to the toolbar (and up the hierarchy to the
+frame, depending on where the application has put its event handlers). This allows command and UI update
+handling to be processed by specific windows and controls, and not necessarily
+by the application frame.
+
\twocolwidtha{7cm}
\begin{twocollist}\itemsep=0pt
\twocolitem{{\bf EVT\_TOOL(id, func)}}{Process a wxEVT\_COMMAND\_TOOL\_CLICKED event
of different implementations depending on platform, wxWindows separates
out the classes. This is because there are a number of different toolbar
styles that you may wish to use simultaneously, and also, future
-toolbar implementations will emerge (for example, using the
-new-style Windows `coolbar' as seen in Microsoft applications) which
+toolbar implementations will emerge which
cannot all be shoe-horned into the one class.
For each platform, the symbol {\bf wxToolBar} is defined to be one of the
\item {\bf wxToolBarBase.} This is a base class with pure virtual functions,
and should not be used directly.
\item {\bf wxToolBarSimple.} A simple toolbar class written entirely with generic wxWindows
-functionality. A simply 3D effect for buttons is possible, but it is not consistent
+functionality. A simple 3D effect for buttons is possible, but it is not consistent
with the Windows look and feel. This toolbar can scroll, and you can have arbitrary
numbers of rows and columns.
\item {\bf wxToolBarMSW.} This class implements an old-style Windows toolbar, only on
No absolute positioning is supported but you can specify the number
of rows, and add tool separators with {\bf AddSeparator}.
Tooltips are supported. {\bf OnRightClick} is not supported. This is the default wxToolBar
-on Windows 95, Windows NT 4 and above.
+on Windows 95, Windows NT 4 and above. With the style wxTB\_FLAT, the flat toolbar
+look is used, with a border that is highlit when the cursor moves over the buttons.
\end{itemize}
A toolbar might appear as a single row of images under
one bitmap for each tool, because the toolbar generates all three images (normal,
depressed and checked) from the single bitmap you give it.
-To intercept
-
\subsection{Using the toolbar library}
Include {\tt "wx/toolbar.h"}, or if using a class directly, one of:
\end{itemize}
Example of toolbar use are given in the sample program ``toolbar''. The
-source is given below.
+source is given below. In fact it's out of date because recommended
+practise is to use event handlers (using EVT\_MENU or EVT\_TOOL) instead of
+overriding OnLeftClick.
{\small
\begin{verbatim}
#define EVT_UPDATE_UI(id, func) \
{ wxEVT_UPDATE_UI, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxUpdateUIEventFunction) & func, (wxObject *) NULL },\
+/*
+ * Helper functions
+ */
+
+// Find a window with the focus, that is also a descendant of the given window.
+// This is used to determine the window to initially send commands to.
+wxWindow* wxFindFocusDescendant(wxWindow* ancestor);
+
#endif
// _WX_EVENTH__
virtual void GtkOnSize( int x, int y, int width, int height );
virtual wxPoint GetClientAreaOrigin() const;
void DoMenuUpdates();
- void DoMenuUpdates(wxMenu* menu);
+ void DoMenuUpdates(wxMenu* menu, wxWindow* focusWin);
virtual void OnInternalIdle();
wxMenuBar *m_frameMenuBar;
void OnChar( wxKeyEvent &event );
+ void OnCut(wxCommandEvent& event);
+ void OnCopy(wxCommandEvent& event);
+ void OnPaste(wxCommandEvent& event);
+ void OnUndo(wxCommandEvent& event);
+ void OnRedo(wxCommandEvent& event);
+
+ void OnUpdateCut(wxUpdateUIEvent& event);
+ void OnUpdateCopy(wxUpdateUIEvent& event);
+ void OnUpdatePaste(wxUpdateUIEvent& event);
+ void OnUpdateUndo(wxUpdateUIEvent& event);
+ void OnUpdateRedo(wxUpdateUIEvent& event);
+
#ifndef NO_TEXT_WINDOW_STREAM
int overflow(int i);
int sync();
virtual void GtkOnSize( int x, int y, int width, int height );
virtual wxPoint GetClientAreaOrigin() const;
void DoMenuUpdates();
- void DoMenuUpdates(wxMenu* menu);
+ void DoMenuUpdates(wxMenu* menu, wxWindow* focusWin);
virtual void OnInternalIdle();
wxMenuBar *m_frameMenuBar;
void OnChar( wxKeyEvent &event );
+ void OnCut(wxCommandEvent& event);
+ void OnCopy(wxCommandEvent& event);
+ void OnPaste(wxCommandEvent& event);
+ void OnUndo(wxCommandEvent& event);
+ void OnRedo(wxCommandEvent& event);
+
+ void OnUpdateCut(wxUpdateUIEvent& event);
+ void OnUpdateCopy(wxUpdateUIEvent& event);
+ void OnUpdatePaste(wxUpdateUIEvent& event);
+ void OnUpdateUndo(wxUpdateUIEvent& event);
+ void OnUpdateRedo(wxUpdateUIEvent& event);
+
#ifndef NO_TEXT_WINDOW_STREAM
int overflow(int i);
int sync();
// Query app for menu item updates (called from OnIdle)
void DoMenuUpdates();
- void DoMenuUpdates(wxMenu* menu);
+ void DoMenuUpdates(wxMenu* menu, wxWindow* focusWin);
// Checks if there is a toolbar, and returns the first free client position
virtual wxPoint GetClientAreaOrigin() const;
// Query app for menu item updates (called from OnIdle)
void DoMenuUpdates();
- void DoMenuUpdates(wxMenu* menu);
+ void DoMenuUpdates(wxMenu* menu, wxWindow* focusWin);
// Checks if there is a toolbar, and returns the first free client position
virtual wxPoint GetClientAreaOrigin() const;
#pragma interface "textctrl.h"
#endif
-#include "wx/ioswrap.h"
#include "wx/control.h"
+#include "wx/ioswrap.h"
// TODO Some platforms/compilers don't like inheritance from streambuf.
#if (defined(__BORLANDC__) && !defined(__WIN32__)) || defined(__MWERKS__)
void OnChar(wxKeyEvent& event);
// void OnEraseBackground(wxEraseEvent& event);
+ void OnCut(wxCommandEvent& event);
+ void OnCopy(wxCommandEvent& event);
+ void OnPaste(wxCommandEvent& event);
+ void OnUndo(wxCommandEvent& event);
+ void OnRedo(wxCommandEvent& event);
+
+ void OnUpdateCut(wxUpdateUIEvent& event);
+ void OnUpdateCopy(wxUpdateUIEvent& event);
+ void OnUpdatePaste(wxUpdateUIEvent& event);
+ void OnUpdateUndo(wxUpdateUIEvent& event);
+ void OnUpdateRedo(wxUpdateUIEvent& event);
+
virtual void Command(wxCommandEvent& event);
// implementation from here to the end
// Query app for menu item updates (called from OnIdle)
void DoMenuUpdates();
- void DoMenuUpdates(wxMenu* menu);
+ void DoMenuUpdates(wxMenu* menu, wxWindow* focusWin);
WXHMENU GetWinMenu() const ;
void OnChar(wxKeyEvent& event); // Process 'enter' if required
void OnEraseBackground(wxEraseEvent& event);
+ void OnCut(wxCommandEvent& event);
+ void OnCopy(wxCommandEvent& event);
+ void OnPaste(wxCommandEvent& event);
+ void OnUndo(wxCommandEvent& event);
+ void OnRedo(wxCommandEvent& event);
+
+ void OnUpdateCut(wxUpdateUIEvent& event);
+ void OnUpdateCopy(wxUpdateUIEvent& event);
+ void OnUpdatePaste(wxUpdateUIEvent& event);
+ void OnUpdateUndo(wxUpdateUIEvent& event);
+ void OnUpdateRedo(wxUpdateUIEvent& event);
+
// Implementation
// --------------
virtual void Command(wxCommandEvent& event);
// Query app for menu item updates (called from OnIdle)
void DoMenuUpdates();
- void DoMenuUpdates(wxMenu* menu);
+ void DoMenuUpdates(wxMenu* menu, wxWindow* focusWin);
// Checks if there is a toolbar, and returns the first free client position
virtual wxPoint GetClientAreaOrigin() const;
void OnDropFiles(wxDropFilesEvent& event);
// void OnChar(wxKeyEvent& event); // Process 'enter' if required
// void OnEraseBackground(wxEraseEvent& event);
-
+ void OnCut(wxCommandEvent& event);
+ void OnCopy(wxCommandEvent& event);
+ void OnPaste(wxCommandEvent& event);
+ void OnUndo(wxCommandEvent& event);
+ void OnRedo(wxCommandEvent& event);
+
+ void OnUpdateCut(wxUpdateUIEvent& event);
+ void OnUpdateCopy(wxUpdateUIEvent& event);
+ void OnUpdatePaste(wxUpdateUIEvent& event);
+ void OnUpdateUndo(wxUpdateUIEvent& event);
+ void OnUpdateRedo(wxUpdateUIEvent& event);
+
// Implementation
// --------------
virtual void Command(wxCommandEvent& event);
}
#endif // WXWIN_COMPATIBILITY
+// Find a window with the focus, that is also a descendant of the given window.
+// This is used to determine the window to initially send commands to.
+wxWindow* wxFindFocusDescendant(wxWindow* ancestor)
+{
+ // Process events starting with the window with the focus, if any.
+ wxWindow* focusWin = wxWindow::FindFocus();
+ wxWindow* win = focusWin;
+
+ // Check if this is a descendant of this frame.
+ // If not, win will be set to NULL.
+ while (win)
+ {
+ if (win == ancestor)
+ break;
+ else
+ win = win->GetParent();
+ }
+ if (win == (wxWindow*) NULL)
+ focusWin = (wxWindow*) NULL;
+
+ return focusWin;
+}
+
void wxFrame::DoMenuUpdates()
{
wxMenuBar* bar = GetMenuBar();
+
+ // Process events starting with the window with the focus, if any.
+ wxWindow* focusWin = wxFindFocusDescendant(this);
+
if ( bar != NULL ) {
int nCount = bar->GetMenuCount();
for (int n = 0; n < nCount; n++)
- DoMenuUpdates(bar->GetMenu(n));
+ DoMenuUpdates(bar->GetMenu(n), focusWin);
}
}
// update a menu and all submenus recursively
-void wxFrame::DoMenuUpdates(wxMenu* menu)
+void wxFrame::DoMenuUpdates(wxMenu* menu, wxWindow* focusWin)
{
+ wxEvtHandler* evtHandler = focusWin ? focusWin->GetEventHandler() : GetEventHandler();
wxNode* node = menu->GetItems().First();
while (node)
{
wxUpdateUIEvent event(id);
event.SetEventObject( this );
- if (GetEventHandler()->ProcessEvent(event))
+ if (evtHandler->ProcessEvent(event))
{
if (event.GetSetText())
menu->SetLabel(id, event.GetText());
}
if (item->GetSubMenu())
- DoMenuUpdates(item->GetSubMenu());
+ DoMenuUpdates(item->GetSubMenu(), focusWin);
}
node = node->Next();
}
#include "wx/wx.h"
#endif
+#include "wx/frame.h"
+
// For ::UpdateWindow
#ifdef __WXMSW__
#include <windows.h>
event.SetEventObject(this);
event.SetExtraLong((long) toggleDown);
+ // First try sending the command to a window that has the focus, within a frame that
+ // also contains this toolbar.
+ wxFrame* frame = (wxFrame*) NULL;
+ wxWindow* win = this;
+ wxWindow* focusWin = (wxWindow*) NULL;
+
+ while (win)
+ {
+ if (win->IsKindOf(CLASSINFO(wxFrame)))
+ {
+ frame = (wxFrame*) win;
+ break;
+ }
+ else
+ win = win->GetParent();
+ }
+ if (frame)
+ focusWin = wxFindFocusDescendant(frame);
+
+ if (focusWin && focusWin->GetEventHandler()->ProcessEvent(event))
+ return TRUE;
+
+ // Send events to this toolbar instead (and thence up the window hierarchy)
GetEventHandler()->ProcessEvent(event);
return TRUE;
// Do the toolbar button updates (check for EVT_UPDATE_UI handlers)
void wxToolBarBase::DoToolbarUpdates()
{
+ // First try sending the command to a window that has the focus, within a frame that
+ // also contains this toolbar.
+ wxFrame* frame = (wxFrame*) NULL;
+ wxWindow* win = this;
+ wxWindow* focusWin = (wxWindow*) NULL;
+
+ while (win)
+ {
+ if (win->IsKindOf(CLASSINFO(wxFrame)))
+ {
+ frame = (wxFrame*) win;
+ break;
+ }
+ else
+ win = win->GetParent();
+ }
+ if (frame)
+ focusWin = wxFindFocusDescendant(frame);
+
+
+ wxEvtHandler* evtHandler = focusWin ? focusWin->GetEventHandler() : GetEventHandler() ;
+
wxNode* node = GetTools().First();
while (node)
{
wxUpdateUIEvent event(tool->m_index);
event.SetEventObject(this);
- if (GetEventHandler()->ProcessEvent(event))
+ if (evtHandler->ProcessEvent(event))
{
if (event.GetSetEnabled())
EnableTool(tool->m_index, event.GetEnabled());
common/image.cpp \
common/imagjpeg.cpp \
common/imagpng.cpp \
+ common/imaggif.cpp \
common/ipcbase.cpp \
common/layout.cpp \
common/list.cpp \
{
bar->Check(id,!bar->Checked(id)) ;
}
- GetEventHandler()->ProcessEvent(commandEvent);
+
+ // Process events starting with the window with the focus, if any.
+ wxWindow* focusWin = wxFindFocusDescendant(this);
+
+ wxEvtHandler* evtHandler = focusWin ? focusWin->GetEventHandler() : GetEventHandler();
+
+ evtHandler->ProcessEvent(commandEvent);
}
void wxFrame::SetStatusText(const wxString& text, int number)
#endif
#include "wx/toolbar.h"
+#include "wx/frame.h"
#include "glib.h"
#include "gdk/gdk.h"
event.SetInt( toolIndex );
event.SetExtraLong((long) toggleDown);
+ // First try sending the command to a window that has the focus, within a frame that
+ // also contains this toolbar.
+ wxFrame* frame = (wxFrame*) NULL;
+ wxWindow* win = this;
+ wxWindow* focusWin = (wxWindow*) NULL;
+
+ while (win)
+ {
+ if (win->IsKindOf(CLASSINFO(wxFrame)))
+ {
+ frame = (wxFrame*) win;
+ break;
+ }
+ else
+ win = win->GetParent();
+ }
+ if (frame)
+ focusWin = wxFindFocusDescendant(frame);
+
+ if (focusWin && focusWin->GetEventHandler()->ProcessEvent(event))
+ return TRUE;
+
GetEventHandler()->ProcessEvent(event);
return TRUE;
BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
EVT_CHAR(wxTextCtrl::OnChar)
+
+ EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
+ EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
+ EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
+ EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
+ EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
+
+ EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
+ EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
+ EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
+ EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
+ EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
END_EVENT_TABLE()
#ifndef NO_TEXT_WINDOW_STREAM
}
}
+void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
+{
+ Cut();
+}
+
+void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
+{
+ Copy();
+}
+
+void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
+{
+ Paste();
+}
+
+void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
+{
+ Undo();
+}
+
+void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
+{
+ Redo();
+}
+
+void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
+{
+ event.Enable( CanCut() );
+}
+
+void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
+{
+ event.Enable( CanCopy() );
+}
+
+void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
+{
+ event.Enable( CanPaste() );
+}
+
+void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
+{
+ event.Enable( CanUndo() );
+}
+
+void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
+{
+ event.Enable( CanRedo() );
+}
{
bar->Check(id,!bar->Checked(id)) ;
}
- GetEventHandler()->ProcessEvent(commandEvent);
+
+ // Process events starting with the window with the focus, if any.
+ wxWindow* focusWin = wxFindFocusDescendant(this);
+
+ wxEvtHandler* evtHandler = focusWin ? focusWin->GetEventHandler() : GetEventHandler();
+
+ evtHandler->ProcessEvent(commandEvent);
}
void wxFrame::SetStatusText(const wxString& text, int number)
#endif
#include "wx/toolbar.h"
+#include "wx/frame.h"
#include "glib.h"
#include "gdk/gdk.h"
event.SetInt( toolIndex );
event.SetExtraLong((long) toggleDown);
+ // First try sending the command to a window that has the focus, within a frame that
+ // also contains this toolbar.
+ wxFrame* frame = (wxFrame*) NULL;
+ wxWindow* win = this;
+ wxWindow* focusWin = (wxWindow*) NULL;
+
+ while (win)
+ {
+ if (win->IsKindOf(CLASSINFO(wxFrame)))
+ {
+ frame = (wxFrame*) win;
+ break;
+ }
+ else
+ win = win->GetParent();
+ }
+ if (frame)
+ focusWin = wxFindFocusDescendant(frame);
+
+ if (focusWin && focusWin->GetEventHandler()->ProcessEvent(event))
+ return TRUE;
+
GetEventHandler()->ProcessEvent(event);
return TRUE;
BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
EVT_CHAR(wxTextCtrl::OnChar)
+
+ EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
+ EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
+ EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
+ EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
+ EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
+
+ EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
+ EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
+ EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
+ EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
+ EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
END_EVENT_TABLE()
#ifndef NO_TEXT_WINDOW_STREAM
}
}
+void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
+{
+ Cut();
+}
+
+void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
+{
+ Copy();
+}
+
+void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
+{
+ Paste();
+}
+
+void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
+{
+ Undo();
+}
+
+void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
+{
+ Redo();
+}
+
+void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
+{
+ event.Enable( CanCut() );
+}
+
+void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
+{
+ event.Enable( CanCopy() );
+}
+
+void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
+{
+ event.Enable( CanPaste() );
+}
+
+void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
+{
+ event.Enable( CanUndo() );
+}
+
+void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
+{
+ event.Enable( CanRedo() );
+}
}
*/
- GetEventHandler()->ProcessEvent(commandEvent);
+ // Process events starting with the window with the focus, if any.
+ wxWindow* focusWin = wxFindFocusDescendant(this);
+
+ wxEvtHandler* evtHandler = focusWin ? focusWin->GetEventHandler() : GetEventHandler();
+
+ evtHandler->ProcessEvent(commandEvent);
}
// Checks if there is a toolbar, and returns the first free client position
}
*/
- GetEventHandler()->ProcessEvent(commandEvent);
+ // Process events starting with the window with the focus, if any.
+ wxWindow* focusWin = wxFindFocusDescendant(this);
+
+ wxEvtHandler* evtHandler = focusWin ? focusWin->GetEventHandler() : GetEventHandler();
+
+ evtHandler->ProcessEvent(commandEvent);
}
// Checks if there is a toolbar, and returns the first free client position
common/image.cpp \
common/imagjpeg.cpp \
common/imagpng.cpp \
+ common/imaggif.cpp \
common/intl.cpp \
common/ipcbase.cpp \
common/layout.cpp \
}
*/
- GetEventHandler()->ProcessEvent(commandEvent);
+ // Process events starting with the window with the focus, if any.
+ wxWindow* focusWin = wxFindFocusDescendant(this);
+
+ wxEvtHandler* evtHandler = focusWin ? focusWin->GetEventHandler() : GetEventHandler();
+
+ evtHandler->ProcessEvent(commandEvent);
}
// Checks if there is a toolbar, and returns the first free client position
../common/image.cpp \
../common/imagjpeg.cpp \
../common/imagpng.cpp \
+ ../common/imaggif.cpp \
../common/layout.cpp \
../common/list.cpp \
../common/log.cpp \
BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
EVT_CHAR(wxTextCtrl::OnChar)
+
+ EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
+ EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
+ EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
+ EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
+ EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
+
+ EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
+ EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
+ EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
+ EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
+ EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
+
END_EVENT_TABLE()
#endif
tw->ProcessCommand(event);
}
+void wxTextCtrl::OnCut(wxCommandEvent& WXUNUSED(event))
+{
+ Cut();
+}
+
+void wxTextCtrl::OnCopy(wxCommandEvent& WXUNUSED(event))
+{
+ Copy();
+}
+
+void wxTextCtrl::OnPaste(wxCommandEvent& WXUNUSED(event))
+{
+ Paste();
+}
+
+void wxTextCtrl::OnUndo(wxCommandEvent& WXUNUSED(event))
+{
+ Undo();
+}
+
+void wxTextCtrl::OnRedo(wxCommandEvent& WXUNUSED(event))
+{
+ Redo();
+}
+
+void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
+{
+ event.Enable( CanCut() );
+}
+
+void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
+{
+ event.Enable( CanCopy() );
+}
+
+void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
+{
+ event.Enable( CanPaste() );
+}
+
+void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
+{
+ event.Enable( CanUndo() );
+}
+
+void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
+{
+ event.Enable( CanRedo() );
+}
{
bar->Check(id,!bar->Checked(id)) ;
}
- GetEventHandler()->ProcessEvent(commandEvent);
+
+ // Process events starting with the window with the focus, if any.
+ wxWindow* focusWin = wxFindFocusDescendant(this);
+
+ wxEvtHandler* evtHandler = focusWin ? focusWin->GetEventHandler() : GetEventHandler();
+ evtHandler->ProcessEvent(commandEvent);
}
// Checks if there is a toolbar, and returns the first free client position
..\common\$D\image.obj \
..\common\$D\imagjpeg.obj \
..\common\$D\imagpng.obj \
+ ..\common\$D\imaggif.obj \
..\common\$D\intl.obj \
..\common\$D\ipcbase.obj \
..\common\$D\helpbase.obj \
#endif
#if !USE_SHARED_LIBRARY
+
IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
EVT_CHAR(wxTextCtrl::OnChar)
EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
EVT_ERASE_BACKGROUND(wxTextCtrl::OnEraseBackground)
+
+ EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
+ EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
+ EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
+ EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
+ EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
+
+ EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
+ EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
+ EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
+ EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
+ EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
END_EVENT_TABLE()
+
#endif // USE_SHARED_LIBRARY
// Text item
// Clipboard operations
void wxTextCtrl::Copy()
{
- HWND hWnd = (HWND) GetHWND();
- SendMessage(hWnd, WM_COPY, 0, 0L);
+ if (CanCopy())
+ {
+ HWND hWnd = (HWND) GetHWND();
+ SendMessage(hWnd, WM_COPY, 0, 0L);
+ }
}
void wxTextCtrl::Cut()
{
- HWND hWnd = (HWND) GetHWND();
- SendMessage(hWnd, WM_CUT, 0, 0L);
+ if (CanCut())
+ {
+ HWND hWnd = (HWND) GetHWND();
+ SendMessage(hWnd, WM_CUT, 0, 0L);
+ }
}
void wxTextCtrl::Paste()
{
- HWND hWnd = (HWND) GetHWND();
- SendMessage(hWnd, WM_PASTE, 0, 0L);
+ if (CanPaste())
+ {
+ HWND hWnd = (HWND) GetHWND();
+ SendMessage(hWnd, WM_PASTE, 0, 0L);
+ }
}
void wxTextCtrl::SetEditable(bool editable)
#endif
#endif
+void wxTextCtrl::OnCut(wxCommandEvent& event)
+{
+ Cut();
+}
+
+void wxTextCtrl::OnCopy(wxCommandEvent& event)
+{
+ Copy();
+}
+
+void wxTextCtrl::OnPaste(wxCommandEvent& event)
+{
+ Paste();
+}
+
+void wxTextCtrl::OnUndo(wxCommandEvent& event)
+{
+ Undo();
+}
+
+void wxTextCtrl::OnRedo(wxCommandEvent& event)
+{
+ Redo();
+}
+
+void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
+{
+ event.Enable( CanCut() );
+}
+
+void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
+{
+ event.Enable( CanCopy() );
+}
+
+void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
+{
+ event.Enable( CanPaste() );
+}
+
+void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
+{
+ event.Enable( CanUndo() );
+}
+
+void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
+{
+ event.Enable( CanRedo() );
+}
+
}
*/
- GetEventHandler()->ProcessEvent(commandEvent);
+ // Process events starting with the window with the focus, if any.
+ wxWindow* focusWin = wxFindFocusDescendant(this);
+
+ wxEvtHandler* evtHandler = focusWin ? focusWin->GetEventHandler() : GetEventHandler();
+
+ evtHandler->ProcessEvent(commandEvent);
}
// Checks if there is a toolbar, and returns the first free client position
BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
+ EVT_MENU(wxID_CUT, wxTextCtrl::OnCut)
+ EVT_MENU(wxID_COPY, wxTextCtrl::OnCopy)
+ EVT_MENU(wxID_PASTE, wxTextCtrl::OnPaste)
+ EVT_MENU(wxID_UNDO, wxTextCtrl::OnUndo)
+ EVT_MENU(wxID_REDO, wxTextCtrl::OnRedo)
+
+ EVT_UPDATE_UI(wxID_CUT, wxTextCtrl::OnUpdateCut)
+ EVT_UPDATE_UI(wxID_COPY, wxTextCtrl::OnUpdateCopy)
+ EVT_UPDATE_UI(wxID_PASTE, wxTextCtrl::OnUpdatePaste)
+ EVT_UPDATE_UI(wxID_UNDO, wxTextCtrl::OnUpdateUndo)
+ EVT_UPDATE_UI(wxID_REDO, wxTextCtrl::OnUpdateRedo)
END_EVENT_TABLE()
#endif
return *this;
}
+void wxTextCtrl::OnCut(wxCommandEvent& event)
+{
+ Cut();
+}
+
+void wxTextCtrl::OnCopy(wxCommandEvent& event)
+{
+ Copy();
+}
+
+void wxTextCtrl::OnPaste(wxCommandEvent& event)
+{
+ Paste();
+}
+
+void wxTextCtrl::OnUndo(wxCommandEvent& event)
+{
+ Undo();
+}
+
+void wxTextCtrl::OnRedo(wxCommandEvent& event)
+{
+ Redo();
+}
+
+void wxTextCtrl::OnUpdateCut(wxUpdateUIEvent& event)
+{
+ event.Enable( CanCut() );
+}
+
+void wxTextCtrl::OnUpdateCopy(wxUpdateUIEvent& event)
+{
+ event.Enable( CanCopy() );
+}
+
+void wxTextCtrl::OnUpdatePaste(wxUpdateUIEvent& event)
+{
+ event.Enable( CanPaste() );
+}
+
+void wxTextCtrl::OnUpdateUndo(wxUpdateUIEvent& event)
+{
+ event.Enable( CanUndo() );
+}
+
+void wxTextCtrl::OnUpdateRedo(wxUpdateUIEvent& event)
+{
+ event.Enable( CanRedo() );
+}
projects / wxWidgets.git / commitdiff
