action.cpp: remove debug info
[enigma2.git] / lib / actions / action.cpp
index 25db199..a2d85ff 100644 (file)
@@ -2,6 +2,7 @@
 #include <lib/base/init.h>
 #include <lib/base/init_num.h>
 #include <lib/actions/actionids.h>
 #include <lib/base/init.h>
 #include <lib/base/init_num.h>
 #include <lib/actions/actionids.h>
+#include <lib/driver/rc.h>
 
 /*
 
 
 /*
 
@@ -41,25 +42,17 @@ RESULT eActionMap::getInstance(ePtr<eActionMap> &ptr)
        return 0;
 }
 
        return 0;
 }
 
-#if 0
-void eActionMap::getInstance(eActionMap **ptr)
-{
-       *ptr = instance;
-}
-#endif
-
 void eActionMap::bindAction(const std::string &context, int priority, int id, eWidget *widget)
 {
        eActionBinding bnd;
        
        bnd.m_context = context;
        bnd.m_widget = widget;
 void eActionMap::bindAction(const std::string &context, int priority, int id, eWidget *widget)
 {
        eActionBinding bnd;
        
        bnd.m_context = context;
        bnd.m_widget = widget;
-       bnd.m_fnc = 0;
        bnd.m_id = id;
        m_bindings.insert(std::pair<int,eActionBinding>(priority, bnd));
 }
 
        bnd.m_id = id;
        m_bindings.insert(std::pair<int,eActionBinding>(priority, bnd));
 }
 
-void eActionMap::bindAction(const std::string &context, int priority, PyObject *function)
+void eActionMap::bindAction(const std::string &context, int priority, ePyObject function)
 {
        eActionBinding bnd;
        
 {
        eActionBinding bnd;
        
@@ -80,7 +73,7 @@ void eActionMap::unbindAction(eWidget *widget, int id)
                }
 }
 
                }
 }
 
-void eActionMap::unbindAction(const std::string &context, PyObject *function)
+void eActionMap::unbindAction(const std::string &context, ePyObject function)
 {
        for (std::multimap<int, eActionBinding>::iterator i(m_bindings.begin()); i != m_bindings.end(); ++i)
        {
 {
        for (std::multimap<int, eActionBinding>::iterator i(m_bindings.begin()); i != m_bindings.end(); ++i)
        {
@@ -95,7 +88,7 @@ void eActionMap::unbindAction(const std::string &context, PyObject *function)
 }
 
 
 }
 
 
-void eActionMap::bindKey(const std::string &device, int key, int flags, const std::string &context, const std::string &action)
+void eActionMap::bindKey(const std::string &domain, const std::string &device, int key, int flags, const std::string &context, const std::string &action)
 {
                // first, search the actionlist table
        unsigned int i;
 {
                // first, search the actionlist table
        unsigned int i;
@@ -105,10 +98,11 @@ void eActionMap::bindKey(const std::string &device, int key, int flags, const st
                {
                                // we found a native action.
                        eNativeKeyBinding bind;
                {
                                // we found a native action.
                        eNativeKeyBinding bind;
-                       bind.m_device = 0;
+                       bind.m_device = device;
                        bind.m_key = key;
                        bind.m_flags = flags;
                        bind.m_action = actions[i].m_id;
                        bind.m_key = key;
                        bind.m_flags = flags;
                        bind.m_action = actions[i].m_id;
+                       bind.m_domain = domain;
                        m_native_keys.insert(std::pair<std::string,eNativeKeyBinding>(context, bind));
                        return;
                }
                        m_native_keys.insert(std::pair<std::string,eNativeKeyBinding>(context, bind));
                        return;
                }
@@ -117,81 +111,133 @@ void eActionMap::bindKey(const std::string &device, int key, int flags, const st
                // we didn't find the action, so it must be a pythonAction
        ePythonKeyBinding bind;
 
                // we didn't find the action, so it must be a pythonAction
        ePythonKeyBinding bind;
 
-       bind.m_device = 0;
+       bind.m_device = device;
        bind.m_key = key;
        bind.m_flags = flags;
        bind.m_action = action;
        bind.m_key = key;
        bind.m_flags = flags;
        bind.m_action = action;
+       bind.m_domain = domain;
        m_python_keys.insert(std::pair<std::string,ePythonKeyBinding>(context, bind));
 }
 
        m_python_keys.insert(std::pair<std::string,ePythonKeyBinding>(context, bind));
 }
 
-void eActionMap::keyPressed(int device, int key, int flags)
+void eActionMap::unbindKeyDomain(const std::string &domain)
+{
+       for (std::multimap<std::string, eNativeKeyBinding>::iterator i(m_native_keys.begin()); i != m_native_keys.end(); ++i)
+               if (i->second.m_domain == domain)
+               {
+                       m_native_keys.erase(i);
+                       i = m_native_keys.begin();
+               }
+
+       for (std::multimap<std::string, ePythonKeyBinding>::iterator i(m_python_keys.begin()); i != m_python_keys.end(); ++i)
+               if (i->second.m_domain == domain)
+               {
+                       m_python_keys.erase(i);
+                       i = m_python_keys.begin();
+               }
+}
+
+struct call_entry
 {
 {
+       ePyObject m_fnc, m_arg;
+       eWidget *m_widget;
+       void *m_widget_arg, *m_widget_arg2;
+       call_entry(ePyObject fnc, ePyObject arg): m_fnc(fnc), m_arg(arg), m_widget(0), m_widget_arg(0) { }
+       call_entry(eWidget *widget, void *arg, void *arg2): m_widget(widget), m_widget_arg(arg), m_widget_arg2(arg2) { }
+};
+
+void eActionMap::keyPressed(const std::string &device, int key, int flags)
+{
+       std::list<call_entry> call_list;
+       
                /* iterate active contexts. */
                /* iterate active contexts. */
