X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fbindings.hh;h=f45e5ca3123672867eac66b914c0556e90a5fc01;hb=45f6d5271226813ac15ecd69118fe6a947996fb6;hp=ee1c7c665f8566c622ba28172ccc88ae13964e79;hpb=4721c53868187d10e3732cea63efa9fbd352178d;p=chaz%2Fopenbox diff --git a/src/bindings.hh b/src/bindings.hh index ee1c7c66..f45e5ca3 100644 --- a/src/bindings.hh +++ b/src/bindings.hh @@ -2,24 +2,58 @@ #ifndef __binding_hh #define __binding_hh -/*! @file binding.hh +/*! @file bindings.hh @brief I dunno.. some binding stuff? */ #include "actions.hh" +#include "python.hh" #include "otk/timer.hh" -extern "C" { -#include -} - #include #include #include namespace ob { -class OBClient; +class Client; + +struct MouseCallbackData { + MouseCallback callback; + void *data; + MouseCallbackData(MouseCallback c, void *d) : callback(c), data(d) {} + void fire(MouseData *d) { callback(d, data); } + bool operator==(const MouseCallbackData &other) { return (callback == + other.callback && + data == + other.data); } +}; + +struct KeyCallbackData { + KeyCallback callback; + void *data; + KeyCallbackData(KeyCallback c, void *d) : callback(c), data(d) {} + void fire(KeyData *d) { callback(d, data); } + bool operator==(const KeyCallbackData &other) { return (callback == + other.callback && + data == + other.data); } +}; + +struct EventCallbackData { + EventCallback callback; + void *data; + EventCallbackData(EventCallback c, void *d) : callback(c), data(d) {} + void fire(EventData *d) { callback(d, data); } + bool operator==(const EventCallbackData &other) { return (callback == + other.callback && + data == + other.data); } +}; + +typedef std::list MouseCallbackList; +typedef std::list KeyCallbackList; +typedef std::list EventCallbackList; typedef struct Binding { unsigned int modifiers; @@ -32,47 +66,64 @@ typedef struct Binding { Binding(unsigned int mod, unsigned int k) { modifiers = mod; key = k; } } Binding; -typedef struct BindingTree { +typedef struct KeyBindingTree { Binding binding; - PyObject *callback; // the callback given for the binding in add() + KeyCallbackList callbacks; // the callbacks given for the binding in add() bool chain; // true if this is a chain to another key (not an action) - struct BindingTree *next_sibling; // the next binding in the tree at the same + struct KeyBindingTree *next_sibling; // the next binding in the tree at the same // level - struct BindingTree *first_child; // the first child of this binding (next + struct KeyBindingTree *first_child; // the first child of this binding (next // binding in a chained sequence). - BindingTree(PyObject *callback) : binding(0, 0) { - this->callback = callback; chain = true; next_sibling = first_child = 0; + KeyBindingTree() : binding(0, 0) { + chain = true; next_sibling = first_child = 0; } - BindingTree() : binding(0, 0) { - this->callback = 0; chain = true; next_sibling = first_child = 0; - } -} BindingTree; +} KeyBindingTree; + +typedef struct ButtonBinding { + Binding binding; + MouseCallbackList callbacks[MouseAction::NUM_MOUSE_ACTION]; + ButtonBinding() : binding(0, 0) {} +}; -class OBBindings { +class Bindings { public: //! A list of strings typedef std::vector StringVect; private: - BindingTree _tree; // root node of the tree (this doesn't have siblings!) - BindingTree *_curpos; // position in the keytree + // root node of the tree (this doesn't have siblings!) + KeyBindingTree _keytree; + KeyBindingTree *_curpos; // position in the keytree Binding _resetkey; // the key which resets the key chain status - otk::OBTimer _timer; + otk::Timer *_timer; - PyObject *find(BindingTree *search, bool *conflict) const; - BindingTree *buildtree(const StringVect &keylist, PyObject *callback) const; - void assimilate(BindingTree *node); + KeyBindingTree *find(KeyBindingTree *search, bool *conflict) const; + KeyBindingTree *buildtree(const StringVect &keylist, + KeyCallback callback, void *data) const; + void assimilate(KeyBindingTree *node); + + static void resetChains(Bindings *self); // the timer's timeout function + + typedef std::list ButtonBindingList; + ButtonBindingList _buttons[MouseContext::NUM_MOUSE_CONTEXT]; + + void grabButton(bool grab, const Binding &b, MouseContext::MC context, + Client *client); - static void reset(OBBindings *self); // the timer's timeout function + EventCallbackList _eventlist[EventAction::NUM_EVENT_ACTION]; + + KeyCallbackData _keybgrab_callback; + + bool _grabbed; public: - //! Initializes an OBBindings object - OBBindings(); - //! Destroys the OBBindings object - virtual ~OBBindings(); + //! Initializes an Bindings object + Bindings(); + //! Destroys the Bindings object + virtual ~Bindings(); //! Translates a binding string into the actual Binding bool translate(const std::string &str, Binding &b, bool askey = true) const; @@ -83,23 +134,51 @@ public: a chain or not), or if any of the strings in the keylist are invalid. @return true if the binding could be added; false if it could not. */ - bool add(const StringVect &keylist, PyObject *callback); + bool addKey(const StringVect &keylist, KeyCallback callback, void *data); - //! Removes a key binding - /*! - @return The callbackid of the binding, or '< 0' if there was no binding to - be removed. - */ - bool remove(const StringVect &keylist); + ////! Removes a key binding + ///*! + // @return The callbackid of the binding, or '< 0' if there was no binding to + // be removed. + //*/ + //bool removeKey(const StringVect &keylist, KeyCallback callback, void *data); //! Removes all key bindings - void removeAll(); + void removeAllKeys(); - void fire(unsigned int modifiers,unsigned int key, Time time); + void fireKey(int screen, unsigned int modifiers,unsigned int key, Time time, + KeyAction::KA action); void setResetKey(const std::string &key); void grabKeys(bool grab); + + bool grabKeyboard(int screen, KeyCallback callback, void *data); + void ungrabKeyboard(); + + bool grabPointer(int screen); + void ungrabPointer(); + + bool addButton(const std::string &but, MouseContext::MC context, + MouseAction::MA action, MouseCallback callback, void *data); + + void grabButtons(bool grab, Client *client); + + //! Removes all button bindings + void removeAllButtons(); + + void fireButton(MouseData *data); + + //! Bind a callback for an event + bool addEvent(EventAction::EA action, EventCallback callback, void *data); + + //! Unbind the callback function from an event + bool removeEvent(EventAction::EA action, EventCallback callback, void *data); + + //! Remove all callback functions + void removeAllEvents(); + + void fireEvent(EventData *data); }; }