keybinder.h

Go to the documentation of this file.

// Name:        keybinder.h
// Purpose:     Classes for binding keypresses to commands.
// Author:      Aleksandras Gluchovas
// Modified by: Francesco Montorsi (6/1/2004)
// Created:     2000/02/10
// RCS-ID:      $Id: keybinder.h 443 2007-03-01 19:15:57Z frm $
// Copyright:   (c) Aleksandras Gluchovas and (c) Francesco Montorsi
// Licence:     wxWidgets licence


#ifndef __KEYBINDER_G__
#define __KEYBINDER_G__


// required includes
#include "wx/keybinderdef.h"
#include "wx/panel.h"
#include "wx/dialog.h"
#include "wx/listbox.h"
#include "wx/treectrl.h"
#include "wx/menu.h"
#include "wx/button.h"
#include "wx/stattext.h"
#include "wx/textctrl.h"
#include "wx/combobox.h"
#include "wx/app.h"


// The maximum number of shortcuts associated with each wxCmd.
#define wxCMD_MAX_SHORTCUTS             3

#ifndef wxID_INVALID

    // A value used to represent an invalid id...
    #define wxID_INVALID                -1
#endif

// define the following to true to enable lots of debug messages
#define wxKEYBINDER_DEBUG_MSG            0
#if wxKEYBINDER_DEBUG_MSG
    #define wxKBLogDebug    wxLogDebug
#else
    inline void wxKBLogDebug(const wxChar *WXUNUSED(fmt), ...) { /* do nothing */ }
#endif


// defined later...
class wxConfigBase;
class wxKeyBinder;



class WXDLLIMPEXP_KEYBINDER wxKeyBind
{
protected:

    int m_nFlags;

    int m_nKeyCode;

public:

    wxKeyBind() {
        m_nKeyCode = m_nFlags = -1;
    }

    wxKeyBind(int flags, int keycode) {
        Set(flags, keycode);
    }

    wxKeyBind(const wxKeyBind &tocopy) {
        DeepCopy(tocopy);
    }

    wxKeyBind(const wxString &key) {
        m_nFlags = StringToKeyModifier(key);
        m_nKeyCode = StringToKeyCode(key.AfterLast('+').AfterLast('-'));
    }

    virtual void DeepCopy(const wxKeyBind &p) {
        m_nFlags = p.m_nFlags;
        m_nKeyCode = p.m_nKeyCode;
    }

    virtual ~wxKeyBind() {}



public:

    void Set(int flags, int keycode) {
        m_nFlags = flags;
        m_nKeyCode = keycode;
    }

    void Set(const wxKeyBind &key) {
        m_nFlags = key.m_nFlags;
        m_nKeyCode = key.m_nKeyCode;
    }

    bool MatchKey(const wxKeyEvent &key) const;

    bool Match(const wxKeyBind &key) const {
        if (m_nFlags == key.m_nFlags && m_nKeyCode == key.m_nKeyCode)
            return TRUE;
        return FALSE;
    }



    // Getters
    // ------------------

    int GetKeyCode() const {
        return m_nKeyCode;
    }

    int GetModifiers() const {
        return m_nFlags;
    }

    // Returns the string which describes this key combination.
    wxString GetStr() const {
        return KeyModifierToString(m_nFlags) +
            KeyCodeToString(m_nKeyCode);
    }

    wxAcceleratorEntry GetAccelerator(int cmdId) const {
        return wxAcceleratorEntry(GetModifiers(), GetKeyCode(), cmdId);
    }


public:     // static utilities

    static wxString NumpadKeyCodeToString(int keyCode);
    static wxString KeyCodeToString(int keyCode);
    static wxString KeyModifierToString(int keyModifier);

    static int StringToKeyCode(const wxString &keyName);
    static int StringToKeyModifier(const wxString &keyModifier);

    static int GetKeyModifier(wxKeyEvent &event);
    static wxString GetKeyStrokeString(wxKeyEvent &event);
};