-       for (std::multimap<int,eActionBinding>::const_iterator c(m_bindings.begin()); c != m_bindings.end();)
+       for (std::multimap<int,eActionBinding>::iterator c(m_bindings.begin());
+               c != m_bindings.end(); ++c)
        {
        {
-               std::multimap<int,eActionBinding>::const_iterator i = c;
-               ++c;
+               if (flags == eRCKey::flagMake)
+                       c->second.m_prev_seen_make_key = key;
+               else if (c->second.m_prev_seen_make_key != key)  // ignore repeat or break when the make code for this key was not visible
+                       continue;
+
                        /* is this a native context? */
                        /* is this a native context? */
-               if (i->second.m_widget)
+               if (c->second.m_widget)
                {
                                /* is this a named context, i.e. not the wildcard? */
                {
                                /* is this a named context, i.e. not the wildcard? */
-                       if (i->second.m_context.size())
+                       if (c->second.m_context.size())
                        {
                                std::multimap<std::string,eNativeKeyBinding>::const_iterator
                        {
                                std::multimap<std::string,eNativeKeyBinding>::const_iterator
-                                       k = m_native_keys.lower_bound(i->second.m_context),
-                                       e = m_native_keys.upper_bound(i->second.m_context);
-                               
+                                       k = m_native_keys.lower_bound(c->second.m_context),
+                                       e = m_native_keys.upper_bound(c->second.m_context);
+
                                for (; k != e; ++k)
                                {
                                        if (
                                for (; k != e; ++k)
                                {
                                        if (
-                                               // (k->second.m_device == m_device) &&
-                                               (k->second.m_key == key) &&
-                                               (k->second.m_flags & (1<<flags)))
-                                       {
-                                               if (i->second.m_widget->event(eWidget::evtAction, 0, (void*)k->second.m_action))
-                                                       return;
-                                       }
+                                                       (k->second.m_key == key) &&
+                                                       (k->second.m_flags & (1<<flags)) &&
+                                                 ((k->second.m_device == device) || (k->second.m_device == "generic"))
+                                                 )
+                                               call_list.push_back(call_entry(c->second.m_widget, (void*)c->second.m_id, (void*)k->second.m_action));
                                }
                        } else
                        {
                                        /* wildcard - get any keys. */
                                }
                        } else
                        {
                                        /* wildcard - get any keys. */
-                               if (i->second.m_widget->event(eWidget::evtKey, (void*)key, (void*)flags))
+                               if (c->second.m_widget->event(eWidget::evtKey, (void*)key, (void*)flags))
                                        return;
                        }
                                        return;
                        }
-               } else if (i->second.m_fnc)
+               } else if (c->second.m_fnc)
                {
                {
-                       if (i->second.m_context.size())
+                       if (c->second.m_context.size())
                        {
                                std::multimap<std::string,ePythonKeyBinding>::const_iterator
                        {
                                std::multimap<std::string,ePythonKeyBinding>::const_iterator
-                                       k = m_python_keys.lower_bound(i->second.m_context),
-                                       e = m_python_keys.upper_bound(i->second.m_context);
-                               
-                               for (; k != e;)
+                                       k = m_python_keys.lower_bound(c->second.m_context),
+                                       e = m_python_keys.upper_bound(c->second.m_context);
+
+                               for (; k != e; ++k)
                                {
                                        if (
                                {
                                        if (
-                                               // (k->second.m_device == m_device) &&
                                                (k->second.m_key == key) &&
                                                (k->second.m_key == key) &&
-                                               (k->second.m_flags & (1<<flags)))
+                                               (k->second.m_flags & (1<<flags)) &&
+                                               ((k->second.m_device == device) || (k->second.m_device == "generic"))
+                                               )
                                        {
                                        {
-                                               PyObject *pArgs = PyTuple_New(2);
-                                               PyTuple_SetItem(pArgs, 0, PyString_FromString(k->first.c_str()));
-                                               PyTuple_SetItem(pArgs, 1, PyString_FromString(k->second.m_action.c_str()));
-                                               ++k;
-                                               ePython::call(i->second.m_fnc, pArgs);
-                                               Py_DECREF(pArgs);
-                                       } else
-                                               ++k;
+                                               ePyObject pArgs = PyTuple_New(2);
+                                               PyTuple_SET_ITEM(pArgs, 0, PyString_FromString(k->first.c_str()));
+                                               PyTuple_SET_ITEM(pArgs, 1, PyString_FromString(k->second.m_action.c_str()));
+                                               Py_INCREF(c->second.m_fnc);
+                                               call_list.push_back(call_entry(c->second.m_fnc, pArgs));
+                                       }
                                }
                        } else
                        {
                                }
                        } else
                        {
-                               PyObject *pArgs = PyTuple_New(2);
-                               PyTuple_SetItem(pArgs, 0, PyInt_FromLong(key));
-                               PyTuple_SetItem(pArgs, 1, PyInt_FromLong(flags));
-                               ePython::call(i->second.m_fnc, pArgs);
-                               Py_DECREF(pArgs);
+//                             eDebug("wildcard.");
+                               ePyObject pArgs = PyTuple_New(2);
+                               PyTuple_SET_ITEM(pArgs, 0, PyInt_FromLong(key));
+                               PyTuple_SET_ITEM(pArgs, 1, PyInt_FromLong(flags));
+                               Py_INCREF(c->second.m_fnc);
+                               call_list.push_back(call_entry(c->second.m_fnc, pArgs));
                        }
                }
        }
                        }
                }
        }
+
+       int res = 0;
+                       /* we need to iterate over all to not loose a reference */
+       for (std::list<call_entry>::iterator i(call_list.begin()); i != call_list.end(); ++i)
+       {
+               if (i->m_fnc)
+               {
+                       if (!res)
+                               res = ePython::call(i->m_fnc, i->m_arg);
+                       Py_DECREF(i->m_fnc);
+                       Py_DECREF(i->m_arg);
+               } else if (i->m_widget && !res)
+                       res = i->m_widget->event(eWidget::evtAction, (void*)i->m_widget_arg, (void*)i->m_widget_arg2 );
+       }
+}
+
+ePtr<eActionMap> NewActionMapPtr(void)
+{
+       ePtr<eActionMap> ptr;
+       eActionMap::getInstance(ptr);
+       return ptr;
 }
 
 eAutoInitPtr<eActionMap> init_eActionMap(eAutoInitNumbers::actions, "eActionMap");
 }
 
 eAutoInitPtr<eActionMap> init_eActionMap(eAutoInitNumbers::actions, "eActionMap");