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, bool beforeCurrent)
   9 {
  10         if (beforeCurrent && m_size)
  11                 m_list.insert(m_cursor, service);
  12         else
  13                 m_list.push_back(service);
  14         if (m_size++)
  15         {
  16                 ++m_cursor_number;
  17                 if (m_listbox)
  18                         m_listbox->entryAdded(m_cursor_number-1);
  19         }
  20         else
  21         {
  22                 m_cursor = m_list.begin();
  23                 m_cursor_number=0;
  24                 m_listbox->entryAdded(0);
  25         }
  26 }
  27
  28 void eListboxServiceContent::removeCurrent()
  29 {
  30         if (m_size && m_listbox)
  31         {
  32                 if (m_cursor_number == --m_size)
  33                 {
  34                         m_list.erase(m_cursor--);
  35                         if (m_size)
  36                         {
  37                                 --m_cursor_number;
  38                                 m_listbox->entryRemoved(m_cursor_number+1);
  39                         }
  40                         else
  41                                 m_listbox->entryRemoved(m_cursor_number);
  42                 }
  43                 else
  44                 {
  45                         m_list.erase(m_cursor++);
  46                         m_listbox->entryRemoved(m_cursor_number);
  47                 }
  48         }
  49 }
  50
  51 void eListboxServiceContent::FillFinished()
  52 {
  53         m_size = m_list.size();
  54         cursorHome();
  55
  56         if (m_listbox)
  57                 m_listbox->entryReset();
  58 }
  59
  60 void eListboxServiceContent::setRoot(const eServiceReference &root, bool justSet)
  61 {
  62         m_list.clear();
  63         m_root = root;
  64
  65         if (justSet)
  66         {
  67                 m_lst=0;
  68                 return;
  69         }
  70         ASSERT(m_service_center);
  71
  72         if (m_service_center->list(m_root, m_lst))
  73                 eDebug("no list available!");
  74         else if (m_lst->getContent(m_list))
  75                 eDebug("getContent failed");
  76
  77         FillFinished();
  78 }
  79
  80 void eListboxServiceContent::setCurrent(const eServiceReference &ref)
  81 {
  82         int index=0;
  83         for (list::iterator i(m_list.begin()); i != m_list.end(); ++i, ++index)
  84                 if ( *i == ref )
  85                 {
  86                         m_cursor = i;
  87                         m_cursor_number = index;
  88                         break;
  89                 }
  90         if (m_listbox)
  91                 m_listbox->moveSelectionTo(index);
  92 }
  93
  94 void eListboxServiceContent::getCurrent(eServiceReference &ref)
  95 {
  96         if (cursorValid())
  97                 ref = *m_cursor;
  98         else
  99                 ref = eServiceReference();
 100 }
 101
 102 int eListboxServiceContent::getNextBeginningWithChar(char c)
 103 {
 104 //      printf("Char: %c\n", c);
 105         int index=0;
 106         for (list::iterator i(m_list.begin()); i != m_list.end(); ++i, ++index)
 107         {
 108                 std::string text;
 109                 ePtr<iStaticServiceInformation> service_info;
 110                 m_service_center->info(*i, service_info);
 111                 service_info->getName(*i, text);
 112 //              printf("%c\n", text.c_str()[0]);
 113                 int idx=0;
 114                 int len=text.length();
 115                 while ( idx <= len )
 116                 {
 117                         char cc = text[idx++];
 118                         if ( cc >= 33 && cc < 127)
 119                         {
 120                                 if (cc == c)
 121                                         return index;
 122                                 break;
 123                         }
 124                 }
 125         }
 126         return 0;
 127 }
 128
 129 int eListboxServiceContent::getPrevMarkerPos()
 130 {
 131         if (!m_listbox)
 132                 return 0;
 133         list::iterator i(m_cursor);
 134         int index = m_cursor_number;
 135         while (index)
 136         {
 137                 --i;
 138                 --index;
 139                 if (i->flags & eServiceReference::isMarker)
 140                         break;
 141         }
 142         return index;
 143 }
 144
 145 int eListboxServiceContent::getNextMarkerPos()
 146 {
 147         if (!m_listbox)
 148                 return 0;
 149         list::iterator i(m_cursor);
 150         int index = m_cursor_number;
 151         while (index < (m_size-1))
 152         {
 153                 ++i;
 154                 ++index;
 155                 if (i->flags & eServiceReference::isMarker)
 156                         break;
 157         }
 158         return index;
 159 }
 160
 161 void eListboxServiceContent::initMarked()
 162 {
 163         m_marked.clear();
 164 }
 165
 166 void eListboxServiceContent::addMarked(const eServiceReference &ref)
 167 {
 168         m_marked.insert(ref);
 169         if (m_listbox)
 170                 m_listbox->entryChanged(lookupService(ref));
 171 }
 172
 173 void eListboxServiceContent::removeMarked(const eServiceReference &ref)
 174 {
 175         m_marked.erase(ref);
 176         if (m_listbox)
 177                 m_listbox->entryChanged(lookupService(ref));
 178 }
 179
 180 int eListboxServiceContent::isMarked(const eServiceReference &ref)
 181 {
 182         return m_marked.find(ref) != m_marked.end();
 183 }
 184
 185 void eListboxServiceContent::markedQueryStart()
 186 {
 187         m_marked_iterator = m_marked.begin();
 188 }
 189
 190 int eListboxServiceContent::markedQueryNext(eServiceReference &ref)
 191 {
 192         if (m_marked_iterator == m_marked.end())
 193                 return -1;
 194         ref = *m_marked_iterator++;
 195         return 0;
 196 }
 197
 198 int eListboxServiceContent::lookupService(const eServiceReference &ref)
 199 {
 200                 /* shortcut for cursor */
 201         if (ref == *m_cursor)
 202                 return m_cursor_number;
 203                 /* otherwise, search in the list.. */
 204         int index = 0;
 205         for (list::const_iterator i(m_list.begin()); i != m_list.end(); ++i, ++index);
 206
 207                 /* this is ok even when the index was not found. */
 208         return index;
 209 }
 210
 211 void eListboxServiceContent::setVisualMode(int mode)
 212 {
 213         for (int i=0; i < celElements; ++i)
 214         {
 215                 m_element_position[i] = eRect();
 216                 m_element_font[i] = 0;
 217         }
 218
 219         m_visual_mode = mode;
 220
 221         if (m_visual_mode == visModeSimple)
 222         {
 223                 m_element_position[celServiceName] = eRect(ePoint(0, 0), m_itemsize);
 224                 m_element_font[celServiceName] = new gFont("Regular", 23);
 225         }
 226 }
 227
 228 void eListboxServiceContent::setElementPosition(int element, eRect where)
 229 {
 230         if ((element >= 0) && (element < celElements))
 231                 m_element_position[element] = where;
 232 }
 233
 234 void eListboxServiceContent::setElementFont(int element, gFont *font)
 235 {
 236         if ((element >= 0) && (element < celElements))
 237                 m_element_font[element] = font;
 238 }
 239
 240 void eListboxServiceContent::setPixmap(int type, ePtr<gPixmap> &pic)
 241 {
 242         if ((type >=0) && (type < picElements))
 243                 m_pixmaps[type] = pic;
 244 }
 245
 246 void eListboxServiceContent::sort()
 247 {
 248         if (!m_lst)
 249                 m_service_center->list(m_root, m_lst);
 250         if (m_lst)
 251         {
 252                 m_list.sort(iListableServiceCompare(m_lst));
 253                         /* FIXME: is this really required or can we somehow keep the current entry? */
 254                 cursorHome();
 255                 if (m_listbox)
 256                         m_listbox->entryReset();
 257         }
 258 }
 259
 260 DEFINE_REF(eListboxServiceContent);
 261
 262 eListboxServiceContent::eListboxServiceContent()
 263         :m_visual_mode(visModeSimple), m_size(0), m_current_marked(false), m_numberoffset(0), m_itemheight(25)
 264 {
 265         memset(m_color_set, 0, sizeof(m_color_set));
 266         cursorHome();
 267         eServiceCenter::getInstance(m_service_center);
 268 }
 269
 270 void eListboxServiceContent::setColor(int color, gRGB &col)
 271 {
 272         if ((color >= 0) && (color < colorElements))
 273         {
 274                 m_color_set[color] = true;
 275                 m_color[color] = col;
 276         }
 277 }
 278
 279 void eListboxServiceContent::cursorHome()
 280 {
 281         if (m_current_marked && m_saved_cursor == m_list.end())
 282         {
 283                 if (m_cursor_number >= m_size)
 284                 {
 285                         m_cursor_number = m_size-1;
 286                         --m_cursor;
 287                 }
 288                 while (m_cursor_number)
 289                 {
 290                         std::iter_swap(m_cursor--, m_cursor);
 291                         --m_cursor_number;
 292                         if (m_listbox && m_cursor_number)
 293                                 m_listbox->entryChanged(m_cursor_number);
 294                 }
 295         }
 296         else
 297         {
 298                 m_cursor = m_list.begin();
 299                 m_cursor_number = 0;
 300         }
 301 }
 302
 303 void eListboxServiceContent::cursorEnd()
 304 {
 305         if (m_current_marked && m_saved_cursor == m_list.end())
 306         {
 307                 while (m_cursor != m_list.end())
 308                 {
 309                         list::iterator prev = m_cursor++;
 310                         ++m_cursor_number;
 311                         if ( prev != m_list.end() && m_cursor != m_list.end() )
 312                         {
 313                                 std::iter_swap(m_cursor, prev);
 314                                 if ( m_listbox )
 315                                         m_listbox->entryChanged(m_cursor_number);
 316                         }
 317                 }
 318         }
 319         else
 320         {
 321                 m_cursor = m_list.end();
 322                 m_cursor_number = m_size;
 323         }
 324 }
 325
 326 int eListboxServiceContent::setCurrentMarked(bool state)
 327 {
 328         bool prev = m_current_marked;
 329         m_current_marked = state;
 330
 331         if (state != prev && m_listbox)
 332         {
 333                 m_listbox->entryChanged(m_cursor_number);
 334                 if (!state)
 335                 {
 336                         if (!m_lst)
 337                                 m_service_center->list(m_root, m_lst);
 338                         if (m_lst)
 339                         {
 340                                 ePtr<iMutableServiceList> list;
 341                                 if (m_lst->startEdit(list))
 342                                         eDebug("no editable list");
 343                                 else
 344                                 {
 345                                         eServiceReference ref;
 346                                         getCurrent(ref);
 347                                         if(!ref)
 348                                                 eDebug("no valid service selected");
 349                                         else
 350                                         {
 351                                                 int pos = cursorGet();
 352                                                 eDebugNoNewLine("move %s to %d ", ref.toString().c_str(), pos);
 353                                                 if (list->moveService(ref, cursorGet()))
 354                                                         eDebug("failed");
 355                                                 else
 356                                                         eDebug("ok");
 357                                         }
 358                                 }
 359                         }
 360                         else
 361                                 eDebug("no list available!");
 362                 }
 363         }
 364
 365         return 0;
 366 }
 367
 368 int eListboxServiceContent::cursorMove(int count)
 369 {
 370         int prev = m_cursor_number, last = m_cursor_number + count;
 371         if (count > 0)
 372         {
 373                 while(count && m_cursor != m_list.end())
 374                 {
 375                         list::iterator prev_it = m_cursor++;
 376                         if ( m_current_marked && m_cursor != m_list.end() && m_saved_cursor == m_list.end() )
 377                         {
 378                                 std::iter_swap(prev_it, m_cursor);
 379                                 if ( m_listbox && prev != m_cursor_number && last != m_cursor_number )
 380                                         m_listbox->entryChanged(m_cursor_number);
 381                         }
 382                         ++m_cursor_number;
 383                         --count;
 384         }
 385         } else if (count < 0)
 386         {
 387                 while (count && m_cursor != m_list.begin())
 388                 {
 389                         list::iterator prev_it = m_cursor--;
 390                         if ( m_current_marked && m_cursor != m_list.end() && prev_it != m_list.end() && m_saved_cursor == m_list.end() )
 391                         {
 392                                 std::iter_swap(prev_it, m_cursor);
 393                                 if ( m_listbox && prev != m_cursor_number && last != m_cursor_number )
 394                                         m_listbox->entryChanged(m_cursor_number);
 395                         }
 396                         --m_cursor_number;
 397                         ++count;
 398                 }
 399         }
 400         return 0;
 401 }
 402
 403 int eListboxServiceContent::cursorValid()
 404 {
 405         return m_cursor != m_list.end();
 406 }
 407
 408 int eListboxServiceContent::cursorSet(int n)
 409 {
 410         cursorHome();
 411         cursorMove(n);
 412         return 0;
 413 }
 414
 415 int eListboxServiceContent::cursorGet()
 416 {
 417         return m_cursor_number;
 418 }
 419
 420 void eListboxServiceContent::cursorSave()
 421 {
 422         m_saved_cursor = m_cursor;
 423         m_saved_cursor_number = m_cursor_number;
 424 }
 425
 426 void eListboxServiceContent::cursorRestore()
 427 {
 428         m_cursor = m_saved_cursor;
 429         m_cursor_number = m_saved_cursor_number;
 430         m_saved_cursor = m_list.end();
 431 }
 432
 433 int eListboxServiceContent::size()
 434 {
 435         return m_size;
 436 }
 437
 438 void eListboxServiceContent::setSize(const eSize &size)
 439 {
 440         m_itemsize = size;
 441         if (m_visual_mode == visModeSimple)
 442                 setVisualMode(m_visual_mode);
 443 }
 444
 445 void eListboxServiceContent::paint(gPainter &painter, eWindowStyle &style, const ePoint &offset, int selected)
 446 {
 447         painter.clip(eRect(offset, m_itemsize));
 448
 449         int marked = 0;
 450
 451         if (m_current_marked && selected)
 452                 marked = 2;
 453         else if (cursorValid() && isMarked(*m_cursor))
 454         {
 455                 if (selected)
 456                         marked = 2;
 457                 else
 458                         marked = 1;
 459         }
 460         else
 461                 style.setStyle(painter, selected ? eWindowStyle::styleListboxSelected : eWindowStyle::styleListboxNormal);
 462
 463         eListboxStyle *local_style = 0;
 464
 465                 /* get local listbox style, if present */
 466         if (m_listbox)
 467                 local_style = m_listbox->getLocalStyle();
 468
 469         if (marked == 1)  // marked
 470         {
 471                 style.setStyle(painter, eWindowStyle::styleListboxMarked);
 472                 if (m_color_set[markedForeground])
 473                         painter.setForegroundColor(m_color[markedForeground]);
 474                 if (m_color_set[markedBackground])
 475                         painter.setBackgroundColor(m_color[markedBackground]);
 476         }
 477         else if (marked == 2) // marked and selected
 478         {
 479                 style.setStyle(painter, eWindowStyle::styleListboxMarkedAndSelected);
 480                 if (m_color_set[markedForegroundSelected])
 481                         painter.setForegroundColor(m_color[markedForegroundSelected]);
 482                 if (m_color_set[markedBackgroundSelected])
 483                         painter.setBackgroundColor(m_color[markedBackgroundSelected]);
 484         }
 485         else if (local_style)
 486         {
 487                 if (selected)
 488                 {
 489                         /* if we have a local background color set, use that. */
 490                         if (local_style->m_background_color_selected_set)
 491                                 painter.setBackgroundColor(local_style->m_background_color_selected);
 492                         /* same for foreground */
 493                         if (local_style->m_foreground_color_selected_set)
 494                                 painter.setForegroundColor(local_style->m_foreground_color_selected);
 495                 }
 496                 else
 497                 {
 498                         /* if we have a local background color set, use that. */
 499                         if (local_style->m_background_color_set)
 500                                 painter.setBackgroundColor(local_style->m_background_color);
 501                         /* same for foreground */
 502                         if (local_style->m_foreground_color_set)
 503                                 painter.setForegroundColor(local_style->m_foreground_color);
 504                 }
 505         }
 506
 507         if (!local_style || !local_style->m_transparent_background)
 508                 /* if we have no transparent background */
 509         {
 510                 /* blit background picture, if available (otherwise, clear only) */
 511                 if (local_style && local_style->m_background)
 512                         painter.blit(local_style->m_background, offset, eRect(), 0);
 513                 else
 514                         painter.clear();
 515         } else
 516         {
 517                 if (local_style->m_background)
 518                         painter.blit(local_style->m_background, offset, eRect(), gPainter::BT_ALPHATEST);
 519                 else if (selected && !local_style->m_selection)
 520                         painter.clear();
 521         }
 522
 523         if (cursorValid())
 524         {
 525                         /* get service information */
 526                 ePtr<iStaticServiceInformation> service_info;
 527                 m_service_center->info(*m_cursor, service_info);
 528                 eServiceReference ref = *m_cursor;
 529                 bool isMarker = ref.flags & eServiceReference::isMarker;
 530                 bool isPlayable = !(ref.flags & eServiceReference::isDirectory || isMarker);
 531                 bool paintProgress = false;
 532                 ePtr<eServiceEvent> evt;
 533
 534                 bool serviceAvail = true;
 535
 536                 if (!marked && isPlayable && service_info && m_is_playable_ignore.valid() && !service_info->isPlayable(*m_cursor, m_is_playable_ignore))
 537                 {
 538                         if (m_color_set[serviceNotAvail])
 539                                 painter.setForegroundColor(m_color[serviceNotAvail]);
 540                         else
 541                                 painter.setForegroundColor(gRGB(0xbbbbbb));
 542                         serviceAvail = false;
 543                 }
 544
 545                 if (selected && local_style && local_style->m_selection)
 546                         painter.blit(local_style->m_selection, offset, eRect(), gPainter::BT_ALPHATEST);
 547
 548                 int xoffset=0;  // used as offset when painting the folder/marker symbol or the serviceevent progress
 549
 550                 for (int e = 0; e < celElements; ++e)
 551                 {
 552                         if (m_element_font[e])
 553                         {
 554                                 int flags=gPainter::RT_VALIGN_CENTER,
 555                                         yoffs = 0,
 556                                         xoffs = xoffset;
 557                                 eRect &area = m_element_position[e];
 558                                 std::string text = "<n/a>";
 559                                 xoffset=0;
 560
 561                                 switch (e)
 562                                 {
 563                                 case celServiceNumber:
 564                                 {
 565                                         if (m_cursor->flags & eServiceReference::isMarker)
 566                                                 continue;
 567                                         char bla[10];
 568                                 /* how we can do this better? :) */
 569                                         int markers_before=0;
 570                                         {
 571                                                 list::iterator tmp=m_cursor;
 572                                                 while(tmp != m_list.begin())
 573                                                 {
 574                                                         --tmp;
 575                                                         if (tmp->flags & eServiceReference::isMarker)
 576                                                                 ++markers_before;
 577                                                 }
 578                                         }
 579                                         sprintf(bla, "%d", m_numberoffset + m_cursor_number + 1 - markers_before);
 580                                         text = bla;
 581                                         flags|=gPainter::RT_HALIGN_RIGHT;
 582                                         break;
 583                                 }
 584                                 case celServiceName:
 585                                 {
 586                                         if (service_info)
 587                                                 service_info->getName(*m_cursor, text);
 588                                         break;
 589                                 }
 590                                 case celServiceInfo:
 591                                 {
 592                                         if ( isPlayable && !service_info->getEvent(*m_cursor, evt) )
 593                                         {
 594                                                 std::string name = evt->getEventName();
 595                                                 if (!name.length())
 596                                                         continue;
 597                                                 text = '(' + evt->getEventName() + ')';
 598                                                 if (serviceAvail)
 599                                                 {
 600                                                         if (!selected && m_color_set[serviceDescriptionColor])
 601                                                                 painter.setForegroundColor(m_color[serviceDescriptionColor]);
 602                                                         else if (selected && m_color_set[serviceDescriptionColorSelected])
 603                                                                 painter.setForegroundColor(m_color[serviceDescriptionColorSelected]);
 604                                                 }
 605                                         }
 606                                         else
 607                                                 continue;
 608                                         break;
 609                                 }
 610                                 }
 611
 612                                 eRect tmp = area;
 613                                 tmp.setWidth(tmp.width()-xoffs);
 614
 615                                 eTextPara *para = new eTextPara(tmp);
 616                                 para->setFont(m_element_font[e]);
 617                                 para->renderString(text.c_str());
 618
 619                                 if (e == celServiceName)
 620                                 {
 621                                         eRect bbox = para->getBoundBox();
 622                                         int name_width = bbox.width()+8;
 623                                         m_element_position[celServiceInfo].setLeft(area.left()+name_width+xoffs);
 624                                         m_element_position[celServiceInfo].setTop(area.top());
 625                                         m_element_position[celServiceInfo].setWidth(area.width()-(name_width+xoffs));
 626                                         m_element_position[celServiceInfo].setHeight(area.height());
 627                                 }
 628
 629                                 if (flags & gPainter::RT_HALIGN_RIGHT)
 630                                         para->realign(eTextPara::dirRight);
 631                                 else if (flags & gPainter::RT_HALIGN_CENTER)
 632                                         para->realign(eTextPara::dirCenter);
 633                                 else if (flags & gPainter::RT_HALIGN_BLOCK)
 634                                         para->realign(eTextPara::dirBlock);
 635
 636                                 if (flags & gPainter::RT_VALIGN_CENTER)
 637                                 {
 638                                         eRect bbox = para->getBoundBox();
 639                                         int vcentered_top = (area.height() - bbox.height()) / 2;
 640                                         yoffs = vcentered_top - bbox.top();
 641                                 }
 642
 643                                 painter.renderPara(para, offset+ePoint(xoffs, yoffs));
 644                         }
 645                         else if (e == celServiceTypePixmap || e == celFolderPixmap || e == celMarkerPixmap)
 646                         {
 647                                 int orbpos = m_cursor->getUnsignedData(4) >> 16;
 648                                 ePtr<gPixmap> &pixmap =
 649                                         (e == celFolderPixmap) ? m_pixmaps[picFolder] :
 650                                         (e == celMarkerPixmap) ? m_pixmaps[picMarker] :
 651                                         (m_cursor->flags & eServiceReference::isGroup) ? m_pixmaps[picServiceGroup] :
 652                                         (orbpos == 0xFFFF) ? m_pixmaps[picDVB_C] :
 653                                         (orbpos == 0xEEEE) ? m_pixmaps[picDVB_T] : m_pixmaps[picDVB_S];
 654                                 if (pixmap)
 655                                 {
 656                                         eSize pixmap_size = pixmap->size();
 657                                         int p = celServiceInfo;
 658                                         if (e == celFolderPixmap)
 659                                                 p = celServiceName;
 660                                         else if (e == celMarkerPixmap)
 661                                                 p = celServiceNumber;
 662                                         eRect area = m_element_position[p];
 663                                         int correction = (area.height() - pixmap_size.height()) / 2;
 664
 665                                         if (isPlayable)
 666                                         {
 667                                                 if (e != celServiceTypePixmap)
 668                                                         continue;
 669                                                 m_element_position[celServiceInfo] = area;
 670                                                 m_element_position[celServiceInfo].setLeft(area.left() + pixmap_size.width() + 8);
 671                                                 m_element_position[celServiceInfo].setWidth(area.width() - pixmap_size.width() - 8);
 672                                         }
 673                                         else if (m_cursor->flags & eServiceReference::isDirectory)
 674                                         {
 675                                                 if (e != celFolderPixmap)
 676                                                         continue;
 677                                                 xoffset = pixmap_size.width() + 8;
 678                                         }
 679                                         else if (m_cursor->flags & eServiceReference::isMarker)
 680                                         {
 681                                                 if (e != celMarkerPixmap)
 682                                                         continue;
 683                                         }
 684                                         else
 685                                                 eFatal("unknown service type in listboxservice");
 686
 687                                         area.moveBy(offset);
 688                                         painter.clip(area);
 689                                         painter.blit(pixmap, offset+ePoint(area.left(), correction), area, gPainter::BT_ALPHATEST);
 690                                         painter.clippop();
 691                                 }
 692                         }
 693                         else if (e == celServiceEventProgressbar)
 694                         {
 695                                 eRect area = m_element_position[celServiceEventProgressbar];
 696                                 if (area.width() > 0 && (isPlayable || isMarker))
 697                                 {
 698                                         // we schedule it to paint it as last element.. so we dont need to reset fore/background color
 699                                         paintProgress = isPlayable;
 700                                         xoffset = area.width() + 10;
 701                                 }
 702                         }
 703                 }
 704                 if (selected && (!local_style || !local_style->m_selection))
 705                         style.drawFrame(painter, eRect(offset, m_itemsize), eWindowStyle::frameListboxEntry);
 706                 if (paintProgress && evt)
 707                 {
 708                         eRect area = m_element_position[celServiceEventProgressbar];
 709                         if (!selected && m_color_set[serviceEventProgressbarBorderColor])
 710                                 painter.setForegroundColor(m_color[serviceEventProgressbarBorderColor]);
 711                         else if (selected && m_color_set[serviceEventProgressbarBorderColorSelected])
 712                                 painter.setForegroundColor(m_color[serviceEventProgressbarBorderColorSelected]);
 713
 714                         int border = 1;
 715                         int progressH = 6;
 716                         int progressX = area.left() + offset.x();
 717                         int progressW = area.width() - 2 * border;
 718                         int progressT = offset.y() + (m_itemsize.height() - progressH - 2*border) / 2;
 719
 720                         // paint progressbar frame
 721                         painter.fill(eRect(progressX, progressT, area.width(), border));
 722                         painter.fill(eRect(progressX, progressT + border, border, progressH));
 723                         painter.fill(eRect(progressX, progressT + progressH + border, area.width(), border));
 724                         painter.fill(eRect(progressX + area.width() - border, progressT + border, border, progressH));
 725
 726                         // calculate value
 727                         time_t now = time(0);
 728                         int value = progressW * (now - evt->getBeginTime()) / evt->getDuration();
 729
 730                         eRect tmp = eRect(progressX + border, progressT + border, value, progressH);
 731                         ePtr<gPixmap> &pixmap = m_pixmaps[picServiceEventProgressbar];
 732                         if (pixmap)
 733                         {
 734                                 area.moveBy(offset);
 735                                 painter.clip(area);
 736                                 painter.blit(pixmap, ePoint(progressX + border, progressT + border), tmp, gPainter::BT_ALPHATEST);
 737                                 painter.clippop();
 738                         }
 739                         else
 740                         {
 741                                 if (!selected && m_color_set[serviceEventProgressbarColor])
 742                                         painter.setForegroundColor(m_color[serviceEventProgressbarColor]);
 743                                 else if (selected && m_color_set[serviceEventProgressbarColorSelected])
 744                                         painter.setForegroundColor(m_color[serviceEventProgressbarColorSelected]);
 745                                 painter.fill(tmp);
 746                         }
 747                 }
 748         }
 749         painter.clippop();
 750 }
 751
 752 void eListboxServiceContent::setIgnoreService( const eServiceReference &service )
 753 {
 754         m_is_playable_ignore=service;
 755         if (m_listbox && m_listbox->isVisible())
 756                 m_listbox->invalidate();
 757 }
 758
 759 void eListboxServiceContent::setItemHeight(int height)
 760 {
 761         m_itemheight = height;
 762         if (m_listbox)
 763                 m_listbox->setItemHeight(height);
 764 }