#define wxCMD_MAX_TYPES             16

#define wxCMD_CONFIG_PREFIX         wxT("bind")


class WXDLLIMPEXP_KEYBINDER wxCmd
{
    // wxKeyBinder must be allowed to call #Exec()
    friend class wxKeyBinder;

protected:

    wxKeyBind m_keyShortcut[wxCMD_MAX_SHORTCUTS];
    int m_nShortcuts;       

    wxString m_strName;

    wxString m_strDescription;

    int m_nId;

protected:      // static

    typedef wxCmd *(*wxCmdCreationFnc)(int id);

    typedef struct {
        int type;
        wxCmdCreationFnc cmdCreateFnc;
    } wxCmdType;

    static wxCmdType m_arrCmdType[wxCMD_MAX_TYPES];

    static int m_nCmdTypes;


public:     // static

    static wxCmd *CreateNew(int type, int id);

    static void AddCmdType(int type, wxCmdCreationFnc fnc);

    static wxCmdType *FindCmdType(int type);

public:

    wxCmd(const wxKeyBind &first, int id,
        const wxString &name = wxEmptyString,
        const wxString &desc = wxEmptyString) {
        m_strName = name;
        m_strDescription = desc;
        m_nShortcuts = 1;
        m_keyShortcut[0] = first;
        m_nId = id;
    }

    wxCmd(int id = wxID_INVALID,
        const wxString &name = wxEmptyString,
        const wxString &desc = wxEmptyString) {
        m_strName = name;
        m_strDescription = desc;
        m_nId = id;
        m_nShortcuts = 0;
    }

    virtual void DeepCopy(const wxCmd *cmd) {
        m_strName = cmd->m_strName;
        m_strDescription = cmd->m_strDescription;
        m_nId = cmd->m_nId;
        m_nShortcuts = cmd->m_nShortcuts;

        for (int i=0; i < m_nShortcuts; i++)
            m_keyShortcut[i].DeepCopy(cmd->m_keyShortcut[i]);
    }

    virtual wxCmd *Clone() const = 0;

    // Destructor
    virtual ~wxCmd() {}


public:

    // Add/Remove functions
    // ----------------------------

    void AddShortcut(const wxKeyBind &key) {
        if (m_nShortcuts >= wxCMD_MAX_SHORTCUTS) return;
        m_keyShortcut[m_nShortcuts++] = key;
        Update();
    }

    void AddShortcut(int flags, int keycode) {
        if (m_nShortcuts >= wxCMD_MAX_SHORTCUTS) return;
        wxKeyBind key(flags, keycode);
        AddShortcut(key);
        // update is called by the previous call
    }

    void AddShortcut(const wxString &key) {
        if (m_nShortcuts >= wxCMD_MAX_SHORTCUTS) return;
        if (key.IsEmpty()) return;
        m_keyShortcut[m_nShortcuts++] = wxKeyBind(key);
        Update();
    }

    void RemoveShortcut(int n) {
        for (int i=n; i < m_nShortcuts; i++)    // shift array left
            m_keyShortcut[i] = m_keyShortcut[i+1];
        m_nShortcuts--;
        Update();
    }

    void RemoveAllShortcuts() {
        m_nShortcuts=0;
        Update();
    }



    // Miscellaneous
    // ---------------------

    bool MatchKey(const wxKeyEvent &ev) const {
        for (int i=0; i < m_nShortcuts; i++)
            if (m_keyShortcut[i].MatchKey(ev))
                return TRUE;
        return FALSE;
    }

    bool IsBindTo(const wxKeyBind &key, int *n = NULL) const {
        for (int i=0; i < m_nShortcuts; i++) {
            if (m_keyShortcut[i].Match(key)) {
                if (n) *n = i;
                return TRUE;
            }
        }
        return FALSE;
    }

