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>
8 void *gRC::thread_wrapper(void *ptr)
10 return ((gRC*)ptr)->thread();
16 gRC::gRC(): rp(0), wp(0)
18 ,m_notify_pump(eApp, 0)
20 ,m_notify_pump(eApp, 1)
25 CONNECT(m_notify_pump.recv_msg, gRC::recv_notify);
27 pthread_mutex_init(&mutex, 0);
28 pthread_cond_init(&cond, 0);
29 int res = pthread_create(&the_thread, 0, thread_wrapper, this);
31 eFatal("RC thread couldn't be created");
33 eDebug("RC thread created successfully");
35 m_spinner_enabled = 0;
45 o.opcode=gOpcode::shutdown;
48 eDebug("waiting for gRC thread shutdown");
49 pthread_join(the_thread, 0);
50 eDebug("gRC thread has finished");
54 void gRC::submit(const gOpcode &o)
59 pthread_mutex_lock(&mutex);
67 pthread_cond_signal(&cond); // wakeup gdi thread
68 pthread_mutex_unlock(&mutex);
72 //printf("render buffer full...\n");
74 usleep(1000); // wait 1 msec
83 if (o.opcode==gOpcode::flush||o.opcode==gOpcode::shutdown||o.opcode==gOpcode::notify)
85 pthread_cond_signal(&cond); // wakeup gdi thread
86 pthread_mutex_unlock(&mutex);
105 pthread_mutex_lock(&mutex);
109 /* make sure the spinner is not displayed when we something is painted */
112 gOpcode o(queue[rp++]);
116 pthread_mutex_unlock(&mutex);
118 if (o.opcode==gOpcode::shutdown)
120 else if (o.opcode==gOpcode::notify)
125 // o.dc is a gDC* filled with grabref... so we must release it here
134 m_notify_pump.send(1);
140 /* when the main thread is non-idle for a too long time without any display output,
141 we want to display a spinner. */
144 struct timespec timeout;
145 gettimeofday(&time, NULL);
146 timeout.tv_sec = time.tv_sec;
147 timeout.tv_nsec = time.tv_usec * 1000;
149 if (m_spinner_enabled)
150 timeout.tv_nsec += 100*1000*1000;
154 /* yes, this is required. */
155 if (timeout.tv_nsec > 1000*1000*1000)
157 timeout.tv_nsec -= 1000*1000*1000;
163 if (pthread_cond_timedwait(&cond, &mutex, &timeout) == ETIMEDOUT)
165 if (eApp && !eApp->isIdle())
169 pthread_mutex_unlock(&mutex);
173 if (!m_spinner_enabled)
174 eDebug("main thread is non-idle! display spinner!");
188 void gRC::recv_notify(const int &i)
193 gRC *gRC::getInstance()
198 void gRC::enableSpinner()
202 eDebug("no spinner DC!");
207 o.opcode = m_spinner_enabled ? gOpcode::incrementSpinner : gOpcode::enableSpinner;
208 m_spinner_dc->exec(&o);
209 m_spinner_enabled = 1;
213 void gRC::disableSpinner()
215 if (!m_spinner_enabled)
220 eDebug("no spinner DC!");
224 m_spinner_enabled = 0;
227 o.opcode = gOpcode::disableSpinner;
228 m_spinner_dc->exec(&o);
231 static int gPainter_instances;
233 gPainter::gPainter(gDC *dc, eRect rect): m_dc(dc), m_rc(gRC::getInstance())
235 // ASSERT(!gPainter_instances);
236 gPainter_instances++;
240 gPainter::~gPainter()
243 gPainter_instances--;
246 void gPainter::setBackgroundColor(const gColor &color)
248 if ( m_dc->islocked() )
251 o.opcode = gOpcode::setBackgroundColor;
252 o.dc = m_dc.grabRef();
253 o.parm.setColor = new gOpcode::para::psetColor;
254 o.parm.setColor->color = color;
259 void gPainter::setForegroundColor(const gColor &color)
261 if ( m_dc->islocked() )
264 o.opcode = gOpcode::setForegroundColor;
265 o.dc = m_dc.grabRef();
266 o.parm.setColor = new gOpcode::para::psetColor;
267 o.parm.setColor->color = color;
272 void gPainter::setBackgroundColor(const gRGB &color)
274 if ( m_dc->islocked() )
277 o.opcode = gOpcode::setBackgroundColorRGB;
278 o.dc = m_dc.grabRef();
279 o.parm.setColorRGB = new gOpcode::para::psetColorRGB;
280 o.parm.setColorRGB->color = color;
285 void gPainter::setForegroundColor(const gRGB &color)
287 if ( m_dc->islocked() )
290 o.opcode = gOpcode::setForegroundColorRGB;
291 o.dc = m_dc.grabRef();
292 o.parm.setColorRGB = new gOpcode::para::psetColorRGB;
293 o.parm.setColorRGB->color = color;
298 void gPainter::setFont(gFont *font)
300 if ( m_dc->islocked() )
303 o.opcode = gOpcode::setFont;
304 o.dc = m_dc.grabRef();
306 o.parm.setFont = new gOpcode::para::psetFont;
307 o.parm.setFont->font = font;
312 void gPainter::renderText(const eRect &pos, const std::string &string, int flags)
314 if ( m_dc->islocked() )
317 o.opcode=gOpcode::renderText;
318 o.dc = m_dc.grabRef();
319 o.parm.renderText = new gOpcode::para::prenderText;
320 o.parm.renderText->area = pos;
321 o.parm.renderText->text = string.empty()?0:strdup(string.c_str());
322 o.parm.renderText->flags = flags;
326 void gPainter::renderPara(eTextPara *para, ePoint offset)
328 if ( m_dc->islocked() )
331 o.opcode=gOpcode::renderPara;
332 o.dc = m_dc.grabRef();
333 o.parm.renderPara = new gOpcode::para::prenderPara;
334 o.parm.renderPara->offset = offset;
337 o.parm.renderPara->textpara = para;
341 void gPainter::fill(const eRect &area)
343 if ( m_dc->islocked() )
346 o.opcode=gOpcode::fill;
348 o.dc = m_dc.grabRef();
349 o.parm.fill = new gOpcode::para::pfillRect;
350 o.parm.fill->area = area;
354 void gPainter::fill(const gRegion ®ion)
356 if ( m_dc->islocked() )
359 o.opcode=gOpcode::fillRegion;
361 o.dc = m_dc.grabRef();
362 o.parm.fillRegion = new gOpcode::para::pfillRegion;
363 o.parm.fillRegion->region = region;
367 void gPainter::clear()
369 if ( m_dc->islocked() )
372 o.opcode=gOpcode::clear;
373 o.dc = m_dc.grabRef();
374 o.parm.fill = new gOpcode::para::pfillRect;
375 o.parm.fill->area = eRect();
379 void gPainter::blit(gPixmap *pixmap, ePoint pos, const eRect &clip, int flags)
381 if ( m_dc->islocked() )
387 o.opcode=gOpcode::blit;
388 o.dc = m_dc.grabRef();
390 o.parm.blit = new gOpcode::para::pblit;
391 o.parm.blit->pixmap = pixmap;
392 o.parm.blit->position = pos;
393 o.parm.blit->clip = clip;
394 o.parm.blit->flags=flags;
399 void gPainter::setPalette(gRGB *colors, int start, int len)
401 if ( m_dc->islocked() )
404 o.opcode=gOpcode::setPalette;
405 o.dc = m_dc.grabRef();
406 gPalette *p=new gPalette;
408 o.parm.setPalette = new gOpcode::para::psetPalette;
409 p->data=new gRGB[len];
411 memcpy(p->data, colors, len*sizeof(gRGB));
414 o.parm.setPalette->palette = p;
418 void gPainter::setPalette(gPixmap *source)
421 setPalette(source->surface->clut.data, source->surface->clut.start, source->surface->clut.colors);
424 void gPainter::mergePalette(gPixmap *target)
426 if ( m_dc->islocked() )
429 o.opcode = gOpcode::mergePalette;
430 o.dc = m_dc.grabRef();
432 o.parm.mergePalette = new gOpcode::para::pmergePalette;
433 o.parm.mergePalette->target = target;
437 void gPainter::line(ePoint start, ePoint end)
439 if ( m_dc->islocked() )
442 o.opcode=gOpcode::line;
443 o.dc = m_dc.grabRef();
444 o.parm.line = new gOpcode::para::pline;
445 o.parm.line->start = start;
446 o.parm.line->end = end;
450 void gPainter::setOffset(ePoint val)
452 if ( m_dc->islocked() )
455 o.opcode=gOpcode::setOffset;
456 o.dc = m_dc.grabRef();
457 o.parm.setOffset = new gOpcode::para::psetOffset;
458 o.parm.setOffset->rel = 0;
459 o.parm.setOffset->value = val;
463 void gPainter::moveOffset(ePoint rel)
465 if ( m_dc->islocked() )
468 o.opcode=gOpcode::setOffset;
469 o.dc = m_dc.grabRef();
470 o.parm.setOffset = new gOpcode::para::psetOffset;
471 o.parm.setOffset->rel = 1;
472 o.parm.setOffset->value = rel;
476 void gPainter::resetOffset()
478 if ( m_dc->islocked() )
481 o.opcode=gOpcode::setOffset;
482 o.dc = m_dc.grabRef();
483 o.parm.setOffset = new gOpcode::para::psetOffset;
484 o.parm.setOffset->rel = 0;
485 o.parm.setOffset->value = ePoint(0, 0);
489 void gPainter::resetClip(const gRegion ®ion)
491 if ( m_dc->islocked() )
494 o.opcode = gOpcode::setClip;
495 o.dc = m_dc.grabRef();
496 o.parm.clip = new gOpcode::para::psetClip;
497 o.parm.clip->region = region;
501 void gPainter::clip(const gRegion ®ion)
503 if ( m_dc->islocked() )
506 o.opcode = gOpcode::addClip;
507 o.dc = m_dc.grabRef();
508 o.parm.clip = new gOpcode::para::psetClip;
509 o.parm.clip->region = region;
513 void gPainter::clippop()
515 if ( m_dc->islocked() )
518 o.opcode = gOpcode::popClip;
519 o.dc = m_dc.grabRef();
523 void gPainter::flush()
525 if ( m_dc->islocked() )
528 o.opcode = gOpcode::flush;
529 o.dc = m_dc.grabRef();
533 void gPainter::waitVSync()
535 if ( m_dc->islocked() )
538 o.opcode = gOpcode::waitVSync;
539 o.dc = m_dc.grabRef();
543 void gPainter::flip()
545 if ( m_dc->islocked() )
548 o.opcode = gOpcode::flip;
549 o.dc = m_dc.grabRef();
553 void gPainter::notify()
555 if ( m_dc->islocked() )
558 o.opcode = gOpcode::notify;
559 o.dc = m_dc.grabRef();
565 if ( m_dc->islocked() )
568 o.opcode = gOpcode::flush;
569 o.dc = m_dc.grabRef();
578 gDC::gDC(gPixmap *pixmap): m_pixmap(pixmap)
585 delete[] m_spinner_pic;
588 void gDC::exec(gOpcode *o)
592 case gOpcode::setBackgroundColor:
593 m_background_color = o->parm.setColor->color;
594 m_background_color_rgb = getRGB(m_background_color);
595 delete o->parm.setColor;
597 case gOpcode::setForegroundColor:
598 m_foreground_color = o->parm.setColor->color;
599 m_background_color_rgb = getRGB(m_foreground_color);
600 delete o->parm.setColor;
602 case gOpcode::setBackgroundColorRGB:
603 if (m_pixmap->needClut())
604 m_background_color = m_pixmap->surface->clut.findColor(o->parm.setColorRGB->color);
605 m_background_color_rgb = o->parm.setColorRGB->color;
606 delete o->parm.setColorRGB;
608 case gOpcode::setForegroundColorRGB:
609 if (m_pixmap->needClut())
610 m_foreground_color = m_pixmap->surface->clut.findColor(o->parm.setColorRGB->color);
611 m_foreground_color_rgb = o->parm.setColorRGB->color;
612 delete o->parm.setColorRGB;
614 case gOpcode::setFont:
615 m_current_font = o->parm.setFont->font;
616 o->parm.setFont->font->Release();
617 delete o->parm.setFont;
619 case gOpcode::renderText:
621 ePtr<eTextPara> para = new eTextPara(o->parm.renderText->area);
622 int flags = o->parm.renderText->flags;
623 assert(m_current_font);
624 para->setFont(m_current_font);
625 para->renderString(o->parm.renderText->text, (flags & gPainter::RT_WRAP) ? RS_WRAP : 0);
626 if (o->parm.renderText->text)
627 free(o->parm.renderText->text);
628 if (flags & gPainter::RT_HALIGN_RIGHT)
629 para->realign(eTextPara::dirRight);
630 else if (flags & gPainter::RT_HALIGN_CENTER)
631 para->realign(eTextPara::dirCenter);
632 else if (flags & gPainter::RT_HALIGN_BLOCK)
633 para->realign(eTextPara::dirBlock);
635 ePoint offset = m_current_offset;
637 if (o->parm.renderText->flags & gPainter::RT_VALIGN_CENTER)
639 eRect bbox = para->getBoundBox();
640 int vcentered_top = o->parm.renderText->area.top() + ((o->parm.renderText->area.height() - bbox.height()) / 2);
641 int correction = vcentered_top - bbox.top();
642 offset += ePoint(0, correction);
645 para->blit(*this, offset, m_background_color_rgb, m_foreground_color_rgb);
646 delete o->parm.renderText;
649 case gOpcode::renderPara:
651 o->parm.renderPara->textpara->blit(*this, o->parm.renderPara->offset + m_current_offset, m_background_color_rgb, m_foreground_color_rgb);
652 o->parm.renderPara->textpara->Release();
653 delete o->parm.renderPara;
658 eRect area = o->parm.fill->area;
659 area.moveBy(m_current_offset);
660 gRegion clip = m_current_clip & area;
661 if (m_pixmap->needClut())
662 m_pixmap->fill(clip, m_foreground_color);
664 m_pixmap->fill(clip, m_foreground_color_rgb);
668 case gOpcode::fillRegion:
670 o->parm.fillRegion->region.moveBy(m_current_offset);
671 gRegion clip = m_current_clip & o->parm.fillRegion->region;
672 if (m_pixmap->needClut())
673 m_pixmap->fill(clip, m_foreground_color);
675 m_pixmap->fill(clip, m_foreground_color_rgb);
676 delete o->parm.fillRegion;
680 if (m_pixmap->needClut())
681 m_pixmap->fill(m_current_clip, m_background_color);
683 m_pixmap->fill(m_current_clip, m_background_color_rgb);
689 // this code should be checked again but i'm too tired now
691 o->parm.blit->position += m_current_offset;
693 if (o->parm.blit->clip.valid())
695 o->parm.blit->clip.moveBy(m_current_offset);
696 clip.intersect(gRegion(o->parm.blit->clip), m_current_clip);
698 clip = m_current_clip;
700 m_pixmap->blit(*o->parm.blit->pixmap, o->parm.blit->position, clip, o->parm.blit->flags);
701 o->parm.blit->pixmap->Release();
705 case gOpcode::setPalette:
706 if (o->parm.setPalette->palette->start > m_pixmap->surface->clut.colors)
707 o->parm.setPalette->palette->start = m_pixmap->surface->clut.colors;
708 if (o->parm.setPalette->palette->colors > (m_pixmap->surface->clut.colors-o->parm.setPalette->palette->start))
709 o->parm.setPalette->palette->colors = m_pixmap->surface->clut.colors-o->parm.setPalette->palette->start;
710 if (o->parm.setPalette->palette->colors)
711 memcpy(m_pixmap->surface->clut.data+o->parm.setPalette->palette->start, o->parm.setPalette->palette->data, o->parm.setPalette->palette->colors*sizeof(gRGB));
713 delete[] o->parm.setPalette->palette->data;
714 delete o->parm.setPalette->palette;
715 delete o->parm.setPalette;
717 case gOpcode::mergePalette:
718 m_pixmap->mergePalette(*o->parm.mergePalette->target);
719 o->parm.mergePalette->target->Release();
720 delete o->parm.mergePalette;
724 ePoint start = o->parm.line->start + m_current_offset, end = o->parm.line->end + m_current_offset;
725 m_pixmap->line(m_current_clip, start, end, m_foreground_color);
729 case gOpcode::addClip:
730 m_clip_stack.push(m_current_clip);
731 o->parm.clip->region.moveBy(m_current_offset);
732 m_current_clip &= o->parm.clip->region;
735 case gOpcode::setClip:
736 o->parm.clip->region.moveBy(m_current_offset);
737 m_current_clip = o->parm.clip->region & eRect(ePoint(0, 0), m_pixmap->size());
740 case gOpcode::popClip:
741 if (!m_clip_stack.empty())
743 m_current_clip = m_clip_stack.top();
747 case gOpcode::setOffset:
748 if (o->parm.setOffset->rel)
749 m_current_offset += o->parm.setOffset->value;
751 m_current_offset = o->parm.setOffset->value;
752 delete o->parm.setOffset;
754 case gOpcode::waitVSync:
760 case gOpcode::enableSpinner:
763 case gOpcode::disableSpinner:
766 case gOpcode::incrementSpinner:
770 eFatal("illegal opcode %d. expect memory leak!", o->opcode);
774 gRGB gDC::getRGB(gColor col)
776 if ((!m_pixmap) || (!m_pixmap->surface->clut.data))
777 return gRGB(col, col, col);
780 eFatal("bla transp");
781 return gRGB(0, 0, 0, 0xFF);
783 return m_pixmap->surface->clut.data[col];
786 void gDC::enableSpinner()
788 ASSERT(m_spinner_saved);
790 /* save the background to restore it later. We need to negative position because we want to blit from the middle of the screen. */
791 m_spinner_saved->blit(*m_pixmap, -m_spinner_pos.topLeft(), gRegion(eRect(ePoint(0, 0), m_spinner_saved->size())), 0);
796 void gDC::disableSpinner()
798 ASSERT(m_spinner_saved);
800 /* restore background */
801 m_pixmap->blit(*m_spinner_saved, m_spinner_pos.topLeft(), gRegion(m_spinner_pos), 0);
804 void gDC::incrementSpinner()
806 ASSERT(m_spinner_saved);
814 for (i = 0; i < 5; ++i)
816 int x = i * 20 + m_spinner_pos.left();
817 int y = m_spinner_pos.top();
819 int col = ((blub - i) * 30) % 256;
821 m_pixmap->fill(eRect(x, y, 10, 10), gRGB(col, col, col));
825 m_spinner_temp->blit(*m_spinner_saved, ePoint(0, 0), eRect(ePoint(0, 0), m_spinner_pos.size()));
827 if (m_spinner_pic[m_spinner_i])
828 m_spinner_temp->blit(*m_spinner_pic[m_spinner_i], ePoint(0, 0), eRect(ePoint(0, 0), m_spinner_pos.size()), gPixmap::blitAlphaTest);
830 m_pixmap->blit(*m_spinner_temp, m_spinner_pos.topLeft(), gRegion(m_spinner_pos), 0);
832 m_spinner_i %= m_spinner_num;
835 void gDC::setSpinner(eRect pos, ePtr<gPixmap> *pic, int len)
838 ASSERT(m_pixmap->surface);
839 m_spinner_saved = new gPixmap(pos.size(), m_pixmap->surface->bpp);
840 m_spinner_temp = new gPixmap(pos.size(), m_pixmap->surface->bpp);
848 delete[] m_spinner_pic;
850 m_spinner_pic = new ePtr<gPixmap>[len];
852 for (i = 0; i < len; ++i)
853 m_spinner_pic[i] = pic[i];
858 eAutoInitPtr<gRC> init_grc(eAutoInitNumbers::graphic, "gRC");