1391a2b56f2e44a320c12caac075b7216bfd7d8a
[enigma2.git] / lib / gui / elistboxcontent.cpp
1 #include <lib/gui/elistbox.h>
2 #include <lib/gui/elistboxcontent.h>
3 #include <lib/gdi/font.h>
4 #include <Python.h>
5
6 /*
7     The basic idea is to have an interface which gives all relevant list
8     processing functions, and can be used by the listbox to browse trough
9     the list.
10     
11     The listbox directly uses the implemented cursor. It tries hard to avoid
12     iterating trough the (possibly very large) list, so it should be O(1),
13     i.e. the performance should not be influenced by the size of the list.
14     
15     The list interface knows how to draw the current entry to a specified 
16     offset. Different interfaces can be used to adapt different lists,
17     pre-filter lists on the fly etc.
18     
19                 cursorSave/Restore is used to avoid re-iterating the list on redraw.
20                 The current selection is always selected as cursor position, the
21     cursor is then positioned to the start, and then iterated. This gives
22     at most 2x m_items_per_page cursor movements per redraw, indepenent
23     of the size of the list.
24     
25     Although cursorSet is provided, it should be only used when there is no
26     other way, as it involves iterating trough the list.
27  */
28
29 iListboxContent::~iListboxContent()
30 {
31 }
32
33 iListboxContent::iListboxContent(): m_listbox(0)
34 {
35 }
36
37 void iListboxContent::setListbox(eListbox *lb)
38 {
39         m_listbox = lb;
40 }
41
42 DEFINE_REF(eListboxTestContent);
43
44 void eListboxTestContent::cursorHome()
45 {
46         m_cursor = 0;
47 }
48
49 void eListboxTestContent::cursorEnd()
50 {
51         m_cursor = size();
52 }
53
54 int eListboxTestContent::cursorMove(int count)
55 {
56         m_cursor += count;
57         
58         if (m_cursor < 0)
59                 cursorHome();
60         else if (m_cursor > size())
61                 cursorEnd();
62         return 0;
63 }
64
65 int eListboxTestContent::cursorValid()
66 {
67         return m_cursor < size();
68 }
69
70 int eListboxTestContent::cursorSet(int n)
71 {
72         m_cursor = n;
73         
74         if (m_cursor < 0)
75                 cursorHome();
76         else if (m_cursor > size())
77                 cursorEnd();
78         return 0;
79 }
80
81 int eListboxTestContent::cursorGet()
82 {
83         return m_cursor;
84 }
85
86 void eListboxTestContent::cursorSave()
87 {
88         m_saved_cursor = m_cursor;
89 }
90
91 void eListboxTestContent::cursorRestore()
92 {
93         m_cursor = m_saved_cursor;
94 }
95
96 int eListboxTestContent::size()
97 {
98         return 10;
99 }
100         
101 RESULT eListboxTestContent::connectItemChanged(const Slot0<void> &itemChanged, ePtr<eConnection> &connection)
102 {
103         return 0;
104 }
105
106 void eListboxTestContent::setSize(const eSize &size)
107 {
108         m_size = size;
109 }
110
111 void eListboxTestContent::paint(gPainter &painter, eWindowStyle &style, const ePoint &offset, int selected)
112 {
113         ePtr<gFont> fnt = new gFont("Arial", 20);
114         painter.clip(eRect(offset, m_size));
115         style.setStyle(painter, selected ? eWindowStyle::styleListboxSelected : eWindowStyle::styleListboxNormal);
116         painter.clear();
117
118         if (cursorValid())
119         {
120                 painter.setFont(fnt);
121                 char string[10];
122                 sprintf(string, "%d.)", m_cursor);
123                 
124                 ePoint text_offset = offset + (selected ? ePoint(2, 2) : ePoint(1, 1));
125                 
126                 painter.renderText(eRect(text_offset, m_size), string);
127                 
128                 if (selected)
129                         style.drawFrame(painter, eRect(offset, m_size), eWindowStyle::frameListboxEntry);
130         }
131         
132         painter.clippop();
133 }
134
135 //////////////////////////////////////
136
137 DEFINE_REF(eListboxStringContent);
138
139 eListboxStringContent::eListboxStringContent()
140 {
141         m_size = 0;
142         cursorHome();
143 }
144
145 void eListboxStringContent::cursorHome()
146 {
147         m_cursor = m_list.begin();
148         m_cursor_number = 0;
149 }
150
151 void eListboxStringContent::cursorEnd()
152 {
153         m_cursor = m_list.end();
154         m_cursor_number = m_size;
155 }
156
157 int eListboxStringContent::cursorMove(int count)
158 {
159         if (count > 0)
160         {
161                 while (count && (m_cursor != m_list.end()))
162                 {
163                         ++m_cursor;
164                         ++m_cursor_number;
165                         --count;
166                 }
167         } else if (count < 0)
168         {
169                 while (count && (m_cursor != m_list.begin()))
170                 {
171                         --m_cursor;
172                         --m_cursor_number;
173                         ++count;
174                 }
175         }
176         
177         return 0;
178 }
179
180 int eListboxStringContent::cursorValid()
181 {
182         return m_cursor != m_list.end();
183 }
184
185 int eListboxStringContent::cursorSet(int n)
186 {
187         cursorHome();
188         cursorMove(n);
189         
190         return 0;
191 }
192
193 int eListboxStringContent::cursorGet()
194 {
195         return m_cursor_number;
196 }
197
198 void eListboxStringContent::cursorSave()
199 {
200         m_saved_cursor = m_cursor;
201         m_saved_cursor_number = m_cursor_number;
202 }
203
204 void eListboxStringContent::cursorRestore()
205 {
206         m_cursor = m_saved_cursor;
207         m_cursor_number = m_saved_cursor_number;
208 }
209
210 int eListboxStringContent::size()
211 {
212         return m_size;
213 }
214         
215 void eListboxStringContent::setSize(const eSize &size)
216 {
217         m_itemsize = size;
218 }
219
220 void eListboxStringContent::paint(gPainter &painter, eWindowStyle &style, const ePoint &offset, int selected)
221 {
222         ePtr<gFont> fnt = new gFont("Arial", 20);
223         painter.clip(eRect(offset, m_itemsize));
224         style.setStyle(painter, selected ? eWindowStyle::styleListboxSelected : eWindowStyle::styleListboxNormal);
225         painter.clear();
226         
227         eDebug("item %d", m_cursor_number);
228         if (cursorValid())
229         {
230                 eDebug("is valid..");
231                 painter.setFont(fnt);
232                 
233                 ePoint text_offset = offset + (selected ? ePoint(2, 2) : ePoint(1, 1));
234                 
235                 painter.renderText(eRect(text_offset, m_itemsize), *m_cursor);
236                 
237                 if (selected)
238                         style.drawFrame(painter, eRect(offset, m_itemsize), eWindowStyle::frameListboxEntry);
239         }
240         
241         painter.clippop();
242 }
243
244 void eListboxStringContent::setList(std::list<std::string> &list)
245 {
246         m_list = list;
247         m_size = list.size();
248         cursorHome();
249 }
250
251 //////////////////////////////////////
252
253 DEFINE_REF(eListboxPythonStringContent);
254
255 eListboxPythonStringContent::eListboxPythonStringContent()
256 {
257         m_list = 0;
258 }
259
260 eListboxPythonStringContent::~eListboxPythonStringContent()
261 {
262 }
263
264 void eListboxPythonStringContent::cursorHome()
265 {
266         m_cursor = 0;
267 }
268
269 void eListboxPythonStringContent::cursorEnd()
270 {
271         m_cursor = size();
272 }
273
274 int eListboxPythonStringContent::cursorMove(int count)
275 {
276         m_cursor += count;
277         
278         if (m_cursor < 0)
279                 cursorHome();
280         else if (m_cursor > size())
281                 cursorEnd();
282         return 0;
283 }
284
285 int eListboxPythonStringContent::cursorValid()
286 {
287         return m_cursor < size();
288 }
289
290 int eListboxPythonStringContent::cursorSet(int n)
291 {
292         m_cursor = n;
293         
294         if (m_cursor < 0)
295                 cursorHome();
296         else if (m_cursor > size())
297                 cursorEnd();
298         return 0;
299 }
300
301 int eListboxPythonStringContent::cursorGet()
302 {
303         return m_cursor;
304 }
305
306 void eListboxPythonStringContent::cursorSave()
307 {
308         m_saved_cursor = m_cursor;
309 }
310
311 void eListboxPythonStringContent::cursorRestore()
312 {
313         m_cursor = m_saved_cursor;
314 }
315
316 int eListboxPythonStringContent::size()
317 {
318         if (!m_list)
319                 return 0;
320         return PyList_Size(m_list);
321 }
322         
323 void eListboxPythonStringContent::setSize(const eSize &size)
324 {
325         m_itemsize = size;
326 }
327
328 void eListboxPythonStringContent::paint(gPainter &painter, eWindowStyle &style, const ePoint &offset, int selected)
329 {
330         ePtr<gFont> fnt = new gFont("Arial", 20);
331         painter.clip(eRect(offset, m_itemsize));
332         style.setStyle(painter, selected ? eWindowStyle::styleListboxSelected : eWindowStyle::styleListboxNormal);
333         painter.clear();
334
335         if (m_list && cursorValid())
336         {
337                 PyObject *item = PyList_GetItem(m_list, m_cursor); // borrowed reference!
338                 painter.setFont(fnt);
339
340                         /* the user can supply tuples, in this case the first one will be displayed. */         
341                 if (PyTuple_Check(item))
342                         item = PyTuple_GetItem(item, 0);
343                 
344                 const char *string = PyString_Check(item) ? PyString_AsString(item) : "<not-a-string>";
345                 
346                 ePoint text_offset = offset + (selected ? ePoint(2, 2) : ePoint(1, 1));
347                 
348                 painter.renderText(eRect(text_offset, m_itemsize), string);
349                 
350                 if (selected)
351                         style.drawFrame(painter, eRect(offset, m_itemsize), eWindowStyle::frameListboxEntry);
352         }
353         
354         painter.clippop();
355 }
356
357 void eListboxPythonStringContent::setList(PyObject *list)
358 {
359         Py_XDECREF(m_list);
360         if (!PyList_Check(list))
361         {
362                 m_list = 0;
363         } else
364         {
365                 m_list = list;
366                 Py_INCREF(m_list);
367         }
368
369         //always invalidate when we get a new list
370         if (m_listbox)
371                 m_listbox->invalidate();
372 }
373
374 PyObject *eListboxPythonStringContent::getCurrentSelection()
375 {
376         if (!m_list)
377                 return 0;
378         if (!cursorValid())
379                 return 0;
380         PyObject *r = PyList_GetItem(m_list, m_cursor);
381         Py_XINCREF(r);
382         return r;
383 }
384
385 void eListboxPythonStringContent::invalidateEntry(int index)
386 {
387         if (m_listbox)
388                 m_listbox->entryChanged(index);
389 }
390
391 void eListboxPythonStringContent::invalidate()
392 {
393         if (m_listbox)
394                 m_listbox->invalidate();
395 }
396
397 //////////////////////////////////////
398
399 void eListboxPythonConfigContent::paint(gPainter &painter, eWindowStyle &style, const ePoint &offset, int selected)
400 {
401         ePtr<gFont> fnt = new gFont("Arial", 20);
402         ePtr<gFont> fnt2 = new gFont("Arial", 16);
403         painter.clip(eRect(offset, m_itemsize));
404         style.setStyle(painter, selected ? eWindowStyle::styleListboxSelected : eWindowStyle::styleListboxNormal);
405         painter.clear();
406
407         if (m_list && cursorValid())
408         {
409                         /* get current list item */
410                 PyObject *item = PyList_GetItem(m_list, m_cursor); // borrowed reference!
411                 PyObject *text = 0, *value = 0;
412                 painter.setFont(fnt);
413
414                         /* the first tuple element is a string for the left side.
415                            the second one will be called, and the result shall be an tuple.
416                            
417                            of this tuple,
418                            the first one is the type (string).
419                            the second one is the value. */
420                 if (PyTuple_Check(item))
421                 {
422                                 /* handle left part. get item from tuple, convert to string, display. */
423                                 
424                         text = PyTuple_GetItem(item, 0);
425                         text = PyObject_Str(text);
426                         const char *string = (text && PyString_Check(text)) ? PyString_AsString(text) : "<not-a-string>";
427                         eSize item_left = eSize(m_seperation, m_itemsize.height());
428                         eSize item_right = eSize(m_itemsize.width() - m_seperation, m_itemsize.height());
429                         painter.renderText(eRect(offset, item_left), string, gPainter::RT_HALIGN_LEFT);
430                         Py_XDECREF(text);
431                         
432                                 /* now, handle the value. get 2nd part from tuple*/
433                         value = PyTuple_GetItem(item, 1);
434                         if (value)
435                         {
436                                 PyObject *args = PyTuple_New(1);
437                                 PyTuple_SetItem(args, 0, PyInt_FromLong(selected));
438                                 
439                                         /* CallObject will call __call__ which should return the value tuple */
440                                 value = PyObject_CallObject(value, args);
441                                 
442                                 if (PyErr_Occurred())
443                                         PyErr_Print();
444
445                                 Py_DECREF(args);
446                                         /* the PyInt was stolen. */
447                         }
448                         
449                                 /*  check if this is really a tuple */
450                         if (value && PyTuple_Check(value))
451                         {
452                                         /* convert type to string */
453                                 PyObject *type = PyTuple_GetItem(value, 0);
454                                 const char *atype = (type && PyString_Check(type)) ? PyString_AsString(type) : 0;
455                                 
456                                 if (atype)
457                                 {
458                                         if (!strcmp(atype, "text"))
459                                         {
460                                                 PyObject *pvalue = PyTuple_GetItem(value, 1);
461                                                 const char *value = (pvalue && PyString_Check(pvalue)) ? PyString_AsString(pvalue) : "<not-a-string>";
462                                                 painter.setFont(fnt2);
463                                                 painter.renderText(eRect(offset + eSize(m_seperation, 0), item_right), value, gPainter::RT_HALIGN_RIGHT);
464
465                                                         /* pvalue is borrowed */
466                                         } else if (!strcmp(atype, "slider"))
467                                         {
468                                                 PyObject *pvalue = PyTuple_GetItem(value, 1);
469                                                 
470                                                         /* convert value to Long. fallback to -1 on error. */
471                                                 int value = (pvalue && PyInt_Check(pvalue)) ? PyInt_AsLong(pvalue) : -1;
472                                                 
473                                                         /* calc. slider length */
474                                                 int width = item_right.width() * value / 100;
475                                                 int height = item_right.height();
476                                                 
477                                                                                                 
478                                                         /* draw slider */
479                                                 //painter.fill(eRect(offset.x() + m_seperation, offset.y(), width, height));
480                                                 //hack - make it customizable
481                                                 painter.fill(eRect(offset.x() + m_seperation, offset.y() + 5, width, height-10));
482                                                 
483                                                         /* pvalue is borrowed */
484                                         } else if (!strcmp(atype, "mtext"))
485                                         {
486                                                 PyObject *pvalue = PyTuple_GetItem(value, 1);
487                                                 const char *text = (pvalue && PyString_Check(pvalue)) ? PyString_AsString(pvalue) : "<not-a-string>";
488                                                 
489                                                 ePtr<eTextPara> para = new eTextPara(eRect(offset + eSize(m_seperation, 0), item_right));
490                                                 para->setFont(fnt2);
491                                                 para->renderString(text, 0);
492                                                 para->realign(eTextPara::dirRight);
493                                                 int glyphs = para->size();
494                                                 
495                                                 PyObject *plist = 0;
496                                                 
497                                                 if (PyTuple_Size(value) >= 3)
498                                                         plist = PyTuple_GetItem(value, 2);
499                                                 
500                                                 int entries = 0;
501
502                                                 if (plist && PyList_Check(plist))
503                                                         entries = PyList_Size(plist);
504                                                 
505                                                 for (int i = 0; i < entries; ++i)
506                                                 {
507                                                         PyObject *entry = PyList_GetItem(plist, i);
508                                                         int num = PyInt_Check(entry) ? PyInt_AsLong(entry) : -1;
509                                                         
510                                                         if ((num < 0) || (num >= glyphs))
511                                                                 eWarning("glyph index %d in PythonConfigList out of bounds!");
512                                                         else
513                                                         {
514                                                                 para->setGlyphFlag(num, GS_INVERT);
515                                                                 eRect bbox;
516                                                                 bbox = para->getGlyphBBox(num);
517                                                                 bbox = eRect(bbox.left(), offset.y(), bbox.width(), m_itemsize.height());
518                                                                 painter.fill(bbox);
519                                                         }
520                                                                 /* entry is borrowed */
521                                                 }
522                                                 
523                                                 painter.renderPara(para, ePoint(0, 0));
524                                                         /* pvalue is borrowed */
525                                                         /* plist is 0 or borrowed */
526                                         }
527                                 }
528                                 Py_XDECREF(type);
529                         } else
530                                 eWarning("eListboxPythonConfigContent: second value of tuple is not a tuple.");
531                                 /* value is borrowed */
532                 }
533
534                 if (selected)
535                         style.drawFrame(painter, eRect(offset, m_itemsize), eWindowStyle::frameListboxEntry);
536         }
537         
538         painter.clippop();
539 }
540
541 //////////////////////////////////////
542
543         /* todo: make a real infrastructure here! */
544 RESULT SwigFromPython(ePtr<gPixmap> &res, PyObject *obj);
545
546 void eListboxPythonMultiContent::paint(gPainter &painter, eWindowStyle &style, const ePoint &offset, int selected)
547 {
548         painter.clip(eRect(offset, m_itemsize));
549         style.setStyle(painter, selected ? eWindowStyle::styleListboxSelected : eWindowStyle::styleListboxNormal);
550         painter.clear();
551
552         if (m_list && cursorValid())
553         {
554                 PyObject *items = PyList_GetItem(m_list, m_cursor); // borrowed reference!
555                 
556                 if (!items)
557                 {
558                         eDebug("eListboxPythonMultiContent: error getting item %d", m_cursor);
559                         painter.clippop();
560                         return;
561                 }
562                 
563                 if (!PyList_Check(items))
564                 {
565                         eDebug("eListboxPythonMultiContent: list entry %d is not a list", m_cursor);
566                         painter.clippop();
567                         return;
568                 }
569                 
570                 int size = PyList_Size(items);
571                 for (int i = 1; i < size; ++i)
572                 {
573                         PyObject *item = PyList_GetItem(items, i); // borrowed reference!
574                         
575                         if (!item)
576                         {
577                                 eDebug("eListboxPythonMultiContent: ?");
578                                 painter.clippop();
579                                 return;
580                         }
581                         
582                         
583                         PyObject *px = 0, *py = 0, *pwidth = 0, *pheight = 0, *pfnt = 0, *pstring = 0, *pflags = 0;
584                 
585                         /*
586                                 we have a list of tuples:
587                                 
588                                 (x, y, width, height, fnt, flags, "bla" ),
589                                 
590                                 or, for a pixmap:
591                                 
592                                 (x, y, width, height, pixmap )
593                                 
594                          */
595                         
596                         if (!PyTuple_Check(item))
597                         {
598                                 eDebug("eListboxPythonMultiContent did not receive a tuple.");
599                                 painter.clippop();
600                                 return;
601                         }
602                         
603                         int size = PyTuple_Size(item);
604                         
605                         if (size >= 5)
606                         {
607                                 px = PyTuple_GetItem(item, 0);
608                                 py = PyTuple_GetItem(item, 1);
609                                 pwidth = PyTuple_GetItem(item, 2);
610                                 pheight = PyTuple_GetItem(item, 3);
611                         
612                                 pfnt = PyTuple_GetItem(item, 4); /* could also be an pixmap */
613                                 if (size >= 7)
614                                 {
615                                         pflags = PyTuple_GetItem(item, 5);
616                                         pstring = PyTuple_GetItem(item, 6);
617                                 }
618                         }
619                         
620                         ePtr<gPixmap> pixmap;
621                         
622                                 /* decide what type */
623                         int type = -1;
624                         if (pfnt)
625                         {
626                                 if (PyNumber_Check(pfnt)) /* font index */
627                                         type = 0;
628                                 else if (!SwigFromPython(pixmap, pfnt))
629                                         type = 1;
630                         }
631                         
632                         switch (type)
633                         {
634                         case 0: // text
635                         {
636                                 if (!(px && py && pwidth && pheight && pfnt && pstring))
637                                 {
638                                         eDebug("eListboxPythonMultiContent received too small tuple (must be (x, y, width, height, fnt, flags, string[, ...])");
639                                         painter.clippop();
640                                         return;
641                                 }
642         
643                                 pstring = PyObject_Str(pstring);
644                         
645                                 const char *string = (PyString_Check(pstring)) ? PyString_AsString(pstring) : "<not-a-string>";
646                         
647                                 int x = PyInt_AsLong(px);
648                                 int y = PyInt_AsLong(py);
649                                 int width = PyInt_AsLong(pwidth);
650                                 int height = PyInt_AsLong(pheight);
651                                 int flags = PyInt_AsLong(pflags);
652
653                                 int fnt = PyInt_AsLong(pfnt);
654
655                                 if (m_font.find(fnt) == m_font.end())
656                                 {
657                                         eDebug("eListboxPythonMultiContent: specified font %d was not found!", fnt);
658                                         Py_XDECREF(pstring);
659                                         painter.clippop();
660                                         return;
661                                 }
662                                 eRect r = eRect(x, y, width, height);
663                                 r.moveBy(offset);
664
665                                 painter.setFont(m_font[fnt]);
666
667                                 painter.renderText(r, string, flags);
668
669                                 Py_XDECREF(pstring);
670                                 break;
671                         }
672                         case 1: // pixmap
673                         {
674                                 int x = PyInt_AsLong(px);
675                                 int y = PyInt_AsLong(py);
676                                 int width = PyInt_AsLong(pwidth);
677                                 int height = PyInt_AsLong(pheight);
678                                 
679                                 eRect r = eRect(x, y, width, height);
680                                 r.moveBy(offset);
681                                 
682                                 painter.blit(pixmap, r.topLeft(), r);
683                                 break;
684                         }
685                         default:
686                                 eWarning("eListboxPythonMultiContent received neither text nor pixmap entry");
687                                 painter.clippop();
688                                 return;
689                         }
690                 }
691         }
692         
693         if (selected)
694                 style.drawFrame(painter, eRect(offset, m_itemsize), eWindowStyle::frameListboxEntry);
695
696         painter.clippop();
697 }
698
699 void eListboxPythonMultiContent::setFont(int fnt, gFont *font)
700 {
701         if (font)
702                 m_font[fnt] = font;
703         else
704                 m_font.erase(fnt);
705 }