adding timers works now
[enigma2.git] / lib / gui / elistboxcontent.cpp
index d3a2e77..3561878 100644 (file)
@@ -1,5 +1,6 @@
 #include <lib/gui/elistbox.h>
 #include <lib/gui/elistboxcontent.h>
+#include <lib/gdi/font.h>
 #include <Python.h>
 
 /*
@@ -29,6 +30,14 @@ iListboxContent::~iListboxContent()
 {
 }
 
+iListboxContent::iListboxContent(): m_listbox(0)
+{
+}
+
+void iListboxContent::setListbox(eListbox *lb)
+{
+       m_listbox = lb;
+}
 
 DEFINE_REF(eListboxTestContent);
 
@@ -101,7 +110,7 @@ void eListboxTestContent::setSize(const eSize &size)
 
 void eListboxTestContent::paint(gPainter &painter, eWindowStyle &style, const ePoint &offset, int selected)
 {
-       ePtr<gFont> fnt = new gFont("Arial", 14);
+       ePtr<gFont> fnt = new gFont("Arial", 20);
        painter.clip(eRect(offset, m_size));
        style.setStyle(painter, selected ? eWindowStyle::styleListboxSelected : eWindowStyle::styleListboxNormal);
        painter.clear();
@@ -203,11 +212,6 @@ int eListboxStringContent::size()
        return m_size;
 }
        
-RESULT eListboxStringContent::connectItemChanged(const Slot0<void> &itemChanged, ePtr<eConnection> &connection)
-{
-       return 0;
-}
-
 void eListboxStringContent::setSize(const eSize &size)
 {
        m_itemsize = size;
@@ -215,7 +219,7 @@ void eListboxStringContent::setSize(const eSize &size)
 
 void eListboxStringContent::paint(gPainter &painter, eWindowStyle &style, const ePoint &offset, int selected)
 {
-       ePtr<gFont> fnt = new gFont("Arial", 14);
+       ePtr<gFont> fnt = new gFont("Arial", 20);
        painter.clip(eRect(offset, m_itemsize));
        style.setStyle(painter, selected ? eWindowStyle::styleListboxSelected : eWindowStyle::styleListboxNormal);
        painter.clear();
@@ -316,11 +320,6 @@ int eListboxPythonStringContent::size()
        return PyList_Size(m_list);
 }
        
-RESULT eListboxPythonStringContent::connectItemChanged(const Slot0<void> &itemChanged, ePtr<eConnection> &connection)
-{
-       return 0;
-}
-
 void eListboxPythonStringContent::setSize(const eSize &size)
 {
        m_itemsize = size;
@@ -328,7 +327,7 @@ void eListboxPythonStringContent::setSize(const eSize &size)
 
 void eListboxPythonStringContent::paint(gPainter &painter, eWindowStyle &style, const ePoint &offset, int selected)
 {
-       ePtr<gFont> fnt = new gFont("Arial", 14);
+       ePtr<gFont> fnt = new gFont("Arial", 20);
        painter.clip(eRect(offset, m_itemsize));
        style.setStyle(painter, selected ? eWindowStyle::styleListboxSelected : eWindowStyle::styleListboxNormal);
        painter.clear();
@@ -366,6 +365,10 @@ void eListboxPythonStringContent::setList(PyObject *list)
                m_list = list;
                Py_INCREF(m_list);
        }
+
+       //always invalidate when we get a new list
+       if (m_listbox)
+               m_listbox->invalidate();
 }
 
 PyObject *eListboxPythonStringContent::getCurrentSelection()
@@ -379,4 +382,273 @@ PyObject *eListboxPythonStringContent::getCurrentSelection()
        return r;
 }
 
+void eListboxPythonStringContent::invalidateEntry(int index)
+{
+       if (m_listbox)
+               m_listbox->entryChanged(index);
+}
+
+void eListboxPythonStringContent::invalidate()
+{
+       if (m_listbox)
+               m_listbox->invalidate();
+}
+
 //////////////////////////////////////
+
+void eListboxPythonConfigContent::paint(gPainter &painter, eWindowStyle &style, const ePoint &offset, int selected)
+{
+       ePtr<gFont> fnt = new gFont("Arial", 20);
+       ePtr<gFont> fnt2 = new gFont("Arial", 16);
+       painter.clip(eRect(offset, m_itemsize));
+       style.setStyle(painter, selected ? eWindowStyle::styleListboxSelected : eWindowStyle::styleListboxNormal);
+       painter.clear();
+
+       if (m_list && cursorValid())
+       {
+                       /* get current list item */
+               PyObject *item = PyList_GetItem(m_list, m_cursor); // borrowed reference!
+               PyObject *text = 0, *value = 0;
+               painter.setFont(fnt);
+
+                       /* the first tuple element is a string for the left side.
+                          the second one will be called, and the result shall be an tuple.
+                          
+                          of this tuple,
+                          the first one is the type (string).
+                          the second one is the value. */
+               if (PyTuple_Check(item))
+               {
+                               /* handle left part. get item from tuple, convert to string, display. */
+                               
+                       text = PyTuple_GetItem(item, 0);
+                       text = PyObject_Str(text);
+                       const char *string = (text && PyString_Check(text)) ? PyString_AsString(text) : "<not-a-string>";
+                       eSize item_left = eSize(m_seperation, m_itemsize.height());
+                       eSize item_right = eSize(m_itemsize.width() - m_seperation, m_itemsize.height());
+                       painter.renderText(eRect(offset, item_left), string, gPainter::RT_HALIGN_LEFT);
+                       Py_XDECREF(text);
+                       
+                               /* now, handle the value. get 2nd part from tuple*/
+                       value = PyTuple_GetItem(item, 1);
+                       if (value)
+                       {
+                               PyObject *args = PyTuple_New(1);
+                               PyTuple_SetItem(args, 0, PyInt_FromLong(selected));
+                               
+                                       /* CallObject will call __call__ which should return the value tuple */
+                               value = PyObject_CallObject(value, args);
+                               
+                               if (PyErr_Occurred())
+                                       PyErr_Print();
+
+                               Py_DECREF(args);
+                                       /* the PyInt was stolen. */
+                       }
+                       
+                               /*  check if this is really a tuple */
+                       if (value && PyTuple_Check(value))
+                       {
+                                       /* convert type to string */
+                               PyObject *type = PyTuple_GetItem(value, 0);
+                               const char *atype = (type && PyString_Check(type)) ? PyString_AsString(type) : 0;
+                               
+                               if (atype)
+                               {
+                                       if (!strcmp(atype, "text"))
+                                       {
+                                               PyObject *pvalue = PyTuple_GetItem(value, 1);
+                                               const char *value = (pvalue && PyString_Check(pvalue)) ? PyString_AsString(pvalue) : "<not-a-string>";
+                                               painter.setFont(fnt2);
+                                               painter.renderText(eRect(offset + eSize(m_seperation, 0), item_right), value, gPainter::RT_HALIGN_RIGHT);
+
+                                                       /* pvalue is borrowed */
+                                       } else if (!strcmp(atype, "slider"))
+                                       {
+                                               PyObject *pvalue = PyTuple_GetItem(value, 1);
+                                               
+                                                       /* convert value to Long. fallback to -1 on error. */
+                                               int value = (pvalue && PyInt_Check(pvalue)) ? PyInt_AsLong(pvalue) : -1;
+                                               
+                                                       /* calc. slider length */
+                                               int width = item_right.width() * value / 100;
+                                               int height = item_right.height();
+                                               
+                                                                                               
+                                                       /* draw slider */
+                                               //painter.fill(eRect(offset.x() + m_seperation, offset.y(), width, height));
+                                               //hack - make it customizable
+                                               painter.fill(eRect(offset.x() + m_seperation, offset.y() + 5, width, height-10));
+                                               
+                                                       /* pvalue is borrowed */
+                                       } else if (!strcmp(atype, "mtext"))
+                                       {
+                                               PyObject *pvalue = PyTuple_GetItem(value, 1);
+                                               const char *text = (pvalue && PyString_Check(pvalue)) ? PyString_AsString(pvalue) : "<not-a-string>";
+                                               
+                                               ePtr<eTextPara> para = new eTextPara(eRect(offset + eSize(m_seperation, 0), item_right));
+                                               para->setFont(fnt2);
+                                               para->renderString(text, 0);
+                                               para->realign(eTextPara::dirRight);
+                                               int glyphs = para->size();
+                                               
+                                               PyObject *plist = 0;
+                                               
+                                               if (PyTuple_Size(value) >= 3)
+                                                       plist = PyTuple_GetItem(value, 2);
+                                               
+                                               int entries = 0;
+
+                                               if (plist && PyList_Check(plist))
+                                                       entries = PyList_Size(plist);
+                                               
+                                               for (int i = 0; i < entries; ++i)
+                                               {
+                                                       PyObject *entry = PyList_GetItem(plist, i);
+                                                       int num = PyInt_Check(entry) ? PyInt_AsLong(entry) : -1;
+                                                       
+                                                       if ((num < 0) || (num >= glyphs))
+                                                               eWarning("glyph index %d in PythonConfigList out of bounds!");
+                                                       else
+                                                       {
+                                                               para->setGlyphFlag(num, GS_INVERT);
+                                                               eRect bbox;
+                                                               bbox = para->getGlyphBBox(num);
+                                                               bbox = eRect(bbox.left(), offset.y(), bbox.width(), m_itemsize.height());
+                                                               painter.fill(bbox);
+                                                       }
+                                                               /* entry is borrowed */
+                                               }
+                                               
+                                               painter.renderPara(para, ePoint(0, 0));
+                                                       /* pvalue is borrowed */
+                                                       /* plist is 0 or borrowed */
+                                       }
+                               }
+                               Py_XDECREF(type);
+                       } else
+                               eWarning("eListboxPythonConfigContent: second value of tuple is not a tuple.");
+                               /* value is borrowed */
+               }
+
+               if (selected)
+                       style.drawFrame(painter, eRect(offset, m_itemsize), eWindowStyle::frameListboxEntry);
+       }
+       
+       painter.clippop();
+}
+
+//////////////////////////////////////
+
+void eListboxPythonMultiContent::paint(gPainter &painter, eWindowStyle &style, const ePoint &offset, int selected)
+{
+       painter.clip(eRect(offset, m_itemsize));
+       style.setStyle(painter, selected ? eWindowStyle::styleListboxSelected : eWindowStyle::styleListboxNormal);
+       painter.clear();
+
+       if (m_list && cursorValid())
+       {
+               PyObject *items = PyList_GetItem(m_list, m_cursor); // borrowed reference!
+               
+               if (!items)
+               {
+                       eDebug("eListboxPythonMultiContent: error getting item %d", m_cursor);
+                       painter.clippop();
+                       return;
+               }
+               
+               if (!PyList_Check(items))
+               {
+                       eDebug("eListboxPythonMultiContent: list entry %d is not a list", m_cursor);
+                       painter.clippop();
+                       return;
+               }
+               
+               int size = PyList_Size(items);
+               for (int i = 1; i < size; ++i)
+               {
+                       PyObject *item = PyList_GetItem(items, i); // borrowed reference!
+                       
+                       if (!item)
+                       {
+                               eDebug("eListboxPythonMultiContent: ?");
+                               painter.clippop();
+                               return;
+                       }
+                       
+                       
+                       PyObject *px, *py, *pwidth, *pheight, *pfnt, *pstring, *pflags;
+               
+                       /*
+                               we have a list of tuples:
+                               
+                               (x, y, width, height, fnt, flags, "bla" ),
+                               
+                        */
+                       
+                       if (!PyTuple_Check(item))
+                       {
+                               eDebug("eListboxPythonMultiContent did not receive a tuple.");
+                               painter.clippop();
+                               return;
+                       }
+               
+                       px = PyTuple_GetItem(item, 0);
+                       py = PyTuple_GetItem(item, 1);
+                       pwidth = PyTuple_GetItem(item, 2);
+                       pheight = PyTuple_GetItem(item, 3);
+                       pfnt = PyTuple_GetItem(item, 4);
+                       pflags = PyTuple_GetItem(item, 5);
+                       pstring = PyTuple_GetItem(item, 6);
+                       
+                       if (!(px && py && pwidth && pheight && pfnt && pstring))
+                       {
+                               eDebug("eListboxPythonMultiContent received too small tuple (must be (x, y, width, height, fnt, flags, string[, ...])");
+                               painter.clippop();
+                               return;
+                       }
+       
+                       pstring = PyObject_Str(pstring);
+                       
+                       const char *string = (PyString_Check(pstring)) ? PyString_AsString(pstring) : "<not-a-string>";
+                       
+                       int x = PyInt_AsLong(px);
+                       int y = PyInt_AsLong(py);
+                       int width = PyInt_AsLong(pwidth);
+                       int height = PyInt_AsLong(pheight);
+                       int flags = PyInt_AsLong(pflags);
+                       
+                       int fnt = PyInt_AsLong(pfnt);
+                       
+                       if (m_font.find(fnt) == m_font.end())
+                       {
+                               eDebug("eListboxPythonMultiContent: specified font %d was not found!", fnt);
+                               Py_XDECREF(pstring);
+                               painter.clippop();
+                               return;
+                       }
+                       
+                       eRect r = eRect(x, y, width, height);
+                       r.moveBy(offset);
+                       
+                       painter.setFont(m_font[fnt]);
+                       
+                       painter.renderText(r, string, flags);
+       
+                       Py_XDECREF(pstring);
+                       
+                       if (selected)
+                               style.drawFrame(painter, eRect(offset, m_itemsize), eWindowStyle::frameListboxEntry);
+               }
+       }
+       
+       painter.clippop();
+}
+
+void eListboxPythonMultiContent::setFont(int fnt, gFont *font)
+{
+       if (font)
+               m_font[fnt] = font;
+       else
+               m_font.erase(fnt);
+}