    bool Save(wxConfigBase *p, const wxString &key = wxEmptyString, bool bCleanOld = FALSE) const;

    bool Load(wxConfigBase *p, const wxString &key = wxEmptyString);




    // Getters
    // ---------------------

    wxKeyBind *GetShortcut(int n)                { return &m_keyShortcut[n]; }
    const wxKeyBind *GetShortcut(int n) const    { return &m_keyShortcut[n]; }

    wxAcceleratorEntry GetAccelerator(int n) const {
        return GetShortcut(n)->GetAccelerator(m_nId);
    }

    int GetId() const {
        return m_nId;
    }

    int GetShortcutCount() const {
        return m_nShortcuts;
    }

    wxString GetDescription() const {
        return m_strDescription;
    }

    wxString GetName() const {
        return m_strName;
    }

    wxArrayString GetShortcutsList() const {
        wxArrayString arr;
        for (int i=0; i < m_nShortcuts; i++)
            arr.Add(m_keyShortcut[i].GetStr());
        return arr;
    }

    virtual int GetType() const = 0;


protected:

    virtual void Update() {}

    virtual void Exec(wxObject *obj, wxEvtHandler *client) = 0;
};




class WXDLLIMPEXP_KEYBINDER wxCmdArray
{
    wxArrayPtrVoid m_arr;

public:
    wxCmdArray() {}
    wxCmdArray(const wxCmdArray &tocopy) { DeepCopy(tocopy); }
    virtual ~wxCmdArray() { Clear(); }

    void DeepCopy(const wxCmdArray &arr) {
        Clear();
        for (int i=0; i < arr.GetCount(); i++)
            Add(arr.Item(i)->Clone());
    }

    wxCmdArray &operator=(const wxCmdArray &tocopy) {
        DeepCopy(tocopy);
        return *this;
    }

    void Add(wxCmd *p)          { m_arr.Add(p); }
    void Remove(int n);
    void Clear();

    int GetCount() const        { return m_arr.GetCount(); }
    wxCmd *Item(int n) const    { return (wxCmd *)m_arr.Item(n); }
};




class WXDLLIMPEXP_KEYBINDER wxBinderEvtHandler : public wxEvtHandler
{
    wxKeyBinder *m_pBinder;

    wxWindow *m_pTarget;

protected:

    void OnChar(wxKeyEvent &event);

public:

    wxBinderEvtHandler(wxKeyBinder *p, wxWindow *tg)
        : m_pBinder(p), m_pTarget(tg) { m_pTarget->PushEventHandler(this); }

    virtual ~wxBinderEvtHandler()
        { m_pTarget->RemoveEventHandler(this); }


    bool IsAttachedTo(wxWindow *p)
        { return p == m_pTarget; }

    wxKeyBinder *GetBinder() const
        { return m_pBinder; }

    wxWindow *GetTargetWnd() const
        { return m_pTarget; }

private:
    DECLARE_CLASS(wxBinderEvtHandler)
    DECLARE_EVENT_TABLE()
};




// Define the wxADD_KEYBINDER_SUPPORT: you should use it inside a protected
// block of the windows which want to use the wxKeyBinder facilities
#ifdef __WXMSW__

    // This is a virtual function used in wxMSW which can be used to allow
    // or disable the message preprocessing and thus the preprocessing of
    // keyshortcuts; to add keybinder support, the preprocessing must be
    // disabled: wxKeyBinder will care of checking the keypresses for
    // eventual hotkeys...
    #define wxADD_KEYBINDER_SUPPORT()                                       \
        virtual bool MSWShouldPreProcessMessage(WXMSG*) { return FALSE; }
#else

    // the other ports doesn't use MSWShouldPreProcessMessage...
    #define wxADD_KEYBINDER_SUPPORT()           /* expand to nothing */

#endif


