fix for canAllocateChannel
[enigma2.git] / lib / service / listboxservice.cpp
1 #include <lib/service/listboxservice.h>
2 #include <lib/service/service.h>
3 #include <lib/gdi/font.h>
4 #include <lib/dvb/epgcache.h>
5 #include <lib/dvb/pmt.h>
6 #include <lib/python/connections.h>
7
8 void eListboxServiceContent::addService(const eServiceReference &service)
9 {
10         m_list.push_back(service);
11 }
12
13 void eListboxServiceContent::FillFinished()
14 {
15         m_size = m_list.size();
16         cursorHome();
17
18         if (m_listbox)
19                 m_listbox->entryReset();
20 }
21
22 void eListboxServiceContent::setRoot(const eServiceReference &root, bool justSet)
23 {
24         m_list.clear();
25         m_root = root;
26
27         if (justSet)
28                 return;
29         assert(m_service_center);
30         
31         ePtr<iListableService> lst;
32         if (m_service_center->list(m_root, lst))
33                 eDebug("no list available!");
34         else
35                 if (lst->getContent(m_list))
36                         eDebug("getContent failed");
37
38         FillFinished();
39 }
40
41 void eListboxServiceContent::setCurrent(const eServiceReference &ref)
42 {
43         int index=0;
44         for (list::iterator i(m_list.begin()); i != m_list.end(); ++i, ++index)
45                 if ( *i == ref )
46                 {
47                         m_cursor = i;
48                         m_cursor_number = index;
49                         break;
50                 }
51 }
52
53 void eListboxServiceContent::getCurrent(eServiceReference &ref)
54 {
55         if (cursorValid())
56                 ref = *m_cursor;
57         else
58                 ref = eServiceReference();
59 }
60
61 int eListboxServiceContent::getNextBeginningWithChar(char c)
62 {
63 //      printf("Char: %c\n", c);
64         int index=0;
65         for (list::iterator i(m_list.begin()); i != m_list.end(); ++i, ++index)
66         {
67                 std::string text;
68                 ePtr<iStaticServiceInformation> service_info;
69                 m_service_center->info(*i, service_info);
70                 service_info->getName(*i, text);
71 //              printf("%c\n", text.c_str()[0]);
72                 int idx=0;
73                 int len=text.length();
74                 while ( idx <= len )
75                 {
76                         char cc = text[idx++];
77                         if ( cc >= 33 && cc < 127)
78                         {
79                                 if (cc == c)
80                                         return index;
81                                 break;
82                         }
83                 }
84         }
85         return 0;
86 }
87
88 void eListboxServiceContent::initMarked()
89 {
90         m_marked.clear();
91 }
92
93 void eListboxServiceContent::addMarked(const eServiceReference &ref)
94 {
95         m_marked.insert(ref);
96         if (m_listbox)
97                 m_listbox->entryChanged(lookupService(ref));
98 }
99
100 void eListboxServiceContent::removeMarked(const eServiceReference &ref)
101 {
102         m_marked.erase(ref);
103         if (m_listbox)
104                 m_listbox->entryChanged(lookupService(ref));
105 }
106
107 int eListboxServiceContent::isMarked(const eServiceReference &ref)
108 {
109         return m_marked.find(ref) != m_marked.end();
110 }
111
112 void eListboxServiceContent::markedQueryStart()
113 {
114         m_marked_iterator = m_marked.begin();
115 }
116
117 int eListboxServiceContent::markedQueryNext(eServiceReference &ref)
118 {
119         if (m_marked_iterator == m_marked.end())
120                 return -1;
121         ref = *m_marked_iterator++;
122         return 0;
123 }
124
125 int eListboxServiceContent::lookupService(const eServiceReference &ref)
126 {
127                 /* shortcut for cursor */
128         if (ref == *m_cursor)
129                 return m_cursor_number;
130                 /* otherwise, search in the list.. */
131         int index = 0;
132         for (list::const_iterator i(m_list.begin()); i != m_list.end(); ++i, ++index);
133         
134                 /* this is ok even when the index was not found. */
135         return index;
136 }
137
138 void eListboxServiceContent::setVisualMode(int mode)
139 {
140         m_visual_mode = mode;
141         
142         if (m_visual_mode == visModeSimple)
143         {
144                 m_element_position[celServiceName] = eRect(ePoint(0, 0), m_itemsize);
145                 m_element_font[celServiceName] = new gFont("Regular", 23);
146                 m_element_position[celServiceNumber] = eRect();
147                 m_element_font[celServiceNumber] = 0;
148                 m_element_position[celIcon] = eRect();
149                 m_element_position[celServiceInfo] = eRect();
150                 m_element_font[celServiceInfo] = 0;
151         }
152 }
153
154 void eListboxServiceContent::setElementPosition(int element, eRect where)
155 {
156         if ((element >= 0) && (element < celElements))
157                 m_element_position[element] = where;
158 }
159
160 void eListboxServiceContent::setElementFont(int element, gFont *font)
161 {
162         if ((element >= 0) && (element < celElements))
163                 m_element_font[element] = font;
164 }
165
166 void eListboxServiceContent::sort()
167 {
168         ePtr<iListableService> lst;
169         if (!m_service_center->list(m_root, lst))
170         {
171                 m_list.sort(iListableServiceCompare(lst));
172                         /* FIXME: is this really required or can we somehow keep the current entry? */
173                 cursorHome();
174                 if (m_listbox)
175                         m_listbox->entryReset();
176         }
177 }
178
179 DEFINE_REF(eListboxServiceContent);
180
181 eListboxServiceContent::eListboxServiceContent()
182         :m_visual_mode(visModeSimple), m_size(0), m_current_marked(false), m_numberoffset(0)
183 {
184         cursorHome();
185         eServiceCenter::getInstance(m_service_center);
186 }
187
188 void eListboxServiceContent::cursorHome()
189 {
190         if (m_current_marked && m_saved_cursor == m_list.end())
191         {
192                 while (m_cursor_number)
193                 {
194                         std::iter_swap(m_cursor--, m_cursor);
195                         --m_cursor_number;
196                         if (m_listbox && m_cursor_number)
197                                 m_listbox->entryChanged(m_cursor_number);
198                 }
199         }
200         else
201         {
202                 m_cursor = m_list.begin();
203                 m_cursor_number = 0;
204         }
205 }
206
207 void eListboxServiceContent::cursorEnd()
208 {
209         if (m_current_marked && m_saved_cursor == m_list.end())
210         {
211                 while (m_cursor != m_list.end())
212                 {
213                         list::iterator prev = m_cursor++;
214                         ++m_cursor_number;
215                         if ( prev != m_list.end() && m_cursor != m_list.end() )
216                         {
217                                 std::iter_swap(m_cursor, prev);
218                                 if ( m_listbox )
219                                         m_listbox->entryChanged(m_cursor_number);
220                         }
221                 }
222         }
223         else
224         {
225                 m_cursor = m_list.end();
226                 m_cursor_number = m_size;
227         }
228 }
229
230 int eListboxServiceContent::setCurrentMarked(bool state)
231 {
232         bool prev = m_current_marked;
233         m_current_marked = state;
234
235         if (state != prev && m_listbox)
236         {
237                 m_listbox->entryChanged(m_cursor_number);
238                 if (!state)
239                 {
240                         ePtr<iListableService> lst;
241                         if (m_service_center->list(m_root, lst))
242                                 eDebug("no list available!");
243                         else
244                         {
245                                 ePtr<iMutableServiceList> list;
246                                 if (lst->startEdit(list))
247                                         eDebug("no editable list");
248                                 else
249                                 {
250                                         eServiceReference ref;
251                                         getCurrent(ref);
252                                         if(!ref)
253                                                 eDebug("no valid service selected");
254                                         else
255                                         {
256                                                 int pos = cursorGet();
257                                                 eDebugNoNewLine("move %s to %d ", ref.toString().c_str(), pos);
258                                                 if (list->moveService(ref, cursorGet()))
259                                                         eDebug("failed");
260                                                 else
261                                                         eDebug("ok");
262                                         }
263                                 }
264                         }
265                 }
266         }
267
268         return 0;
269 }
270
271 int eListboxServiceContent::cursorMove(int count)
272 {
273         int prev = m_cursor_number, last = m_cursor_number + count;
274         if (count > 0)
275         {
276                 while(count && m_cursor != m_list.end())
277                 {
278                         list::iterator prev_it = m_cursor++;
279                         if ( m_current_marked && m_cursor != m_list.end() && m_saved_cursor == m_list.end() )
280                         {
281                                 std::iter_swap(prev_it, m_cursor);
282                                 if ( m_listbox && prev != m_cursor_number && last != m_cursor_number )
283                                         m_listbox->entryChanged(m_cursor_number);
284                         }
285                         ++m_cursor_number;
286                         --count;
287         }
288         } else if (count < 0)
289         {
290                 while (count && m_cursor != m_list.begin())
291                 {
292                         list::iterator prev_it = m_cursor--;
293                         if ( m_current_marked && m_cursor != m_list.end() && prev_it != m_list.end() && m_saved_cursor == m_list.end() )
294                         {
295                                 std::iter_swap(prev_it, m_cursor);
296                                 if ( m_listbox && prev != m_cursor_number && last != m_cursor_number )
297                                         m_listbox->entryChanged(m_cursor_number);
298                         }
299                         --m_cursor_number;
300                         ++count;
301                 }
302         }
303         return 0;
304 }
305
306 int eListboxServiceContent::cursorValid()
307 {
308         return m_cursor != m_list.end();
309 }
310
311 int eListboxServiceContent::cursorSet(int n)
312 {
313         cursorHome();
314         cursorMove(n);
315         return 0;
316 }
317
318 int eListboxServiceContent::cursorGet()
319 {
320         return m_cursor_number;
321 }
322
323 void eListboxServiceContent::cursorSave()
324 {
325         m_saved_cursor = m_cursor;
326         m_saved_cursor_number = m_cursor_number;
327 }
328
329 void eListboxServiceContent::cursorRestore()
330 {
331         m_cursor = m_saved_cursor;
332         m_cursor_number = m_saved_cursor_number;
333         m_saved_cursor = m_list.end();
334 }
335
336 int eListboxServiceContent::size()
337 {
338         return m_size;
339 }
340         
341 void eListboxServiceContent::setSize(const eSize &size)
342 {
343         m_itemsize = size;
344         setVisualMode(m_visual_mode);
345 }
346
347 void eListboxServiceContent::paint(gPainter &painter, eWindowStyle &style, const ePoint &offset, int selected)
348 {
349         painter.clip(eRect(offset, m_itemsize));
350
351         if (m_current_marked && selected)
352                 style.setStyle(painter, eWindowStyle::styleListboxMarked);
353         else if (cursorValid() && isMarked(*m_cursor))
354                 style.setStyle(painter, eWindowStyle::styleListboxMarked);
355         else
356                 style.setStyle(painter, selected ? eWindowStyle::styleListboxSelected : eWindowStyle::styleListboxNormal);
357         painter.clear();
358         
359         if (cursorValid())
360         {
361                         /* get service information */
362                 ePtr<iStaticServiceInformation> service_info;
363                 m_service_center->info(*m_cursor, service_info);
364
365                 if (m_is_playable_ignore.valid() && !service_info->isPlayable(*m_cursor, m_is_playable_ignore))
366                         painter.setForegroundColor(gRGB(0xbbbbbb));
367
368                 for (int e = 0; e < celElements; ++e)
369                 {
370                         if (!m_element_font[e])
371                                 continue;
372                         int flags=gPainter::RT_VALIGN_CENTER;
373
374                         eRect area = m_element_position[e];
375
376                         std::string text = "<n/a>";
377
378                         switch (e)
379                         {
380                         case celIcon:
381                                 // render icon here...
382                                 continue;
383                         case celServiceNumber:
384                         {
385                                 char bla[10];
386                                 sprintf(bla, "%d", m_numberoffset + m_cursor_number + 1);
387                                 text = bla;
388                                 flags|=gPainter::RT_HALIGN_RIGHT;
389                                 break;
390                         }
391                         case celServiceName:
392                         {
393                                 if (service_info)
394                                         service_info->getName(*m_cursor, text);
395                                 break;
396                         }
397                         case celServiceInfo:
398                         {
399                                 ePtr<eServiceEvent> evt;
400                                 if ( !service_info->getEvent(*m_cursor, evt) )
401                                         text = '(' + evt->getEventName() + ')';
402                                 else
403                                         continue;
404                                 break;
405                         }
406                         }
407
408                         eTextPara *para = new eTextPara(area);
409
410                         para->setFont(m_element_font[e]);
411                         para->renderString(text);
412
413                         if (e == celServiceName)
414                         {
415                                 eRect bbox = para->getBoundBox();
416                                 int name_width = bbox.width()+10;
417                                 m_element_position[celServiceInfo].setLeft(area.left()+name_width);
418                                 m_element_position[celServiceInfo].setTop(area.top());
419                                 m_element_position[celServiceInfo].setWidth(area.width()-name_width);
420                                 m_element_position[celServiceInfo].setHeight(area.height());
421                         }
422
423                         if (flags & gPainter::RT_HALIGN_RIGHT)
424                                 para->realign(eTextPara::dirRight);
425                         else if (flags & gPainter::RT_HALIGN_CENTER)
426                                 para->realign(eTextPara::dirCenter);
427                         else if (flags & gPainter::RT_HALIGN_BLOCK)
428                                 para->realign(eTextPara::dirBlock);
429
430                         ePoint offs = offset;
431
432                         if (flags & gPainter::RT_VALIGN_CENTER)
433                         {
434                                 eRect bbox = para->getBoundBox();
435                                 int vcentered_top = (area.height() - bbox.height()) / 2;
436                                 int correction = vcentered_top - bbox.top();
437                                 offs += ePoint(0, correction);
438                         }
439
440                         painter.renderPara(para, offs);
441                 }
442                 
443                 if (selected)
444                         style.drawFrame(painter, eRect(offset, m_itemsize), eWindowStyle::frameListboxEntry);
445         }
446         
447         painter.clippop();
448 }
449
450 void eListboxServiceContent::setIgnoreService( const eServiceReference &service )
451 {
452         m_is_playable_ignore=service;
453 }