Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

wxInputConsumer

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@11664 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Václav Slavík
2001-09-22 11:56:04 +00:00
parent d6eaea2845
commit 23645bfa01
26 changed files with 406 additions and 259 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
include/wx/univ/button.h
View File

@@ -139,14 +139,14 @@ class WXDLLEXPORT wxStdButtonInputHandler : public wxStdInputHandler
public:
wxStdButtonInputHandler(wxInputHandler *inphand);
virtual bool HandleKey(wxControl *control,
virtual bool HandleKey(wxInputConsumer *consumer,
const wxKeyEvent& event,
bool pressed);
virtual bool HandleMouse(wxControl *control,
virtual bool HandleMouse(wxInputConsumer *consumer,
const wxMouseEvent& event);
virtual bool HandleMouseMove(wxControl *control, const wxMouseEvent& event);
virtual bool HandleFocus(wxControl *control, const wxFocusEvent& event);
virtual bool HandleActivation(wxControl *control, bool activated);
virtual bool HandleMouseMove(wxInputConsumer *consumer, const wxMouseEvent& event);
virtual bool HandleFocus(wxInputConsumer *consumer, const wxFocusEvent& event);
virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);
private:
// the window (button) which has capture or NULL and the flag telling if

2
include/wx/univ/checkbox.h
View File

@@ -155,7 +155,7 @@ public:
// we have to override this one as wxStdButtonInputHandler version works
// only with the buttons
virtual bool HandleActivation(wxControl *control, bool activated);
virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);
};
#endif // _WX_UNIV_CHECKBOX_H_

4
include/wx/univ/checklst.h
View File

@@ -102,10 +102,10 @@ class WXDLLEXPORT wxStdCheckListboxInputHandler : public wxStdListboxInputHandle
public:
wxStdCheckListboxInputHandler(wxInputHandler *inphand);
virtual bool HandleKey(wxControl *control,
virtual bool HandleKey(wxInputConsumer *consumer,
const wxKeyEvent& event,
bool pressed);
virtual bool HandleMouse(wxControl *control,
virtual bool HandleMouse(wxInputConsumer *consumer,
const wxMouseEvent& event);
};

2
include/wx/univ/combobox.h
View File

@@ -303,7 +303,7 @@ class WXDLLEXPORT wxStdComboBoxInputHandler : public wxStdInputHandler
public:
wxStdComboBoxInputHandler(wxInputHandler *inphand);
virtual bool HandleKey(wxControl *control,
virtual bool HandleKey(wxInputConsumer *consumer,
const wxKeyEvent& event,
bool pressed);
};

34
include/wx/univ/control.h
View File

@@ -24,6 +24,8 @@ class WXDLLEXPORT wxRenderer;
// it
#include "wx/univ/inphand.h"
#include "wx/univ/inpcons.h"
// ----------------------------------------------------------------------------
// wxControlAction: the action is currently just a string which identifies it,
// later it might become an atom (i.e. an opaque handler to string).
@@ -40,7 +42,7 @@ typedef wxString wxControlAction;
// wxControl: the base class for all GUI controls
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxControl : public wxControlBase
class WXDLLEXPORT wxControl : public wxControlBase, public wxInputConsumer
{
public:
wxControl() { Init(); }
@@ -85,39 +87,12 @@ public:
return m_indexAccel == -1 ? _T('\0') : m_label[m_indexAccel];
}
// get the input handler of this control
wxInputHandler *GetInputHandler() const { return m_handler; }
// perform a control-dependent action: an action may have an optional
// numeric and another (also optional) string argument whose interpretation
// depends on the action
//
// NB: we might use ellipsis in PerformAction() declaration but this
// wouldn't be more efficient than always passing 2 unused parameters
// but would be more difficult. Another solution would be to have
// several overloaded versions but this will expose the problem of
// virtual function hiding we don't have here.
virtual bool PerformAction(const wxControlAction& action,
long numArg = -1l,
const wxString& strArg = wxEmptyString);
virtual wxWindow *GetInputWindow() const { return (wxWindow*)this; }
protected:
// event handlers
void OnMouse(wxMouseEvent& event);
void OnKeyDown(wxKeyEvent& event);
void OnKeyUp(wxKeyEvent& event);
void OnFocus(wxFocusEvent& event);
void OnActivate(wxActivateEvent& event);
// common part of all ctors
void Init();
// create input handler by name
void CreateInputHandler(const wxString& inphandler);
// input processor (never deleted, the theme deletes it itself)
wxInputHandler *m_handler;
private:
// label and accel info
wxString m_label;
@@ -125,6 +100,7 @@ private:
DECLARE_DYNAMIC_CLASS(wxControl)
DECLARE_EVENT_TABLE()
WX_DECLARE_INPUT_CONSUMER()
};
#endif // _WX_UNIV_CONTROL_H_