class WXDLLIMPEXP_KEYBINDER wxBinderApp : public wxApp
{
    wxKeyBinder *m_pGlobalBinder;
    wxEvtHandler *m_pGlobalHdl;

public:
    wxBinderApp() { m_pGlobalHdl = NULL; m_pGlobalBinder = NULL; }
    virtual ~wxBinderApp() {}


    int FilterEvent(wxEvent &ev);

    static bool IsChildOf(wxWindow *parent, wxWindow *child);

    static wxWindow *GetTopLevelParent(wxWindow *wnd);


public:     // accessors

    void SetGlobalBinder(wxKeyBinder *p)
        { m_pGlobalBinder = p; }
    void SetGlobalHandler(wxEvtHandler *p)
        { m_pGlobalHdl = p; }

    wxKeyBinder *GetGlobalBinder() const
        { return m_pGlobalBinder; }
    wxEvtHandler *GetGlobalHandler() const
        { return m_pGlobalHdl ; }
};



class WXDLLIMPEXP_KEYBINDER wxKeyBinder : public wxObject
{
protected:

    wxCmdArray m_arrCmd;

    //wxArrayPtrVoid m_arrAttachedWnd;
    //wxWindowList m_lstAttachedWnd;        // I don't like wxList...

    wxArrayPtrVoid m_arrHandlers;

protected:


    int FindCmd(int id) const {
        for (int i=0; i < (int)m_arrCmd.GetCount(); i++)
            if (id == m_arrCmd.Item(i)->GetId())
                return i;
        return -1;
    }

    int FindCmdBindTo(const wxKeyBind &key, int *n = NULL) const {
        for (int i=0; i < (int)m_arrCmd.GetCount(); i++)
            if (m_arrCmd.Item(i)->IsBindTo(key, n))
                return i;
        return -1;
    }

    int FindMatchingCmd(const wxKeyEvent &key) const {
        for (int i=0; i < (int)m_arrCmd.GetCount(); i++)
            if (m_arrCmd.Item(i)->MatchKey(key))
                return i;
        return -1;
    }


public:

    wxKeyBinder() {}
    wxKeyBinder(const wxKeyBinder &tocopy) { DeepCopy(tocopy); }
    virtual ~wxKeyBinder() { DetachAll(); }



public:     // miscellaneous

    void OnChar(wxKeyEvent &event, wxEvtHandler *next);

    void DeepCopy(const wxKeyBinder &p) {
        m_arrCmd.DeepCopy(p.m_arrCmd);

        // NEVER COPY THE ARRAY OF THE ATTACHED WINDOWs:
        // WE ARE NOT ATTACHED TO THE WINDOWS OF THE GIVEN BINDER !!
        // m_arrAttachedWnd = p->m_arrAttachedWnd;
    }

    wxKeyBinder &operator=(const wxKeyBinder &tocopy) {
        DeepCopy(tocopy);
        return *this;
    }

    void Reset() {
        m_arrCmd.Clear();
    }

    void UpdateAllCmd() {
        if (m_arrHandlers.GetCount() == 0)
            return;     // we are not attached to any window... we can skip
                        // this update...
        for (int i=0; i < (int)m_arrCmd.GetCount(); i++)
            m_arrCmd.Item(i)->Update();
    }

    void Enable(bool bEnable = TRUE) {
        for (int i=0; i < (int)m_arrHandlers.GetCount(); i++)
            ((wxBinderEvtHandler*)m_arrHandlers.Item(i))->SetEvtHandlerEnabled(bEnable);
    }

    void Attach(wxWindow *p);

    void AttachRecursively(wxWindow *p);

    void Detach(wxWindow *p);

    void DetachAll();

    bool IsAttachedTo(wxWindow *p) const
        { return FindHandlerIdxFor(p) != wxNOT_FOUND; }

    int FindHandlerIdxFor(wxWindow *p) const;

    wxBinderEvtHandler *FindHandlerFor(wxWindow *p) const;

    void ImportMenuBarCmd(wxMenuBar *p);

