code.vuplus.com Git - vuplus_dvbapp/blob - lib/gdi/grc.cpp

   1 #include <unistd.h>
   2 #include <lib/gdi/grc.h>
   3 #include <lib/gdi/font.h>
   4 #include <lib/base/init.h>
   5 #include <lib/base/init_num.h>
   6 #ifdef USE_LIBVUGLES2
   7 #include <vuplus_gles.h>
   8 #endif
   9
  10 #ifndef SYNC_PAINT
  11 void *gRC::thread_wrapper(void *ptr)
  12 {
  13         return ((gRC*)ptr)->thread();
  14 }
  15 #endif
  16
  17 gRC *gRC::instance=0;
  18
  19 gRC::gRC(): rp(0), wp(0)
  20 #ifdef SYNC_PAINT
  21 ,m_notify_pump(eApp, 0)
  22 #else
  23 ,m_notify_pump(eApp, 1)
  24 #endif
  25 {
  26         ASSERT(!instance);
  27         instance=this;
  28         CONNECT(m_notify_pump.recv_msg, gRC::recv_notify);
  29 #ifndef SYNC_PAINT
  30         pthread_mutex_init(&mutex, 0);
  31         pthread_cond_init(&cond, 0);
  32         int res = pthread_create(&the_thread, 0, thread_wrapper, this);
  33         if (res)
  34                 eFatal("RC thread couldn't be created");
  35         else
  36                 eDebug("RC thread created successfully");
  37 #endif
  38         m_spinner_enabled = 0;
  39 }
  40
  41 DEFINE_REF(gRC);
  42
  43 gRC::~gRC()
  44 {
  45         instance=0;
  46
  47         gOpcode o;
  48         o.opcode=gOpcode::shutdown;
  49         submit(o);
  50 #ifndef SYNC_PAINT
  51         eDebug("waiting for gRC thread shutdown");
  52         pthread_join(the_thread, 0);
  53         eDebug("gRC thread has finished");
  54 #endif
  55 }
  56
  57 void gRC::submit(const gOpcode &o)
  58 {
  59         while(1)
  60         {
  61 #ifndef SYNC_PAINT
  62                 pthread_mutex_lock(&mutex);
  63 #endif
  64                 int tmp=wp+1;
  65                 if ( tmp == MAXSIZE )
  66                         tmp=0;
  67                 if ( tmp == rp )
  68                 {
  69 #ifndef SYNC_PAINT
  70                         pthread_cond_signal(&cond);  // wakeup gdi thread
  71                         pthread_mutex_unlock(&mutex);
  72 #else
  73                         thread();
  74 #endif
  75                         //printf("render buffer full...\n");
  76                         //fflush(stdout);
  77                         usleep(1000);  // wait 1 msec
  78                         continue;
  79                 }
  80                 int free=rp-wp;
  81                 if ( free <= 0 )
  82                         free+=MAXSIZE;
  83                 queue[wp++]=o;
  84                 if ( wp == MAXSIZE )
  85                         wp = 0;
  86                 if (o.opcode==gOpcode::flush||o.opcode==gOpcode::shutdown||o.opcode==gOpcode::notify)
  87 #ifndef SYNC_PAINT
  88                         pthread_cond_signal(&cond);  // wakeup gdi thread
  89                 pthread_mutex_unlock(&mutex);
  90 #else
  91                         thread(); // paint
  92 #endif
  93                 break;
  94         }
  95 }
  96
  97 void *gRC::thread()
  98 {
  99         int need_notify = 0;
 100 #ifdef USE_LIBVUGLES2
 101         if (gles_open()) {
 102                 gles_state_open();
 103                 gles_viewport(720, 576, 720 * 4);
 104         }
 105 #endif
 106 #ifndef SYNC_PAINT
 107         while (1)
 108         {
 109 #else
 110         while (rp != wp)
 111         {
 112 #endif
 113 #ifndef SYNC_PAINT
 114                 pthread_mutex_lock(&mutex);
 115 #endif
 116                 if ( rp != wp )
 117                 {
 118                                 /* make sure the spinner is not displayed when we something is painted */
 119                         disableSpinner();
 120
 121                         gOpcode o(queue[rp++]);
 122                         if ( rp == MAXSIZE )
 123                                 rp=0;
 124 #ifndef SYNC_PAINT
 125                         pthread_mutex_unlock(&mutex);
 126 #endif
 127                         if (o.opcode==gOpcode::shutdown)
 128                                 break;
 129                         else if (o.opcode==gOpcode::notify)
 130                                 need_notify = 1;
 131                         else if (o.opcode==gOpcode::setCompositing)
 132                         {
 133                                 m_compositing = o.parm.setCompositing;
 134                                 m_compositing->Release();
 135                         } else if(o.dc)
 136                         {
 137                                 o.dc->exec(&o);
 138                                 // o.dc is a gDC* filled with grabref... so we must release it here
 139                                 o.dc->Release();
 140                         }
 141                 }
 142                 else
 143                 {
 144                         if (need_notify)
 145                         {
 146                                 need_notify = 0;
 147                                 m_notify_pump.send(1);
 148                         }
 149 #ifndef SYNC_PAINT
 150                         while(rp == wp)
 151                         {
 152
 153                                         /* when the main thread is non-idle for a too long time without any display output,
 154                                            we want to display a spinner. */
 155                                 struct timespec timeout;
 156                                 clock_gettime(CLOCK_REALTIME, &timeout);
 157
 158                                 if (m_spinner_enabled)
 159                                 {
 160                                         timeout.tv_nsec += 100*1000*1000;
 161                                         /* yes, this is required. */
 162                                         if (timeout.tv_nsec > 1000*1000*1000)
 163                                         {
 164                                                 timeout.tv_nsec -= 1000*1000*1000;
 165                                                 timeout.tv_sec++;
 166                                         }
 167                                 }
 168                                 else
 169                                         timeout.tv_sec += 2;
 170
 171                                 int idle = 1;
 172
 173                                 if (pthread_cond_timedwait(&cond, &mutex, &timeout) == ETIMEDOUT)
 174                                 {
 175                                         if (eApp && !eApp->isIdle())
 176                                         {
 177                                                 int idle_count = eApp->idleCount();
 178                                                 if (idle_count == m_prev_idle_count)
 179                                                         idle = 0;
 180                                                 else
 181                                                         m_prev_idle_count = idle_count;
 182                                         }
 183                                 }
 184
 185                                 if (!idle)
 186                                 {
 187                                         if (!m_spinner_enabled)
 188                                                 eDebug("main thread is non-idle! display spinner!");
 189                                         enableSpinner();
 190                                 } else
 191                                         disableSpinner();
 192                         }
 193                         pthread_mutex_unlock(&mutex);
 194 #endif
 195                 }
 196         }
 197 #ifdef USE_LIBVUGLES2
 198         gles_state_close();
 199         gles_close();
 200 #endif
 201 #ifndef SYNC_PAINT
 202         pthread_exit(0);
 203 #endif
 204         return 0;
 205 }
 206
 207 void gRC::recv_notify(const int &i)
 208 {
 209         notify();
 210 }
 211
 212 gRC *gRC::getInstance()
 213 {
 214         return instance;
 215 }
 216
 217 void gRC::enableSpinner()
 218 {
 219         if (!m_spinner_dc)
 220         {
 221                 eDebug("no spinner DC!");
 222                 return;
 223         }
 224
 225         gOpcode o;
 226         o.opcode = m_spinner_enabled ? gOpcode::incrementSpinner : gOpcode::enableSpinner;
 227         m_spinner_dc->exec(&o);
 228         m_spinner_enabled = 1;
 229         o.opcode = gOpcode::flush;
 230         m_spinner_dc->exec(&o);
 231 }
 232
 233 void gRC::disableSpinner()
 234 {
 235         if (!m_spinner_enabled)
 236                 return;
 237
 238         if (!m_spinner_dc)
 239         {
 240                 eDebug("no spinner DC!");
 241                 return;
 242         }
 243
 244         m_spinner_enabled = 0;
 245
 246         gOpcode o;
 247         o.opcode = gOpcode::disableSpinner;
 248         m_spinner_dc->exec(&o);
 249         o.opcode = gOpcode::flush;
 250         m_spinner_dc->exec(&o);
 251 }
 252
 253 static int gPainter_instances;
 254
 255 gPainter::gPainter(gDC *dc, eRect rect): m_dc(dc), m_rc(gRC::getInstance())
 256 {
 257 //      ASSERT(!gPainter_instances);
 258         gPainter_instances++;
 259 //      begin(rect);
 260 }
 261
 262 gPainter::~gPainter()
 263 {
 264         end();
 265         gPainter_instances--;
 266 }
 267
 268 void gPainter::setBackgroundColor(const gColor &color)
 269 {
 270         if ( m_dc->islocked() )
 271                 return;
 272         gOpcode o;
 273         o.opcode = gOpcode::setBackgroundColor;
 274         o.dc = m_dc.grabRef();
 275         o.parm.setColor = new gOpcode::para::psetColor;
 276         o.parm.setColor->color = color;
 277
 278         m_rc->submit(o);
 279 }
 280
 281 void gPainter::setForegroundColor(const gColor &color)
 282 {
 283         if ( m_dc->islocked() )
 284                 return;
 285         gOpcode o;
 286         o.opcode = gOpcode::setForegroundColor;
 287         o.dc = m_dc.grabRef();
 288         o.parm.setColor = new gOpcode::para::psetColor;
 289         o.parm.setColor->color = color;
 290
 291         m_rc->submit(o);
 292 }
 293
 294 void gPainter::setBackgroundColor(const gRGB &color)
 295 {
 296         if ( m_dc->islocked() )
 297                 return;
 298         gOpcode o;
 299         o.opcode = gOpcode::setBackgroundColorRGB;
 300         o.dc = m_dc.grabRef();
 301         o.parm.setColorRGB = new gOpcode::para::psetColorRGB;
 302         o.parm.setColorRGB->color = color;
 303
 304         m_rc->submit(o);
 305 }
 306
 307 void gPainter::setForegroundColor(const gRGB &color)
 308 {
 309         if ( m_dc->islocked() )
 310                 return;
 311         gOpcode o;
 312         o.opcode = gOpcode::setForegroundColorRGB;
 313         o.dc = m_dc.grabRef();
 314         o.parm.setColorRGB = new gOpcode::para::psetColorRGB;
 315         o.parm.setColorRGB->color = color;
 316
 317         m_rc->submit(o);
 318 }
 319
 320 void gPainter::setFont(gFont *font)
 321 {
 322         if ( m_dc->islocked() )
 323                 return;
 324         gOpcode o;
 325         o.opcode = gOpcode::setFont;
 326         o.dc = m_dc.grabRef();
 327         font->AddRef();
 328         o.parm.setFont = new gOpcode::para::psetFont;
 329         o.parm.setFont->font = font;
 330
 331         m_rc->submit(o);
 332 }
 333
 334 void gPainter::renderText(const eRect &pos, const std::string &string, int flags, gRGB bordercolor, int border)
 335 {
 336         if ( m_dc->islocked() )
 337                 return;
 338         gOpcode o;
 339         o.opcode=gOpcode::renderText;
 340         o.dc = m_dc.grabRef();
 341         o.parm.renderText = new gOpcode::para::prenderText;
 342         o.parm.renderText->area = pos;
 343         o.parm.renderText->text = string.empty()?0:strdup(string.c_str());
 344         o.parm.renderText->flags = flags;
 345         o.parm.renderText->border = border;
 346         o.parm.renderText->bordercolor = bordercolor;
 347         m_rc->submit(o);
 348 }
 349
 350 void gPainter::renderPara(eTextPara *para, ePoint offset)
 351 {
 352         if ( m_dc->islocked() )
 353                 return;
 354         ASSERT(para);
 355         gOpcode o;
 356         o.opcode=gOpcode::renderPara;
 357         o.dc = m_dc.grabRef();
 358         o.parm.renderPara = new gOpcode::para::prenderPara;
 359         o.parm.renderPara->offset = offset;
 360
 361         para->AddRef();
 362         o.parm.renderPara->textpara = para;
 363         m_rc->submit(o);
 364 }
 365
 366 void gPainter::fill(const eRect &area)
 367 {
 368         if ( m_dc->islocked() )
 369                 return;
 370         gOpcode o;
 371         o.opcode=gOpcode::fill;
 372
 373         o.dc = m_dc.grabRef();
 374         o.parm.fill = new gOpcode::para::pfillRect;
 375         o.parm.fill->area = area;
 376         m_rc->submit(o);
 377 }
 378
 379 void gPainter::fill(const gRegion &region)
 380 {
 381         if ( m_dc->islocked() )
 382                 return;
 383         gOpcode o;
 384         o.opcode=gOpcode::fillRegion;
 385
 386         o.dc = m_dc.grabRef();
 387         o.parm.fillRegion = new gOpcode::para::pfillRegion;
 388         o.parm.fillRegion->region = region;
 389         m_rc->submit(o);
 390 }
 391
 392 void gPainter::clear()
 393 {
 394         if ( m_dc->islocked() )
 395                 return;
 396         gOpcode o;
 397         o.opcode=gOpcode::clear;
 398         o.dc = m_dc.grabRef();
 399         o.parm.fill = new gOpcode::para::pfillRect;
 400         o.parm.fill->area = eRect();
 401         m_rc->submit(o);
 402 }
 403
 404 void gPainter::blit(gPixmap *pixmap, ePoint pos, const eRect &clip, int flags)
 405 {
 406         blitScale(pixmap, eRect(pos, eSize()), clip, flags, 0);
 407 }
 408
 409 void gPainter::blitScale(gPixmap *pixmap, const eRect &position, const eRect &clip, int flags, int aflags)
 410 {
 411         flags |= aflags;
 412
 413         if ( m_dc->islocked() )
 414                 return;
 415         gOpcode o;
 416
 417         ASSERT(pixmap);
 418
 419         o.opcode=gOpcode::blit;
 420         o.dc = m_dc.grabRef();
 421         pixmap->AddRef();
 422         o.parm.blit  = new gOpcode::para::pblit;
 423         o.parm.blit->pixmap = pixmap;
 424         o.parm.blit->clip = clip;
 425         o.parm.blit->flags = flags;
 426         o.parm.blit->position = position;
 427         m_rc->submit(o);
 428 }
 429
 430 void gPainter::setPalette(gRGB *colors, int start, int len)
 431 {
 432         if ( m_dc->islocked() )
 433                 return;
 434         ASSERT(colors);
 435         gOpcode o;
 436         o.opcode=gOpcode::setPalette;
 437         o.dc = m_dc.grabRef();
 438         gPalette *p=new gPalette;
 439
 440         o.parm.setPalette = new gOpcode::para::psetPalette;
 441         p->data=new gRGB[len];
 442
 443         memcpy(p->data, colors, len*sizeof(gRGB));
 444         p->start=start;
 445         p->colors=len;
 446         o.parm.setPalette->palette = p;
 447         m_rc->submit(o);
 448 }
 449
 450 void gPainter::setPalette(gPixmap *source)
 451 {
 452         ASSERT(source);
 453         setPalette(source->surface->clut.data, source->surface->clut.start, source->surface->clut.colors);
 454 }
 455
 456 void gPainter::mergePalette(gPixmap *target)
 457 {
 458         if ( m_dc->islocked() )
 459                 return;
 460         ASSERT(target);
 461         gOpcode o;
 462         o.opcode = gOpcode::mergePalette;
 463         o.dc = m_dc.grabRef();
 464         target->AddRef();
 465         o.parm.mergePalette = new gOpcode::para::pmergePalette;
 466         o.parm.mergePalette->target = target;
 467         m_rc->submit(o);
 468 }
 469
 470 void gPainter::line(ePoint start, ePoint end)
 471 {
 472         if ( m_dc->islocked() )
 473                 return;
 474         gOpcode o;
 475         o.opcode=gOpcode::line;
 476         o.dc = m_dc.grabRef();
 477         o.parm.line = new gOpcode::para::pline;
 478         o.parm.line->start = start;
 479         o.parm.line->end = end;
 480         m_rc->submit(o);
 481 }
 482
 483 void gPainter::setOffset(ePoint val)
 484 {
 485         if ( m_dc->islocked() )
 486                 return;
 487         gOpcode o;
 488         o.opcode=gOpcode::setOffset;
 489         o.dc = m_dc.grabRef();
 490         o.parm.setOffset = new gOpcode::para::psetOffset;
 491         o.parm.setOffset->rel = 0;
 492         o.parm.setOffset->value = val;
 493         m_rc->submit(o);
 494 }
 495
 496 void gPainter::moveOffset(ePoint rel)
 497 {
 498         if ( m_dc->islocked() )
 499                 return;
 500         gOpcode o;
 501         o.opcode=gOpcode::setOffset;
 502         o.dc = m_dc.grabRef();
 503         o.parm.setOffset = new gOpcode::para::psetOffset;
 504         o.parm.setOffset->rel = 1;
 505         o.parm.setOffset->value = rel;
 506         m_rc->submit(o);
 507 }
 508
 509 void gPainter::resetOffset()
 510 {
 511         if ( m_dc->islocked() )
 512                 return;
 513         gOpcode o;
 514         o.opcode=gOpcode::setOffset;
 515         o.dc = m_dc.grabRef();
 516         o.parm.setOffset = new gOpcode::para::psetOffset;
 517         o.parm.setOffset->rel = 0;
 518         o.parm.setOffset->value = ePoint(0, 0);
 519         m_rc->submit(o);
 520 }
 521
 522 void gPainter::resetClip(const gRegion &region)
 523 {
 524         if ( m_dc->islocked() )
 525                 return;
 526         gOpcode o;
 527         o.opcode = gOpcode::setClip;
 528         o.dc = m_dc.grabRef();
 529         o.parm.clip = new gOpcode::para::psetClip;
 530         o.parm.clip->region = region;
 531         m_rc->submit(o);
 532 }
 533
 534 void gPainter::clip(const gRegion &region)
 535 {
 536         if ( m_dc->islocked() )
 537                 return;
 538         gOpcode o;
 539         o.opcode = gOpcode::addClip;
 540         o.dc = m_dc.grabRef();
 541         o.parm.clip = new gOpcode::para::psetClip;
 542         o.parm.clip->region = region;
 543         m_rc->submit(o);
 544 }
 545
 546 void gPainter::clippop()
 547 {
 548         if ( m_dc->islocked() )
 549                 return;
 550         gOpcode o;
 551         o.opcode = gOpcode::popClip;
 552         o.dc = m_dc.grabRef();
 553         m_rc->submit(o);
 554 }
 555
 556 void gPainter::waitVSync()
 557 {
 558         if ( m_dc->islocked() )
 559                 return;
 560         gOpcode o;
 561         o.opcode = gOpcode::waitVSync;
 562         o.dc = m_dc.grabRef();
 563         m_rc->submit(o);
 564 }
 565
 566 void gPainter::flip()
 567 {
 568         if ( m_dc->islocked() )
 569                 return;
 570         gOpcode o;
 571         o.opcode = gOpcode::flip;
 572         o.dc = m_dc.grabRef();
 573         m_rc->submit(o);
 574 }
 575
 576 void gPainter::notify()
 577 {
 578         if ( m_dc->islocked() )
 579                 return;
 580         gOpcode o;
 581         o.opcode = gOpcode::notify;
 582         o.dc = m_dc.grabRef();
 583         m_rc->submit(o);
 584 }
 585
 586 void gPainter::setCompositing(gCompositingData *comp)
 587 {
 588         gOpcode o;
 589         o.opcode = gOpcode::setCompositing;
 590         o.dc = 0;
 591         o.parm.setCompositing = comp;
 592         comp->AddRef(); /* will be freed in ::thread */
 593         m_rc->submit(o);
 594 }
 595
 596 void gPainter::flush()
 597 {
 598         if ( m_dc->islocked() )
 599                 return;
 600         gOpcode o;
 601         o.opcode = gOpcode::flush;
 602         o.dc = m_dc.grabRef();
 603         m_rc->submit(o);
 604 }
 605
 606 void gPainter::end()
 607 {
 608         if ( m_dc->islocked() )
 609                 return;
 610 }
 611
 612 void gPainter::sendShow(ePoint point, eSize size)
 613 {
 614         if ( m_dc->islocked() )
 615                 return;
 616         gOpcode o;
 617         o.opcode=gOpcode::sendShow;
 618         o.dc = m_dc.grabRef();
 619         o.parm.setShowHideInfo = new gOpcode::para::psetShowHideInfo;
 620         o.parm.setShowHideInfo->point = point;
 621         o.parm.setShowHideInfo->size = size;
 622         m_rc->submit(o);
 623 }
 624
 625 void gPainter::sendHide(ePoint point, eSize size)
 626 {
 627         if ( m_dc->islocked() )
 628                 return;
 629         gOpcode o;
 630         o.opcode=gOpcode::sendHide;
 631         o.dc = m_dc.grabRef();
 632         o.parm.setShowHideInfo = new gOpcode::para::psetShowHideInfo;
 633         o.parm.setShowHideInfo->point = point;
 634         o.parm.setShowHideInfo->size = size;
 635         m_rc->submit(o);
 636 }
 637
 638 #ifdef USE_LIBVUGLES2
 639 void gPainter::setView(eSize size)
 640 {
 641         if ( m_dc->islocked() )
 642                 return;
 643         gOpcode o;
 644         o.opcode=gOpcode::setView;
 645         o.dc = m_dc.grabRef();
 646         o.parm.setViewInfo = new gOpcode::para::psetViewInfo;
 647         o.parm.setViewInfo->size = size;
 648         m_rc->submit(o);
 649 }
 650 #endif
 651
 652 gDC::gDC()
 653 {
 654         m_spinner_pic = 0;
 655 }
 656
 657 gDC::gDC(gPixmap *pixmap): m_pixmap(pixmap)
 658 {
 659         m_spinner_pic = 0;
 660 }
 661
 662 gDC::~gDC()
 663 {
 664         delete[] m_spinner_pic;
 665 }
 666
 667 void gDC::exec(const gOpcode *o)
 668 {
 669         switch (o->opcode)
 670         {
 671         case gOpcode::setBackgroundColor:
 672                 m_background_color = o->parm.setColor->color;
 673                 m_background_color_rgb = getRGB(m_background_color);
 674                 delete o->parm.setColor;
 675                 break;
 676         case gOpcode::setForegroundColor:
 677                 m_foreground_color = o->parm.setColor->color;
 678                 m_background_color_rgb = getRGB(m_foreground_color);
 679                 delete o->parm.setColor;
 680                 break;
 681         case gOpcode::setBackgroundColorRGB:
 682                 if (m_pixmap->needClut())
 683                         m_background_color = m_pixmap->surface->clut.findColor(o->parm.setColorRGB->color);
 684                 m_background_color_rgb = o->parm.setColorRGB->color;
 685                 delete o->parm.setColorRGB;
 686                 break;
 687         case gOpcode::setForegroundColorRGB:
 688                 if (m_pixmap->needClut())
 689                         m_foreground_color = m_pixmap->surface->clut.findColor(o->parm.setColorRGB->color);
 690                 m_foreground_color_rgb = o->parm.setColorRGB->color;
 691                 delete o->parm.setColorRGB;
 692                 break;
 693         case gOpcode::setFont:
 694                 m_current_font = o->parm.setFont->font;
 695                 o->parm.setFont->font->Release();
 696                 delete o->parm.setFont;
 697                 break;
 698         case gOpcode::renderText:
 699         {
 700                 ePtr<eTextPara> para = new eTextPara(o->parm.renderText->area);
 701                 int flags = o->parm.renderText->flags;
 702                 ASSERT(m_current_font);
 703                 para->setFont(m_current_font);
 704                 para->renderString(o->parm.renderText->text, (flags & gPainter::RT_WRAP) ? RS_WRAP : 0, o->parm.renderText->border);
 705                 if (o->parm.renderText->text)
 706                         free(o->parm.renderText->text);
 707                 if (flags & gPainter::RT_HALIGN_RIGHT)
 708                         para->realign(eTextPara::dirRight);
 709                 else if (flags & gPainter::RT_HALIGN_CENTER)
 710                         para->realign(eTextPara::dirCenter);
 711                 else if (flags & gPainter::RT_HALIGN_BLOCK)
 712                         para->realign(eTextPara::dirBlock);
 713
 714                 ePoint offset = m_current_offset;
 715
 716                 if (o->parm.renderText->flags & gPainter::RT_VALIGN_CENTER)
 717                 {
 718                         eRect bbox = para->getBoundBox();
 719                         int vcentered_top = o->parm.renderText->area.top() + ((o->parm.renderText->area.height() - bbox.height()) / 2);
 720                         int correction = vcentered_top - bbox.top();
 721                         offset += ePoint(0, correction);
 722                 }
 723
 724                 if (o->parm.renderText->border)
 725                 {
 726                         para->blit(*this, offset, m_background_color_rgb, o->parm.renderText->bordercolor, true);
 727                         para->blit(*this, offset, o->parm.renderText->bordercolor, m_foreground_color_rgb);
 728                 }
 729                 else
 730                         para->blit(*this, offset, m_background_color_rgb, m_foreground_color_rgb);
 731                 delete o->parm.renderText;
 732                 break;
 733         }
 734         case gOpcode::renderPara:
 735         {
 736                 o->parm.renderPara->textpara->blit(*this, o->parm.renderPara->offset + m_current_offset, m_background_color_rgb, m_foreground_color_rgb);
 737                 o->parm.renderPara->textpara->Release();
 738                 delete o->parm.renderPara;
 739                 break;
 740         }
 741         case gOpcode::fill:
 742         {
 743                 eRect area = o->parm.fill->area;
 744                 area.moveBy(m_current_offset);
 745                 gRegion clip = m_current_clip & area;
 746                 if (m_pixmap->needClut())
 747                         m_pixmap->fill(clip, m_foreground_color);
 748                 else
 749                         m_pixmap->fill(clip, m_foreground_color_rgb);
 750                 delete o->parm.fill;
 751                 break;
 752         }
 753         case gOpcode::fillRegion:
 754         {
 755                 o->parm.fillRegion->region.moveBy(m_current_offset);
 756                 gRegion clip = m_current_clip & o->parm.fillRegion->region;
 757                 if (m_pixmap->needClut())
 758                         m_pixmap->fill(clip, m_foreground_color);
 759                 else
 760                         m_pixmap->fill(clip, m_foreground_color_rgb);
 761                 delete o->parm.fillRegion;
 762                 break;
 763         }
 764         case gOpcode::clear:
 765                 if (m_pixmap->needClut())
 766                         m_pixmap->fill(m_current_clip, m_background_color);
 767                 else
 768                         m_pixmap->fill(m_current_clip, m_background_color_rgb);
 769                 delete o->parm.fill;
 770                 break;
 771         case gOpcode::blit:
 772         {
 773                 gRegion clip;
 774                                 // this code should be checked again but i'm too tired now
 775
 776                 o->parm.blit->position.moveBy(m_current_offset);
 777
 778                 if (o->parm.blit->clip.valid())
 779                 {
 780                         o->parm.blit->clip.moveBy(m_current_offset);
 781                         clip.intersect(gRegion(o->parm.blit->clip), m_current_clip);
 782                 } else
 783                         clip = m_current_clip;
 784
 785                 m_pixmap->blit(*o->parm.blit->pixmap, o->parm.blit->position, clip, o->parm.blit->flags);
 786                 o->parm.blit->pixmap->Release();
 787                 delete o->parm.blit;
 788                 break;
 789         }
 790         case gOpcode::setPalette:
 791                 if (o->parm.setPalette->palette->start > m_pixmap->surface->clut.colors)
 792                         o->parm.setPalette->palette->start = m_pixmap->surface->clut.colors;
 793                 if (o->parm.setPalette->palette->colors > (m_pixmap->surface->clut.colors-o->parm.setPalette->palette->start))
 794                         o->parm.setPalette->palette->colors = m_pixmap->surface->clut.colors-o->parm.setPalette->palette->start;
 795                 if (o->parm.setPalette->palette->colors)
 796                         memcpy(m_pixmap->surface->clut.data+o->parm.setPalette->palette->start, o->parm.setPalette->palette->data, o->parm.setPalette->palette->colors*sizeof(gRGB));
 797
 798                 delete[] o->parm.setPalette->palette->data;
 799                 delete o->parm.setPalette->palette;
 800                 delete o->parm.setPalette;
 801                 break;
 802         case gOpcode::mergePalette:
 803                 m_pixmap->mergePalette(*o->parm.mergePalette->target);
 804                 o->parm.mergePalette->target->Release();
 805                 delete o->parm.mergePalette;
 806                 break;
 807         case gOpcode::line:
 808         {
 809                 ePoint start = o->parm.line->start + m_current_offset, end = o->parm.line->end + m_current_offset;
 810                 m_pixmap->line(m_current_clip, start, end, m_foreground_color);
 811                 delete o->parm.line;
 812                 break;
 813         }
 814         case gOpcode::addClip:
 815                 m_clip_stack.push(m_current_clip);
 816                 o->parm.clip->region.moveBy(m_current_offset);
 817                 m_current_clip &= o->parm.clip->region;
 818                 delete o->parm.clip;
 819                 break;
 820         case gOpcode::setClip:
 821                 o->parm.clip->region.moveBy(m_current_offset);
 822                 m_current_clip = o->parm.clip->region & eRect(ePoint(0, 0), m_pixmap->size());
 823                 delete o->parm.clip;
 824                 break;
 825         case gOpcode::popClip:
 826                 if (!m_clip_stack.empty())
 827                 {
 828                         m_current_clip = m_clip_stack.top();
 829                         m_clip_stack.pop();
 830                 }
 831                 break;
 832         case gOpcode::setOffset:
 833                 if (o->parm.setOffset->rel)
 834                         m_current_offset += o->parm.setOffset->value;
 835                 else
 836                         m_current_offset  = o->parm.setOffset->value;
 837                 delete o->parm.setOffset;
 838                 break;
 839         case gOpcode::waitVSync:
 840                 break;
 841         case gOpcode::flip:
 842                 break;
 843         case gOpcode::flush:
 844                 break;
 845         case gOpcode::sendShow:
 846                 break;
 847         case gOpcode::sendHide:
 848                 break;
 849 #ifdef USE_LIBVUGLES2
 850         case gOpcode::setView:
 851                 break;
 852 #endif
 853         case gOpcode::enableSpinner:
 854                 enableSpinner();
 855                 break;
 856         case gOpcode::disableSpinner:
 857                 disableSpinner();
 858                 break;
 859         case gOpcode::incrementSpinner:
 860                 incrementSpinner();
 861                 break;
 862         default:
 863                 eFatal("illegal opcode %d. expect memory leak!", o->opcode);
 864         }
 865 }
 866
 867 gRGB gDC::getRGB(gColor col)
 868 {
 869         if ((!m_pixmap) || (!m_pixmap->surface->clut.data))
 870                 return gRGB(col, col, col);
 871         if (col<0)
 872         {
 873                 eFatal("bla transp");
 874                 return gRGB(0, 0, 0, 0xFF);
 875         }
 876         return m_pixmap->surface->clut.data[col];
 877 }
 878
 879 void gDC::enableSpinner()
 880 {
 881         ASSERT(m_spinner_saved);
 882
 883                 /* save the background to restore it later. We need to negative position because we want to blit from the middle of the screen. */
 884         m_spinner_saved->blit(*m_pixmap, eRect(-m_spinner_pos.topLeft(), eSize()), gRegion(eRect(ePoint(0, 0), m_spinner_saved->size())), 0);
 885
 886         incrementSpinner();
 887 }
 888
 889 void gDC::disableSpinner()
 890 {
 891         ASSERT(m_spinner_saved);
 892
 893                 /* restore background */
 894         m_pixmap->blit(*m_spinner_saved, eRect(m_spinner_pos.topLeft(), eSize()), gRegion(m_spinner_pos), 0);
 895 }
 896
 897 void gDC::incrementSpinner()
 898 {
 899         ASSERT(m_spinner_saved);
 900
 901         static int blub;
 902         blub++;
 903
 904 #if 0
 905         int i;
 906
 907         for (i = 0; i < 5; ++i)
 908         {
 909                 int x = i * 20 + m_spinner_pos.left();
 910                 int y = m_spinner_pos.top();
 911
 912                 int col = ((blub - i) * 30) % 256;
 913
 914                 m_pixmap->fill(eRect(x, y, 10, 10), gRGB(col, col, col));
 915         }
 916 #endif
 917
 918         m_spinner_temp->blit(*m_spinner_saved, eRect(0, 0, 0, 0), eRect(ePoint(0, 0), m_spinner_pos.size()));
 919
 920         if (m_spinner_pic[m_spinner_i])
 921                 m_spinner_temp->blit(*m_spinner_pic[m_spinner_i], eRect(0, 0, 0, 0), eRect(ePoint(0, 0), m_spinner_pos.size()), gPixmap::blitAlphaTest);
 922
 923         m_pixmap->blit(*m_spinner_temp, eRect(m_spinner_pos.topLeft(), eSize()), gRegion(m_spinner_pos), 0);
 924         m_spinner_i++;
 925         m_spinner_i %= m_spinner_num;
 926 }
 927
 928 void gDC::setSpinner(eRect pos, ePtr<gPixmap> *pic, int len)
 929 {
 930         ASSERT(m_pixmap);
 931         ASSERT(m_pixmap->surface);
 932         m_spinner_saved = new gPixmap(pos.size(), m_pixmap->surface->bpp);
 933         m_spinner_temp = new gPixmap(pos.size(), m_pixmap->surface->bpp);
 934         m_spinner_pos = pos;
 935
 936         m_spinner_i = 0;
 937         m_spinner_num = len;
 938
 939         int i;
 940         if (m_spinner_pic)
 941                 delete[] m_spinner_pic;
 942
 943         m_spinner_pic = new ePtr<gPixmap>[len];
 944
 945         for (i = 0; i < len; ++i)
 946                 m_spinner_pic[i] = pic[i];
 947 }
 948
 949 DEFINE_REF(gDC);
 950
 951 eAutoInitPtr<gRC> init_grc(eAutoInitNumbers::graphic, "gRC");