140
include/wx/univ/inpcons.h Normal file
View File

@@ -0,0 +1,140 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/univ/inpcons.h
// Purpose: wxInputConsumer: mix-in class for input handling
// Author: Vadim Zeitlin
// Modified by:
// Created: 14.08.00
// RCS-ID: $Id$
// Copyright: (c) 2000 SciTech Software, Inc. (www.scitechsoft.com)
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIV_INPCONS_H_
#define _WX_UNIV_INPCONS_H_
#ifdef __GNUG__
#pragma interface "inpcons.h"
#endif
class WXDLLEXPORT wxInputHandler;
class WXDLLEXPORT wxWindow;
#include "wx/object.h"
#include "wx/event.h"
// ----------------------------------------------------------------------------
// wxControlAction: the action is currently just a string which identifies it,
// later it might become an atom (i.e. an opaque handler to string).
// ----------------------------------------------------------------------------
typedef wxString wxControlAction;
// the list of actions which apply to all controls (other actions are defined
// in the controls headers)
#define wxACTION_NONE _T("") // no action to perform
// ----------------------------------------------------------------------------
// wxInputConsumer: mix-in class for handling wxControlActions (used by
// wxControl and wxTopLevelWindow).
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxInputConsumer
{
public:
wxInputConsumer() { m_inputHandler = NULL; }
// get the input handler
wxInputHandler *GetInputHandler() const { return m_inputHandler; }
// perform a control-dependent action: an action may have an optional
// numeric and another (also optional) string argument whose interpretation
// depends on the action
//
// NB: we might use ellipsis in PerformAction() declaration but this
// wouldn't be more efficient than always passing 2 unused parameters
// but would be more difficult. Another solution would be to have
// several overloaded versions but this will expose the problem of
// virtual function hiding we don't have here.
virtual bool PerformAction(const wxControlAction& action,
long numArg = -1l,
const wxString& strArg = wxEmptyString);
// get the window to work with (usually the class wxInputConsumer was mixed into)
virtual wxWindow *GetInputWindow() const = 0;
protected:
// event handlers
void OnMouse(wxMouseEvent& event);
void OnKeyDown(wxKeyEvent& event);
void OnKeyUp(wxKeyEvent& event);
void OnFocus(wxFocusEvent& event);
void OnActivate(wxActivateEvent& event);
// create input handler by name
void CreateInputHandler(const wxString& inphandler);
// input processor (never deleted, the theme deletes it itself)
wxInputHandler *m_inputHandler;
};
// ----------------------------------------------------------------------------
// macros which must be used by the classes derived from wxInputConsumer mix-in
// ----------------------------------------------------------------------------
// declare the methods to be forwarded
#define WX_DECLARE_INPUT_CONSUMER() \
private: \
void OnMouse(wxMouseEvent& event); \
void OnKeyDown(wxKeyEvent& event); \
void OnKeyUp(wxKeyEvent& event); \
void OnFocus(wxFocusEvent& event); \
void OnActivate(wxActivateEvent& event);
// implement the event table entries for wxControlContainer
#define WX_EVENT_TABLE_INPUT_CONSUMER(classname) \
EVT_KEY_DOWN(classname::OnKeyDown) \
EVT_KEY_UP(classname::OnKeyUp) \
EVT_MOUSE_EVENTS(classname::OnMouse) \
EVT_SET_FOCUS(classname::OnFocus) \
EVT_KILL_FOCUS(classname::OnFocus) \
EVT_ACTIVATE(classname::OnActivate)
// Forward event handlers to wxInputConsumer
//
// (We can't use them directly, because wxIC has virtual methods, which forces
// the compiler to include (at least) two vtables into wxControl, one for the
// wxWindow-wxControlBase-wxControl branch and one for the wxIC mix-in.
// Consequently, the "this" pointer has different value when in wxControl's
// and wxIC's method, even though the instance stays same. This doesn't matter
// so far as member pointers aren't used, but that's not wxControl's case.
// When we add an event table entry (= use a member pointer) pointing to
// wxIC's OnXXX method, GCC compiles code that executes wxIC::OnXXX with the
// version of "this" that belongs to wxControl, not wxIC! In our particular
// case, the effect is that m_handler is NULL (probably same memory
// area as the_other_vtable's_this->m_refObj) and input handling doesn't work.)
#define WX_FORWARD_TO_INPUT_CONSUMER(classname) \
void classname::OnMouse(wxMouseEvent& event) \
{ \
wxInputConsumer::OnMouse(event); \
} \
void classname::OnKeyDown(wxKeyEvent& event) \
{ \
wxInputConsumer::OnKeyDown(event); \
} \
void classname::OnKeyUp(wxKeyEvent& event) \
{ \
wxInputConsumer::OnKeyUp(event); \
} \
void classname::OnFocus(wxFocusEvent& event) \
{ \
wxInputConsumer::OnFocus(event); \
} \
void classname::OnActivate(wxActivateEvent& event) \
{ \
wxInputConsumer::OnActivate(event); \
}
#endif // _WX_UNIV_INPCONS_H_