    bool Save(wxConfigBase *p, const wxString &key = wxEmptyString, bool bCleanOld = FALSE) const;

    bool Load(wxConfigBase *p, const wxString &key = wxEmptyString);



    // Add functions
    // -------------------

    void AddCmd(wxCmd *p) {
        m_arrCmd.Add(p);
    }

    void AddShortcut(int id, const wxString &key) {
        wxCmd *p = GetCmd(id);
        if (p) p->AddShortcut(key);
    }

    void AddShortcut(int id, const wxKeyBind &key) {
        wxCmd *p = GetCmd(id);
        if (p) p->AddShortcut(key);
    }



    // Getters
    // -------------------

    int GetCmdCount() const {
        return m_arrCmd.GetCount();
    }

    int GetAttachedWndCount() const {
        return m_arrHandlers.GetCount();
    }

    wxWindow *GetWindow(int n) const {
        return ((wxBinderEvtHandler*)m_arrHandlers.Item(n))->GetTargetWnd();
    }

    wxCmd *GetMatchingCmd(const wxKeyEvent &key) const {
        int i = FindMatchingCmd(key);
        if (i != -1)
            return m_arrCmd.Item(i);
        return NULL;
    }

    wxCmd *GetCmd(int id) const {
        int i = FindCmd(id);
        if (i != -1)
            return m_arrCmd.Item(i);
        return NULL;
    }

    wxCmd *GetCmdBindTo(const wxString &key, int *n = NULL) const {
        int i = FindCmdBindTo(wxKeyBind(key), n);
        if (i != -1)
            return m_arrCmd.Item(i);
        return NULL;
    }

    wxKeyBind *GetShortcut(int id, int n) const {
        wxCmd *p = GetCmd(id);
        if (p) return p->GetShortcut(n);
        return NULL;
    }

    wxString GetShortcutStr(int id, int n) const {
        wxKeyBind *p = GetShortcut(id, n);
        if (p) return p->GetStr();
        return wxEmptyString;
    }

    wxArrayString GetShortcutsList(int id) const {
        wxCmd *p = GetCmd(id);
        if (p) return p->GetShortcutsList();
        return wxArrayString();
    }

    wxArrayPtrVoid *GetHandlersArr()        { return &m_arrHandlers; }

    wxCmdArray *GetArray()                  { return &m_arrCmd; }
    const wxCmdArray *GetArray() const      { return &m_arrCmd; }


private:
    DECLARE_CLASS(wxKeyBinder)
};



class WXDLLIMPEXP_KEYBINDER wxKeyProfile : public wxKeyBinder
{
protected:

    wxString m_strName;

    wxString m_strDescription;

public:
    wxKeyProfile(const wxString &name = wxEmptyString,
                const wxString &desc = wxEmptyString)
        : m_strName(name), m_strDescription(desc) {}

    wxKeyProfile(const wxKeyProfile &tocopy)
        { DeepCopy(tocopy); }

    virtual ~wxKeyProfile() {}


    void DeepCopy(const wxKeyProfile &p) {
        wxKeyBinder::DeepCopy(p);
        m_strName = p.m_strName;
        m_strDescription = p.m_strDescription;
    }

    wxKeyProfile &operator=(const wxKeyProfile &tocopy) {
        DeepCopy(tocopy);
        return *this;
    }

public:     // miscellaneous

    void SetName(const wxString &name) { m_strName=name; }
    void SetDesc(const wxString &str)  { m_strDescription=str; }

    wxString GetName() const        { return m_strName; }
    wxString GetDesc() const        { return m_strDescription; }

    bool Save(wxConfigBase *p, const wxString &key = wxEmptyString, bool bCleanOld = FALSE) const;
    bool Load(wxConfigBase *p, const wxString &key = wxEmptyString);


private:
    DECLARE_CLASS(wxKeyProfile)
};




