- added ListBoxContents: based on std::list<std::string> and PyList with Strings
[enigma2.git] / lib / gui / elistboxcontent.cpp
1 #include <lib/gui/elistbox.h>
2 #include <lib/gui/elistboxcontent.h>
3 #include <Python.h>
4
5 /*
6     The basic idea is to have an interface which gives all relevant list
7     processing functions, and can be used by the listbox to browse trough
8     the list.
9     
10     The listbox directly uses the implemented cursor. It tries hard to avoid
11     iterating trough the (possibly very large) list, so it should be O(1),
12     i.e. the performance should not be influenced by the size of the list.
13     
14     The list interface knows how to draw the current entry to a specified 
15     offset. Different interfaces can be used to adapt different lists,
16     pre-filter lists on the fly etc.
17     
18                 cursorSave/Restore is used to avoid re-iterating the list on redraw.
19                 The current selection is always selected as cursor position, the
20     cursor is then positioned to the start, and then iterated. This gives
21     at most 2x m_items_per_page cursor movements per redraw, indepenent
22     of the size of the list.
23     
24     Although cursorSet is provided, it should be only used when there is no
25     other way, as it involves iterating trough the list.
26  */
27
28 iListboxContent::~iListboxContent()
29 {
30 }
31
32
33 DEFINE_REF(eListboxTestContent);
34
35 void eListboxTestContent::cursorHome()
36 {
37         m_cursor = 0;
38 }
39
40 void eListboxTestContent::cursorEnd()
41 {
42         m_cursor = size();
43 }
44
45 int eListboxTestContent::cursorMove(int count)
46 {
47         m_cursor += count;
48         
49         if (m_cursor < 0)
50                 cursorHome();
51         else if (m_cursor > size())
52                 cursorEnd();
53         return 0;
54 }
55
56 int eListboxTestContent::cursorValid()
57 {
58         return m_cursor < size();
59 }
60
61 int eListboxTestContent::cursorSet(int n)
62 {
63         m_cursor = n;
64         
65         if (m_cursor < 0)
66                 cursorHome();
67         else if (m_cursor > size())
68                 cursorEnd();
69         return 0;
70 }
71
72 int eListboxTestContent::cursorGet()
73 {
74         return m_cursor;
75 }
76
77 void eListboxTestContent::cursorSave()
78 {
79         m_saved_cursor = m_cursor;
80 }
81
82 void eListboxTestContent::cursorRestore()
83 {
84         m_cursor = m_saved_cursor;
85 }
86
87 int eListboxTestContent::size()
88 {
89         return 10;
90 }
91         
92 RESULT eListboxTestContent::connectItemChanged(const Slot0<void> &itemChanged, ePtr<eConnection> &connection)
93 {
94         return 0;
95 }
96
97 void eListboxTestContent::setSize(const eSize &size)
98 {
99         m_size = size;
100 }
101
102 void eListboxTestContent::paint(gPainter &painter, eWindowStyle &style, const ePoint &offset, int selected)
103 {
104         ePtr<gFont> fnt = new gFont("Arial", 14);
105         painter.clip(eRect(offset, m_size));
106         style.setStyle(painter, selected ? eWindowStyle::styleListboxSelected : eWindowStyle::styleListboxNormal);
107         painter.clear();
108
109         if (cursorValid())
110         {
111                 painter.setFont(fnt);
112                 char string[10];
113                 sprintf(string, "%d.)", m_cursor);
114                 
115                 ePoint text_offset = offset + (selected ? ePoint(2, 2) : ePoint(1, 1));
116                 
117                 painter.renderText(eRect(text_offset, m_size), string);
118                 
119                 if (selected)
120                         style.drawFrame(painter, eRect(offset, m_size), eWindowStyle::frameListboxEntry);
121         }
122         
123         painter.clippop();
124 }
125
126 //////////////////////////////////////
127
128 DEFINE_REF(eListboxStringContent);
129
130 eListboxStringContent::eListboxStringContent()
131 {
132         m_size = 0;
133         cursorHome();
134 }
135
136 void eListboxStringContent::cursorHome()
137 {
138         m_cursor = m_list.begin();
139         m_cursor_number = 0;
140 }
141
142 void eListboxStringContent::cursorEnd()
143 {
144         m_cursor = m_list.end();
145         m_cursor_number = m_size;
146 }
147
148 int eListboxStringContent::cursorMove(int count)
149 {
150         if (count > 0)
151         {
152                 while (count && (m_cursor != m_list.end()))
153                 {
154                         ++m_cursor;
155                         ++m_cursor_number;
156                         --count;
157                 }
158         } else if (count < 0)
159         {
160                 while (count && (m_cursor != m_list.begin()))
161                 {
162                         --m_cursor;
163                         --m_cursor_number;
164                         ++count;
165                 }
166         }
167         
168         return 0;
169 }
170
171 int eListboxStringContent::cursorValid()
172 {
173         return m_cursor != m_list.end();
174 }
175
176 int eListboxStringContent::cursorSet(int n)
177 {
178         cursorHome();
179         cursorMove(n);
180         
181         return 0;
182 }
183
184 int eListboxStringContent::cursorGet()
185 {
186         return m_cursor_number;
187 }
188
189 void eListboxStringContent::cursorSave()
190 {
191         m_saved_cursor = m_cursor;
192         m_saved_cursor_number = m_cursor_number;
193 }
194
195 void eListboxStringContent::cursorRestore()
196 {
197         m_cursor = m_saved_cursor;
198         m_cursor_number = m_saved_cursor_number;
199 }
200
201 int eListboxStringContent::size()
202 {
203         return m_size;
204 }
205         
206 RESULT eListboxStringContent::connectItemChanged(const Slot0<void> &itemChanged, ePtr<eConnection> &connection)
207 {
208         return 0;
209 }
210
211 void eListboxStringContent::setSize(const eSize &size)
212 {
213         m_itemsize = size;
214 }
215
216 void eListboxStringContent::paint(gPainter &painter, eWindowStyle &style, const ePoint &offset, int selected)
217 {
218         ePtr<gFont> fnt = new gFont("Arial", 14);
219         painter.clip(eRect(offset, m_itemsize));
220         style.setStyle(painter, selected ? eWindowStyle::styleListboxSelected : eWindowStyle::styleListboxNormal);
221         painter.clear();
222         
223         eDebug("item %d", m_cursor_number);
224         if (cursorValid())
225         {
226                 eDebug("is valid..");
227                 painter.setFont(fnt);
228                 
229                 ePoint text_offset = offset + (selected ? ePoint(2, 2) : ePoint(1, 1));
230                 
231                 painter.renderText(eRect(text_offset, m_itemsize), *m_cursor);
232                 
233                 if (selected)
234                         style.drawFrame(painter, eRect(offset, m_itemsize), eWindowStyle::frameListboxEntry);
235         }
236         
237         painter.clippop();
238 }
239
240 void eListboxStringContent::setList(std::list<std::string> &list)
241 {
242         m_list = list;
243         m_size = list.size();
244         cursorHome();
245 }
246
247 //////////////////////////////////////
248
249 DEFINE_REF(eListboxPythonStringContent);
250
251 eListboxPythonStringContent::eListboxPythonStringContent()
252 {
253         m_list = 0;
254 }
255
256 eListboxPythonStringContent::~eListboxPythonStringContent()
257 {
258 }
259
260 void eListboxPythonStringContent::cursorHome()
261 {
262         m_cursor = 0;
263 }
264
265 void eListboxPythonStringContent::cursorEnd()
266 {
267         m_cursor = size();
268 }
269
270 int eListboxPythonStringContent::cursorMove(int count)
271 {
272         m_cursor += count;
273         
274         if (m_cursor < 0)
275                 cursorHome();
276         else if (m_cursor > size())
277                 cursorEnd();
278         return 0;
279 }
280
281 int eListboxPythonStringContent::cursorValid()
282 {
283         return m_cursor < size();
284 }
285
286 int eListboxPythonStringContent::cursorSet(int n)
287 {
288         m_cursor = n;
289         
290         if (m_cursor < 0)
291                 cursorHome();
292         else if (m_cursor > size())
293                 cursorEnd();
294         return 0;
295 }
296
297 int eListboxPythonStringContent::cursorGet()
298 {
299         return m_cursor;
300 }
301
302 void eListboxPythonStringContent::cursorSave()
303 {
304         m_saved_cursor = m_cursor;
305 }
306
307 void eListboxPythonStringContent::cursorRestore()
308 {
309         m_cursor = m_saved_cursor;
310 }
311
312 int eListboxPythonStringContent::size()
313 {
314         if (!m_list)
315                 return 0;
316         return PyList_Size(m_list);
317 }
318         
319 RESULT eListboxPythonStringContent::connectItemChanged(const Slot0<void> &itemChanged, ePtr<eConnection> &connection)
320 {
321         return 0;
322 }
323
324 void eListboxPythonStringContent::setSize(const eSize &size)
325 {
326         m_itemsize = size;
327 }
328
329 void eListboxPythonStringContent::paint(gPainter &painter, eWindowStyle &style, const ePoint &offset, int selected)
330 {
331         ePtr<gFont> fnt = new gFont("Arial", 14);
332         painter.clip(eRect(offset, m_itemsize));
333         style.setStyle(painter, selected ? eWindowStyle::styleListboxSelected : eWindowStyle::styleListboxNormal);
334         painter.clear();
335
336         if (m_list && cursorValid())
337         {
338                 PyObject *item = PyList_GetItem(m_list, m_cursor); // borrowed reference!
339                 painter.setFont(fnt);
340                 
341                 const char *string = PyString_Check(item) ? PyString_AsString(item) : "<not-a-string>";
342                 
343                 ePoint text_offset = offset + (selected ? ePoint(2, 2) : ePoint(1, 1));
344                 
345                 painter.renderText(eRect(text_offset, m_itemsize), string);
346                 
347                 if (selected)
348                         style.drawFrame(painter, eRect(offset, m_itemsize), eWindowStyle::frameListboxEntry);
349         }
350         
351         painter.clippop();
352 }
353
354 void eListboxPythonStringContent::setList(PyObject *list)
355 {
356         Py_XDECREF(m_list);
357         if (!PyList_Check(list))
358         {
359                 m_list = 0;
360         } else
361         {
362                 m_list = list;
363                 Py_INCREF(m_list);
364         }
365 }
366
367 PyObject *eListboxPythonStringContent::getCurrentSelection()
368 {
369         if (!m_list)
370                 return 0;
371         if (!cursorValid())
372                 return 0;
373         PyObject *r = PyList_GetItem(m_list, m_cursor);
374         Py_XINCREF(r);
375         return r;
376 }
377
378 //////////////////////////////////////