30
include/wx/univ/inphand.h
View File

@@ -17,7 +17,7 @@
#pragma interface "inphand.h"
#endif
#include "wx/control.h" // for wxControlAction(s)
#include "wx/univ/inpcons.h" // for wxControlAction(s)
// ----------------------------------------------------------------------------
// types of the standard input handlers which can be passed to
@@ -41,23 +41,23 @@
// wxInputHandler: maps the events to the actions
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxInputHandler
class WXDLLEXPORT wxInputHandler : public wxObject
{
public:
// map a keyboard event to one or more actions (pressed == TRUE if the key
// was pressed, FALSE if released), returns TRUE if something was done
virtual bool HandleKey(wxControl *control,
virtual bool HandleKey(wxInputConsumer *consumer,
const wxKeyEvent& event,
bool pressed) = 0;
// map a mouse (click) event to one or more actions
virtual bool HandleMouse(wxControl *control,
virtual bool HandleMouse(wxInputConsumer *consumer,
const wxMouseEvent& event) = 0;
// handle mouse movement (or enter/leave) event: it is separated from
// HandleMouse() for convenience as many controls don't care about mouse
// movements at all
virtual bool HandleMouseMove(wxControl *control,
virtual bool HandleMouseMove(wxInputConsumer *consumer,
const wxMouseEvent& event);
// do something with focus set/kill event: this is different from
@@ -65,12 +65,12 @@ public:
// focus
//
// return TRUE to refresh the control, FALSE otherwise
virtual bool HandleFocus(wxControl *control, const wxFocusEvent& event);
virtual bool HandleFocus(wxInputConsumer *consumer, const wxFocusEvent& event);
// react to the app getting/losing activation
//
// return TRUE to refresh the control, FALSE otherwise
virtual bool HandleActivation(wxControl *control, bool activated);
virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);
// virtual dtor for any base class
virtual ~wxInputHandler();
@@ -86,28 +86,28 @@ class WXDLLEXPORT wxStdInputHandler : public wxInputHandler
public:
wxStdInputHandler(wxInputHandler *handler) : m_handler(handler) { }
virtual bool HandleKey(wxControl *control,
virtual bool HandleKey(wxInputConsumer *consumer,
const wxKeyEvent& event,
bool pressed)
{
return m_handler ? m_handler->HandleKey(control, event, pressed)
return m_handler ? m_handler->HandleKey(consumer, event, pressed)
: FALSE;
}
virtual bool HandleMouse(wxControl *control,
virtual bool HandleMouse(wxInputConsumer *consumer,
const wxMouseEvent& event)
{
return m_handler ? m_handler->HandleMouse(control, event) : FALSE;
return m_handler ? m_handler->HandleMouse(consumer, event) : FALSE;
}
virtual bool HandleMouseMove(wxControl *control, const wxMouseEvent& event)
virtual bool HandleMouseMove(wxInputConsumer *consumer, const wxMouseEvent& event)
{
return m_handler ? m_handler->HandleMouseMove(control, event) : FALSE;
return m_handler ? m_handler->HandleMouseMove(consumer, event) : FALSE;
}
virtual bool HandleFocus(wxControl *control, const wxFocusEvent& event)
virtual bool HandleFocus(wxInputConsumer *consumer, const wxFocusEvent& event)
{
return m_handler ? m_handler->HandleFocus(control, event) : FALSE;
return m_handler ? m_handler->HandleFocus(consumer, event) : FALSE;
}
private:

6
include/wx/univ/listbox.h
View File

@@ -290,12 +290,12 @@ public:
bool toggleOnPressAlways = TRUE);
// base class methods
virtual bool HandleKey(wxControl *control,
virtual bool HandleKey(wxInputConsumer *consumer,
const wxKeyEvent& event,
bool pressed);
virtual bool HandleMouse(wxControl *control,
virtual bool HandleMouse(wxInputConsumer *consumer,
const wxMouseEvent& event);
virtual bool HandleMouseMove(wxControl *control,
virtual bool HandleMouseMove(wxInputConsumer *consumer,
const wxMouseEvent& event);
protected:

12
include/wx/univ/notebook.h
View File

@@ -259,17 +259,17 @@ class WXDLLEXPORT wxStdNotebookInputHandler : public wxStdInputHandler
public:
wxStdNotebookInputHandler(wxInputHandler *inphand);
virtual bool HandleKey(wxControl *control,
virtual bool HandleKey(wxInputConsumer *consumer,
const wxKeyEvent& event,
bool pressed);
virtual bool HandleMouse(wxControl *control,
virtual bool HandleMouse(wxInputConsumer *consumer,
const wxMouseEvent& event);
virtual bool HandleMouseMove(wxControl *control, const wxMouseEvent& event);
virtual bool HandleFocus(wxControl *control, const wxFocusEvent& event);
virtual bool HandleActivation(wxControl *control, bool activated);
virtual bool HandleMouseMove(wxInputConsumer *consumer, const wxMouseEvent& event);
virtual bool HandleFocus(wxInputConsumer *consumer, const wxFocusEvent& event);
virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);
protected:
void HandleFocusChange(wxControl *control);
void HandleFocusChange(wxInputConsumer *consumer);
};
#endif // _WX_UNIV_NOTEBOOK_H_

6
include/wx/univ/scrolbar.h
View File

@@ -170,12 +170,12 @@ public:
wxStdScrollBarInputHandler(wxRenderer *renderer,
wxInputHandler *inphand);
virtual bool HandleKey(wxControl *control,
virtual bool HandleKey(wxInputConsumer *consumer,
const wxKeyEvent& event,
bool pressed);
virtual bool HandleMouse(wxControl *control,
virtual bool HandleMouse(wxInputConsumer *consumer,
const wxMouseEvent& event);
virtual bool HandleMouseMove(wxControl *control, const wxMouseEvent& event);
virtual bool HandleMouseMove(wxInputConsumer *consumer, const wxMouseEvent& event);
virtual ~wxStdScrollBarInputHandler();

8
include/wx/univ/slider.h
View File

@@ -231,15 +231,15 @@ public:
}
// base class methods
virtual bool HandleKey(wxControl *control,
virtual bool HandleKey(wxInputConsumer *consumer,
const wxKeyEvent& event,
bool pressed);
virtual bool HandleMouse(wxControl *control,
virtual bool HandleMouse(wxInputConsumer *consumer,
const wxMouseEvent& event);
virtual bool HandleMouseMove(wxControl *control,
virtual bool HandleMouseMove(wxInputConsumer *consumer,
const wxMouseEvent& event);
virtual bool HandleFocus(wxControl *control, const wxFocusEvent& event);
virtual bool HandleFocus(wxInputConsumer *consumer, const wxFocusEvent& event);
};
#endif // _WX_UNIV_SLIDER_H_

6
include/wx/univ/spinbutt.h
View File

@@ -107,12 +107,12 @@ class WXDLLEXPORT wxStdSpinButtonInputHandler : public wxStdInputHandler
public:
wxStdSpinButtonInputHandler(wxInputHandler *inphand);
virtual bool HandleKey(wxControl *control,
virtual bool HandleKey(wxInputConsumer *consumer,
const wxKeyEvent& event,
bool pressed);
virtual bool HandleMouse(wxControl *control,
virtual bool HandleMouse(wxInputConsumer *consumer,
const wxMouseEvent& event);
virtual bool HandleMouseMove(wxControl *control,
virtual bool HandleMouseMove(wxInputConsumer *consumer,
const wxMouseEvent& event);
};

8
include/wx/univ/textctrl.h
View File

@@ -562,14 +562,14 @@ class WXDLLEXPORT wxStdTextCtrlInputHandler : public wxStdInputHandler
public:
wxStdTextCtrlInputHandler(wxInputHandler *inphand);
virtual bool HandleKey(wxControl *control,
virtual bool HandleKey(wxInputConsumer *consumer,
const wxKeyEvent& event,
bool pressed);
virtual bool HandleMouse(wxControl *control,
virtual bool HandleMouse(wxInputConsumer *consumer,
const wxMouseEvent& event);
virtual bool HandleMouseMove(wxControl *control,
virtual bool HandleMouseMove(wxInputConsumer *consumer,
const wxMouseEvent& event);
virtual bool HandleFocus(wxControl *control, const wxFocusEvent& event);
virtual bool HandleFocus(wxInputConsumer *consumer, const wxFocusEvent& event);
protected:
// get the position of the mouse click