#define wxKEYPROFILE_CONFIG_PREFIX          wxT("keyprof")


class WXDLLIMPEXP_KEYBINDER wxKeyProfileArray
{
    wxArrayPtrVoid m_arr;

    int m_nSelected;

public:
    wxKeyProfileArray() { m_nSelected=-1; }
    wxKeyProfileArray(const wxKeyProfileArray &tocopy) { DeepCopy(tocopy); }
    virtual ~wxKeyProfileArray() { Cleanup(); }



    int GetCount() const            { return m_arr.GetCount(); }
    int GetSelProfileIdx() const    { return m_nSelected; }
    wxKeyProfile *Item(int n)       { return (wxKeyProfile*)m_arr.Item(n); }
    wxKeyProfile *GetSelProfile()   { wxASSERT(m_nSelected >= 0 && m_nSelected < GetCount()); return Item(m_nSelected); }
    void Add(wxKeyProfile *p)       { m_arr.Add(p); }
    void Clear()                    { m_arr.Clear(); }
    void Remove(wxKeyProfile *p)    { m_arr.Remove(p); }
    void SetSelProfile(int n)       { wxASSERT(n < GetCount()); m_nSelected = n; }
    bool IsEmpty() const            { return m_arr.IsEmpty(); }

    const wxKeyProfile *Item(int n) const           { return (wxKeyProfile*)m_arr.Item(n); }
    const wxKeyProfile *GetSelProfile() const       { return Item(m_nSelected); }
    void RemoveAt(size_t i, size_t count = 1)       { m_arr.RemoveAt(i, count); }
    void Insert(wxKeyProfile *p, int n)             { m_arr.Insert(p, n); }



    void DeepCopy(const wxKeyProfileArray &p) {
        Cleanup();
        for (int i=0; i < p.GetCount(); i++)
            Add(new wxKeyProfile(*p.Item(i)));
        m_nSelected = p.m_nSelected;
    }

    wxKeyProfileArray &operator=(const wxKeyProfileArray &tocopy) {
        DeepCopy(tocopy);
        return *this;
    }

    void Cleanup() {
        for (int i=0; i < GetCount(); i++)
            delete Item(i);
        Clear();
    }

    void AttachAllTo(wxWindow *w) {
        for (int i=0; i<GetCount(); i++)
            Item(i)->Attach(w);
    }

    void EnableAll(bool bEnable = TRUE) {
        for (int i=0; i<GetCount(); i++)
            Item(i)->Enable(bEnable);
    }

    void DetachAllFrom(wxWindow *w) {
        for (int i=0; i<GetCount(); i++)
            Item(i)->Detach(w);
    }

    void DetachAll() {
        for (int i=0; i<GetCount(); i++)
            Item(i)->DetachAll();
    }

    void UpdateAllCmd() {
        for (int i=0; i<GetCount(); i++)
            Item(i)->UpdateAllCmd();
    }

    bool Save(wxConfigBase *p, const wxString &key = wxEmptyString, bool bCleanOld = FALSE) const;

    bool Load(wxConfigBase *p, const wxString &key = wxEmptyString);
};






class WXDLLIMPEXP_KEYBINDER wxKeyMonitorTextCtrl : public wxTextCtrl
{
public:
    wxKeyMonitorTextCtrl(
        wxWindow* parent,
        wxWindowID id,
        const wxString& value = wxEmptyString,
        const wxPoint& pos = wxDefaultPosition,
        const wxSize& size = wxDefaultSize,
        long style = wxTE_PROCESS_ENTER,
        const wxValidator& validator = wxDefaultValidator,
        const wxString& name = wxTextCtrlNameStr) :
        wxTextCtrl(parent, id, value, pos, size, style, validator, name) {}

    virtual ~wxKeyMonitorTextCtrl() {}

public:

    void OnKey(wxKeyEvent &);

