small cleanuo
[enigma2.git] / lib / actions / action.cpp
1 #include <lib/actions/action.h>
2 #include <lib/base/init.h>
3 #include <lib/base/init_num.h>
4 #include <lib/actions/actionids.h>
5
6 /*
7
8   THIS CODE SUCKS.
9
10 we need:
11  - contexts that aren't compared as strings,
12  - maybe a lookup "device,key,flags" -> actions? (lazy validation, on bindAction)
13  - devices as ids
14  - seperate native from python keys? (currently, if an action wasn't found, it's ignored.)
15  
16 Sorry. I spent 3 days on thinking how this could be made better, and it just DID NOT WORKED OUT.
17
18 If you have a better idea, please tell me.
19
20  */
21
22 DEFINE_REF(eActionMap);
23
24 eActionMap *eActionMap::instance;
25
26 eActionMap::eActionMap()
27 {
28         instance = this;
29 }
30
31 eActionMap::~eActionMap()
32 {
33         instance = 0;
34 }
35
36 RESULT eActionMap::getInstance(ePtr<eActionMap> &ptr)
37 {
38         ptr = instance;
39         if (!ptr)
40                 return -1;
41         return 0;
42 }
43
44 void eActionMap::bindAction(const std::string &context, int priority, int id, eWidget *widget)
45 {
46         eActionBinding bnd;
47         
48         bnd.m_context = context;
49         bnd.m_widget = widget;
50         bnd.m_id = id;
51         m_bindings.insert(std::pair<int,eActionBinding>(priority, bnd));
52 }
53
54 void eActionMap::bindAction(const std::string &context, int priority, ePyObject function)
55 {
56         eActionBinding bnd;
57         
58         bnd.m_context = context;
59         bnd.m_widget = 0;
60         Py_INCREF(function);
61         bnd.m_fnc = function;
62         m_bindings.insert(std::pair<int,eActionBinding>(priority, bnd));
63 }
64
65 void eActionMap::unbindAction(eWidget *widget, int id)
66 {
67         for (std::multimap<int, eActionBinding>::iterator i(m_bindings.begin()); i != m_bindings.end(); ++i)
68                 if ((i->second.m_widget == widget) && (i->second.m_id == id))
69                 {
70                         m_bindings.erase(i);
71                         return;
72                 }
73 }
74
75 void eActionMap::unbindAction(const std::string &context, ePyObject function)
76 {
77         for (std::multimap<int, eActionBinding>::iterator i(m_bindings.begin()); i != m_bindings.end(); ++i)
78         {
79                 if (i->second.m_fnc && (PyObject_Compare(i->second.m_fnc, function) == 0))
80                 {
81                         Py_DECREF(i->second.m_fnc);
82                         m_bindings.erase(i);
83                         return;
84                 }
85         }
86         eFatal("unbindAction with illegal python reference");
87 }
88
89
90 void eActionMap::bindKey(const std::string &device, int key, int flags, const std::string &context, const std::string &action)
91 {
92                 // first, search the actionlist table
93         unsigned int i;
94         for (i=0; i<sizeof(actions)/sizeof(*actions); ++i)
95         {
96                 if ((actions[i].m_context == context) && (actions[i].m_action == action))
97                 {
98                                 // we found a native action.
99                         eNativeKeyBinding bind;
100                         bind.m_device = device;
101                         bind.m_key = key;
102                         bind.m_flags = flags;
103                         bind.m_action = actions[i].m_id;
104                         m_native_keys.insert(std::pair<std::string,eNativeKeyBinding>(context, bind));
105                         return;
106                 }
107         }
108         
109                 // we didn't find the action, so it must be a pythonAction
110         ePythonKeyBinding bind;
111
112         bind.m_device = device;
113         bind.m_key = key;
114         bind.m_flags = flags;
115         bind.m_action = action;
116         m_python_keys.insert(std::pair<std::string,ePythonKeyBinding>(context, bind));
117 }
118
119 struct call_entry
120 {
121         ePyObject m_fnc, m_arg;
122         eWidget *m_widget;
123         void *m_widget_arg, *m_widget_arg2;
124         call_entry(ePyObject fnc, ePyObject arg): m_fnc(fnc), m_arg(arg), m_widget(0), m_widget_arg(0) { }
125         call_entry(eWidget *widget, void *arg, void *arg2): m_widget(widget), m_widget_arg(arg), m_widget_arg2(arg2) { }
126 };
127
128 void eActionMap::keyPressed(const std::string &device, int key, int flags)
129 {
130         std::list<call_entry> call_list;
131         
132                 /* iterate active contexts. */
133         for (std::multimap<int,eActionBinding>::const_iterator c(m_bindings.begin());
134                 c != m_bindings.end(); ++c)
135         {
136                         /* is this a native context? */
137                 if (c->second.m_widget)
138                 {
139                                 /* is this a named context, i.e. not the wildcard? */
140                         if (c->second.m_context.size())
141                         {
142                                 std::multimap<std::string,eNativeKeyBinding>::const_iterator
143                                         k = m_native_keys.lower_bound(c->second.m_context),
144                                         e = m_native_keys.upper_bound(c->second.m_context);
145
146                                 for (; k != e; ++k)
147                                 {
148                                         if (
149                                                         (k->second.m_key == key) &&
150                                                         (k->second.m_flags & (1<<flags)) &&
151                                                   ((k->second.m_device == device) || (k->second.m_device == "generic"))
152                                                   )
153                                                 call_list.push_back(call_entry(c->second.m_widget, (void*)c->second.m_id, (void*)k->second.m_action));
154                                 }
155                         } else
156                         {
157                                         /* wildcard - get any keys. */
158                                 if (c->second.m_widget->event(eWidget::evtKey, (void*)key, (void*)flags))
159                                         return;
160                         }
161                 } else if (c->second.m_fnc)
162                 {
163                         if (c->second.m_context.size())
164                         {
165                                 std::multimap<std::string,ePythonKeyBinding>::const_iterator
166                                         k = m_python_keys.lower_bound(c->second.m_context),
167                                         e = m_python_keys.upper_bound(c->second.m_context);
168
169                                 for (; k != e; ++k)
170                                 {
171                                         if (
172                                                 (k->second.m_key == key) &&
173                                                 (k->second.m_flags & (1<<flags)) &&
174                                                 ((k->second.m_device == device) || (k->second.m_device == "generic"))
175                                                 )
176                                         {
177                                                 ePyObject pArgs = PyTuple_New(2);
178                                                 PyTuple_SET_ITEM(pArgs, 0, PyString_FromString(k->first.c_str()));
179                                                 PyTuple_SET_ITEM(pArgs, 1, PyString_FromString(k->second.m_action.c_str()));
180                                                 Py_INCREF(c->second.m_fnc);
181                                                 call_list.push_back(call_entry(c->second.m_fnc, pArgs));
182                                         }
183                                 }
184                         } else
185                         {
186                                 eDebug("wildcard.");
187                                 ePyObject pArgs = PyTuple_New(2);
188                                 PyTuple_SET_ITEM(pArgs, 0, PyInt_FromLong(key));
189                                 PyTuple_SET_ITEM(pArgs, 1, PyInt_FromLong(flags));
190                                 Py_INCREF(c->second.m_fnc);
191                                 call_list.push_back(call_entry(c->second.m_fnc, pArgs));
192                         }
193                 }
194         }
195
196         int res = 0;
197                         /* we need to iterate over all to not loose a reference */
198         for (std::list<call_entry>::iterator i(call_list.begin()); i != call_list.end(); ++i)
199         {
200                 if (i->m_fnc)
201                 {
202                         if (!res)
203                                 res = ePython::call(i->m_fnc, i->m_arg);
204                         Py_DECREF(i->m_fnc);
205                         Py_DECREF(i->m_arg);
206                 } else if (i->m_widget && !res)
207                         res = i->m_widget->event(eWidget::evtAction, (void*)i->m_widget_arg, (void*)i->m_widget_arg2 );
208         }
209 }
210
211 ePtr<eActionMap> NewActionMapPtr(void)
212 {
213         ePtr<eActionMap> ptr;
214         eActionMap::getInstance(ptr);
215         return ptr;
216 }
217
218 eAutoInitPtr<eActionMap> init_eActionMap(eAutoInitNumbers::actions, "eActionMap");