    bool IsValidKeyComb() const {
        return !GetValue().IsEmpty() && GetValue().Last() != '+';
    }

private:
    DECLARE_CLASS(wxKeyMonitorTextCtrl)
    DECLARE_EVENT_TABLE()
};






// IDs used by wxKeyConfigPanel
#define wxKEYBINDER_BASEID                  30000       // start from this value

#define wxKEYBINDER_COMMANDS_BOX_ID         wxKEYBINDER_BASEID+1
#define wxKEYBINDER_BINDINGS_BOX_ID         wxKEYBINDER_BASEID+2
#define wxKEYBINDER_KEY_FIELD_ID            wxKEYBINDER_BASEID+3
#define wxKEYBINDER_ASSIGN_KEY_ID           wxKEYBINDER_BASEID+4
#define wxKEYBINDER_REMOVE_KEY_ID           wxKEYBINDER_BASEID+5
#define wxKEYBINDER_REMOVEALL_KEY_ID        wxKEYBINDER_BASEID+6
#define wxKEYBINDER_KEYPROFILES_ID          wxKEYBINDER_BASEID+7
#define wxKEYBINDER_CATEGORIES_ID           wxKEYBINDER_BASEID+8
#define wxKEYBINDER_ADD_PROFILEBTN_ID       wxKEYBINDER_BASEID+9
#define wxKEYBINDER_REMOVE_PROFILEBTN_ID    wxKEYBINDER_BASEID+10


#define wxKEYBINDER_SELECTED_POSTFIX        wxT(" (selected)")



#define wxKEYBINDER_USE_TREECTRL                1

#define wxKEYBINDER_USE_LISTBOX                 2

#define wxKEYBINDER_SHOW_APPLYBUTTON            4

#define wxKEYBINDER_SHOW_ADDREMOVE_PROFILE      8

#define wxKEYBINDER_ENABLE_PROFILE_EDITING      16

#define wxKEYBINDER_DEFAULT_STYLE                                               \
        (wxKEYBINDER_SHOW_APPLYBUTTON|wxKEYBINDER_USE_TREECTRL|                 \
         wxKEYBINDER_SHOW_ADDREMOVE_PROFILE|wxKEYBINDER_ENABLE_PROFILE_EDITING| \
         wxTAB_TRAVERSAL)   /* wxTAB_TRAVERSAL is the default style for a wxPanel */



class WXDLLIMPEXP_KEYBINDER wxKeyConfigPanel : public wxPanel
{
public:

    wxKeyConfigPanel(wxWindow* parent,
                     wxWindowID id = -1,
                     const wxPoint& pos = wxDefaultPosition,
                     const wxSize& size = wxDefaultSize,
                     long style = wxKEYBINDER_DEFAULT_STYLE,
                     const wxString& name = wxT("wxKeyConfigPanel"))
    {
        Create(parent, id, pos, size, style, name);
    }

    bool Create(wxWindow* parent,
                wxWindowID id = -1,
                const wxPoint& pos = wxDefaultPosition,
                const wxSize& size = wxDefaultSize,
                long style = wxKEYBINDER_DEFAULT_STYLE,
                const wxString& name = wxT("wxKeyConfigPanel"));

    virtual ~wxKeyConfigPanel();


public:     // import commands (to call BEFORE ShowModal):
            // they affect the tree control only

    virtual void ImportMenuBarCmd(wxMenuBar *menuitems,
                                const wxString &rootname = wxT("Menu bar"));

    virtual void ImportKeyProfileCmd(const wxKeyProfile &toimport,
                                const wxString &rootname = wxT("Commands"));


public:     // keyprofile utilities (to call BEFORE ShowModal):
            // they affect the keybindings only

    virtual void AddProfile(const wxKeyProfile &p);

    virtual void AddProfiles(const wxKeyProfileArray &arr);

    virtual void SetSelProfile(int n);


public:     // output-access utilities (to call AFTER ShowModal)

    wxKeyProfile *GetProfile(int n) const
        { wxASSERT(m_pKeyProfiles); return (wxKeyProfile *)m_pKeyProfiles->GetClientData(n); }

    wxKeyProfile *GetSelProfile() const
        { int n=GetSelProfileIdx(); return (n >= 0 ? GetProfile(n) : NULL); }

    int GetSelProfileIdx() const
        { wxASSERT(m_pKeyProfiles); return m_nCurrentProf; }

    wxKeyProfileArray GetProfiles() const;


public:     // miscellaneous

    virtual void ApplyChanges();

    void EnableKeyProfiles(bool bEnable = TRUE);

    void DisableKeyProfiles()
        { EnableKeyProfiles(FALSE); }


protected:      // event handlers

    void OnIdle(wxIdleEvent &event);

    void OnTreeCommandSelected(wxTreeEvent &event);
    void OnListCommandSelected(wxCommandEvent &event);

    void OnBindingSelected(wxCommandEvent &event);
    void OnProfileSelected(wxCommandEvent &event);
    void OnCategorySelected(wxCommandEvent &event);

    void OnProfileEditing(wxCommandEvent &event);
    void OnApplyChanges(wxCommandEvent &event);
    void OnAssignKey(wxCommandEvent &event);
    void OnRemoveKey(wxCommandEvent &event);
    void OnRemoveAllKey(wxCommandEvent &event);
    void OnAddProfile(wxCommandEvent &event);
    void OnRemoveProfile(wxCommandEvent &event);

    void OnKeyPressed(wxCommandEvent &event);


protected:      // build functions; these ones can be overridden to
                // customize wxKeyConfigPanel appearances

    virtual void BuildCtrls();
    virtual wxSizer *BuildColumn1();
    virtual wxSizer *BuildColumn2();
    virtual wxSizer *BuildMain(wxSizer *, wxSizer *, bool);


protected:      // utilities

    virtual void UpdateButtons();
    virtual void UpdateDesc();
    virtual void FillInBindings();
    virtual void Reset();
    virtual void AddRootIfMissing(const wxString &rootname);


    wxTreeItemId GetSelCmdId() const;

    wxControl *GetMainCtrl() const;

    bool IsUsingTreeCtrl() const
        { return HasFlag(wxKEYBINDER_USE_TREECTRL); }

    bool IsSelectedValidCmd() const;

    wxString GetSelCmdStr() const;

    wxCmd *GetSelCmd() const;

    virtual void ShowSizer(wxSizer *toshow, bool show);


protected:      // members

    bool m_bEnableKeyProfiles;

    wxCmd *m_pCurrCmd;

    wxKeyProfile m_kBinder;

    int m_nCurrentProf;

    bool m_bProfileHasBeenModified;

protected:      // the subwindows of this dialog

    wxKeyMonitorTextCtrl *m_pKeyField;

    wxButton *m_pAssignBtn;
    wxButton *m_pRemoveBtn;
    wxButton *m_pRemoveAllBtn;

    // used when wxKEYBINDER_USE_TREECTRL is in the build flags
    wxTreeCtrl *m_pCommandsTree;

    // used when wxKEYBINDER_USE_LISTBOX is in the build flags
    wxComboBox *m_pCategories;
    wxListBox *m_pCommandsList;

    wxListBox *m_pBindings;
    wxComboBox *m_pKeyProfiles;
    wxSizer *m_pKeyProfilesSizer;

#ifdef __WXGTK__
    // on wxGTK wxStaticText does not implement line wrapping
    // (which is required !!) so we will use a wxTextCtrl (on wxGTK)
    wxTextCtrl  *m_pDescLabel;
#else
    wxStaticText *m_pDescLabel;
#endif
    wxStaticText *m_pCurrCmdField;

private:
    DECLARE_CLASS(wxKeyConfigPanel)
    DECLARE_EVENT_TABLE()
};



#endif // __KEYBINDER_G__

---