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)
122 else if (o.opcode==gOpcode::setCompositing)
124 m_compositing = o.parm.setCompositing;
125 m_compositing->Release();
129 // o.dc is a gDC* filled with grabref... so we must release it here
138 m_notify_pump.send(1);
144 /* when the main thread is non-idle for a too long time without any display output,
145 we want to display a spinner. */
146 struct timespec timeout;
147 clock_gettime(CLOCK_REALTIME, &timeout);
149 if (m_spinner_enabled)
151 timeout.tv_nsec += 100*1000*1000;
152 /* yes, this is required. */
153 if (timeout.tv_nsec > 1000*1000*1000)
155 timeout.tv_nsec -= 1000*1000*1000;
164 if (pthread_cond_timedwait(&cond, &mutex, &timeout) == ETIMEDOUT)
166 if (eApp && !eApp->isIdle())
172 if (!m_spinner_enabled)
173 eDebug("main thread is non-idle! display spinner!");
178 pthread_mutex_unlock(&mutex);
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;
210 o.opcode = gOpcode::flush;
211 m_spinner_dc->exec(&o);
214 void gRC::disableSpinner()
216 if (!m_spinner_enabled)
221 eDebug("no spinner DC!");
225 m_spinner_enabled = 0;
228 o.opcode = gOpcode::disableSpinner;
229 m_spinner_dc->exec(&o);
230 o.opcode = gOpcode::flush;
231 m_spinner_dc->exec(&o);
234 static int gPainter_instances;
236 gPainter::gPainter(gDC *dc, eRect rect): m_dc(dc), m_rc(gRC::getInstance())
238 // ASSERT(!gPainter_instances);
239 gPainter_instances++;
243 gPainter::~gPainter()
246 gPainter_instances--;
249 void gPainter::setBackgroundColor(const gColor &color)
251 if ( m_dc->islocked() )
254 o.opcode = gOpcode::setBackgroundColor;
255 o.dc = m_dc.grabRef();
256 o.parm.setColor = new gOpcode::para::psetColor;
257 o.parm.setColor->color = color;
262 void gPainter::setForegroundColor(const gColor &color)
264 if ( m_dc->islocked() )
267 o.opcode = gOpcode::setForegroundColor;
268 o.dc = m_dc.grabRef();
269 o.parm.setColor = new gOpcode::para::psetColor;
270 o.parm.setColor->color = color;
275 void gPainter::setBackgroundColor(const gRGB &color)
277 if ( m_dc->islocked() )
280 o.opcode = gOpcode::setBackgroundColorRGB;
281 o.dc = m_dc.grabRef();
282 o.parm.setColorRGB = new gOpcode::para::psetColorRGB;
283 o.parm.setColorRGB->color = color;
288 void gPainter::setForegroundColor(const gRGB &color)
290 if ( m_dc->islocked() )
293 o.opcode = gOpcode::setForegroundColorRGB;
294 o.dc = m_dc.grabRef();
295 o.parm.setColorRGB = new gOpcode::para::psetColorRGB;
296 o.parm.setColorRGB->color = color;
301 void gPainter::setFont(gFont *font)
303 if ( m_dc->islocked() )
306 o.opcode = gOpcode::setFont;
307 o.dc = m_dc.grabRef();
309 o.parm.setFont = new gOpcode::para::psetFont;
310 o.parm.setFont->font = font;
315 void gPainter::renderText(const eRect &pos, const std::string &string, int flags)
317 if ( m_dc->islocked() )
320 o.opcode=gOpcode::renderText;
321 o.dc = m_dc.grabRef();
322 o.parm.renderText = new gOpcode::para::prenderText;
323 o.parm.renderText->area = pos;
324 o.parm.renderText->text = string.empty()?0:strdup(string.c_str());
325 o.parm.renderText->flags = flags;
329 void gPainter::renderPara(eTextPara *para, ePoint offset)
331 if ( m_dc->islocked() )
335 o.opcode=gOpcode::renderPara;
336 o.dc = m_dc.grabRef();
337 o.parm.renderPara = new gOpcode::para::prenderPara;
338 o.parm.renderPara->offset = offset;
341 o.parm.renderPara->textpara = para;
345 void gPainter::fill(const eRect &area)
347 if ( m_dc->islocked() )
350 o.opcode=gOpcode::fill;
352 o.dc = m_dc.grabRef();
353 o.parm.fill = new gOpcode::para::pfillRect;
354 o.parm.fill->area = area;
358 void gPainter::fill(const gRegion ®ion)
360 if ( m_dc->islocked() )
363 o.opcode=gOpcode::fillRegion;
365 o.dc = m_dc.grabRef();
366 o.parm.fillRegion = new gOpcode::para::pfillRegion;
367 o.parm.fillRegion->region = region;
371 void gPainter::clear()
373 if ( m_dc->islocked() )
376 o.opcode=gOpcode::clear;
377 o.dc = m_dc.grabRef();
378 o.parm.fill = new gOpcode::para::pfillRect;
379 o.parm.fill->area = eRect();
383 void gPainter::blit(gPixmap *pixmap, ePoint pos, const eRect &clip, int flags)
385 blitScale(pixmap, eRect(pos, eSize()), clip, flags, 0);
388 void gPainter::blitScale(gPixmap *pixmap, const eRect &position, const eRect &clip, int flags, int aflags)
392 if ( m_dc->islocked() )
398 o.opcode=gOpcode::blit;
399 o.dc = m_dc.grabRef();
401 o.parm.blit = new gOpcode::para::pblit;
402 o.parm.blit->pixmap = pixmap;
403 o.parm.blit->clip = clip;
404 o.parm.blit->flags = flags;
405 o.parm.blit->position = position;
409 void gPainter::setPalette(gRGB *colors, int start, int len)
411 if ( m_dc->islocked() )
415 o.opcode=gOpcode::setPalette;
416 o.dc = m_dc.grabRef();
417 gPalette *p=new gPalette;
419 o.parm.setPalette = new gOpcode::para::psetPalette;
420 p->data=new gRGB[len];
422 memcpy(p->data, colors, len*sizeof(gRGB));
425 o.parm.setPalette->palette = p;
429 void gPainter::setPalette(gPixmap *source)
432 setPalette(source->surface->clut.data, source->surface->clut.start, source->surface->clut.colors);
435 void gPainter::mergePalette(gPixmap *target)
437 if ( m_dc->islocked() )
441 o.opcode = gOpcode::mergePalette;
442 o.dc = m_dc.grabRef();
444 o.parm.mergePalette = new gOpcode::para::pmergePalette;
445 o.parm.mergePalette->target = target;
449 void gPainter::line(ePoint start, ePoint end)
451 if ( m_dc->islocked() )
454 o.opcode=gOpcode::line;
455 o.dc = m_dc.grabRef();
456 o.parm.line = new gOpcode::para::pline;
457 o.parm.line->start = start;
458 o.parm.line->end = end;
462 void gPainter::setOffset(ePoint val)
464 if ( m_dc->islocked() )
467 o.opcode=gOpcode::setOffset;
468 o.dc = m_dc.grabRef();
469 o.parm.setOffset = new gOpcode::para::psetOffset;
470 o.parm.setOffset->rel = 0;
471 o.parm.setOffset->value = val;
475 void gPainter::moveOffset(ePoint rel)
477 if ( m_dc->islocked() )
480 o.opcode=gOpcode::setOffset;
481 o.dc = m_dc.grabRef();
482 o.parm.setOffset = new gOpcode::para::psetOffset;
483 o.parm.setOffset->rel = 1;
484 o.parm.setOffset->value = rel;
488 void gPainter::resetOffset()
490 if ( m_dc->islocked() )
493 o.opcode=gOpcode::setOffset;
494 o.dc = m_dc.grabRef();
495 o.parm.setOffset = new gOpcode::para::psetOffset;
496 o.parm.setOffset->rel = 0;
497 o.parm.setOffset->value = ePoint(0, 0);
501 void gPainter::resetClip(const gRegion ®ion)
503 if ( m_dc->islocked() )
506 o.opcode = gOpcode::setClip;
507 o.dc = m_dc.grabRef();
508 o.parm.clip = new gOpcode::para::psetClip;
509 o.parm.clip->region = region;
513 void gPainter::clip(const gRegion ®ion)
515 if ( m_dc->islocked() )
518 o.opcode = gOpcode::addClip;
519 o.dc = m_dc.grabRef();
520 o.parm.clip = new gOpcode::para::psetClip;
521 o.parm.clip->region = region;
525 void gPainter::clippop()
527 if ( m_dc->islocked() )
530 o.opcode = gOpcode::popClip;
531 o.dc = m_dc.grabRef();
535 void gPainter::waitVSync()
537 if ( m_dc->islocked() )
540 o.opcode = gOpcode::waitVSync;
541 o.dc = m_dc.grabRef();
545 void gPainter::flip()
547 if ( m_dc->islocked() )
550 o.opcode = gOpcode::flip;
551 o.dc = m_dc.grabRef();
555 void gPainter::notify()
557 if ( m_dc->islocked() )
560 o.opcode = gOpcode::notify;
561 o.dc = m_dc.grabRef();
565 void gPainter::setCompositing(gCompositingData *comp)
568 o.opcode = gOpcode::setCompositing;
570 o.parm.setCompositing = comp;
571 comp->AddRef(); /* will be freed in ::thread */
575 void gPainter::flush()
577 if ( m_dc->islocked() )
580 o.opcode = gOpcode::flush;
581 o.dc = m_dc.grabRef();
587 if ( m_dc->islocked() )
596 gDC::gDC(gPixmap *pixmap): m_pixmap(pixmap)
603 delete[] m_spinner_pic;
606 void gDC::exec(gOpcode *o)
610 case gOpcode::setBackgroundColor:
611 m_background_color = o->parm.setColor->color;
612 m_background_color_rgb = getRGB(m_background_color);
613 delete o->parm.setColor;
615 case gOpcode::setForegroundColor:
616 m_foreground_color = o->parm.setColor->color;
617 m_background_color_rgb = getRGB(m_foreground_color);
618 delete o->parm.setColor;
620 case gOpcode::setBackgroundColorRGB:
621 if (m_pixmap->needClut())
622 m_background_color = m_pixmap->surface->clut.findColor(o->parm.setColorRGB->color);
623 m_background_color_rgb = o->parm.setColorRGB->color;
624 delete o->parm.setColorRGB;
626 case gOpcode::setForegroundColorRGB:
627 if (m_pixmap->needClut())
628 m_foreground_color = m_pixmap->surface->clut.findColor(o->parm.setColorRGB->color);
629 m_foreground_color_rgb = o->parm.setColorRGB->color;
630 delete o->parm.setColorRGB;
632 case gOpcode::setFont:
633 m_current_font = o->parm.setFont->font;
634 o->parm.setFont->font->Release();
635 delete o->parm.setFont;
637 case gOpcode::renderText:
639 ePtr<eTextPara> para = new eTextPara(o->parm.renderText->area);
640 int flags = o->parm.renderText->flags;
641 ASSERT(m_current_font);
642 para->setFont(m_current_font);
643 para->renderString(o->parm.renderText->text, (flags & gPainter::RT_WRAP) ? RS_WRAP : 0);
644 if (o->parm.renderText->text)
645 free(o->parm.renderText->text);
646 if (flags & gPainter::RT_HALIGN_RIGHT)
647 para->realign(eTextPara::dirRight);
648 else if (flags & gPainter::RT_HALIGN_CENTER)
649 para->realign(eTextPara::dirCenter);
650 else if (flags & gPainter::RT_HALIGN_BLOCK)
651 para->realign(eTextPara::dirBlock);
653 ePoint offset = m_current_offset;
655 if (o->parm.renderText->flags & gPainter::RT_VALIGN_CENTER)
657 eRect bbox = para->getBoundBox();
658 int vcentered_top = o->parm.renderText->area.top() + ((o->parm.renderText->area.height() - bbox.height()) / 2);
659 int correction = vcentered_top - bbox.top();
660 offset += ePoint(0, correction);
663 para->blit(*this, offset, m_background_color_rgb, m_foreground_color_rgb);
664 delete o->parm.renderText;
667 case gOpcode::renderPara:
669 o->parm.renderPara->textpara->blit(*this, o->parm.renderPara->offset + m_current_offset, m_background_color_rgb, m_foreground_color_rgb);
670 o->parm.renderPara->textpara->Release();
671 delete o->parm.renderPara;
676 eRect area = o->parm.fill->area;
677 area.moveBy(m_current_offset);
678 gRegion clip = m_current_clip & area;
679 if (m_pixmap->needClut())
680 m_pixmap->fill(clip, m_foreground_color);
682 m_pixmap->fill(clip, m_foreground_color_rgb);
686 case gOpcode::fillRegion:
688 o->parm.fillRegion->region.moveBy(m_current_offset);
689 gRegion clip = m_current_clip & o->parm.fillRegion->region;
690 if (m_pixmap->needClut())
691 m_pixmap->fill(clip, m_foreground_color);
693 m_pixmap->fill(clip, m_foreground_color_rgb);
694 delete o->parm.fillRegion;
698 if (m_pixmap->needClut())
699 m_pixmap->fill(m_current_clip, m_background_color);
701 m_pixmap->fill(m_current_clip, m_background_color_rgb);
707 // this code should be checked again but i'm too tired now
709 o->parm.blit->position.moveBy(m_current_offset);
711 if (o->parm.blit->clip.valid())
713 o->parm.blit->clip.moveBy(m_current_offset);
714 clip.intersect(gRegion(o->parm.blit->clip), m_current_clip);
716 clip = m_current_clip;
718 m_pixmap->blit(*o->parm.blit->pixmap, o->parm.blit->position, clip, o->parm.blit->flags);
719 o->parm.blit->pixmap->Release();
723 case gOpcode::setPalette:
724 if (o->parm.setPalette->palette->start > m_pixmap->surface->clut.colors)
725 o->parm.setPalette->palette->start = m_pixmap->surface->clut.colors;
726 if (o->parm.setPalette->palette->colors > (m_pixmap->surface->clut.colors-o->parm.setPalette->palette->start))
727 o->parm.setPalette->palette->colors = m_pixmap->surface->clut.colors-o->parm.setPalette->palette->start;
728 if (o->parm.setPalette->palette->colors)
729 memcpy(m_pixmap->surface->clut.data+o->parm.setPalette->palette->start, o->parm.setPalette->palette->data, o->parm.setPalette->palette->colors*sizeof(gRGB));
731 delete[] o->parm.setPalette->palette->data;
732 delete o->parm.setPalette->palette;
733 delete o->parm.setPalette;
735 case gOpcode::mergePalette:
736 m_pixmap->mergePalette(*o->parm.mergePalette->target);
737 o->parm.mergePalette->target->Release();
738 delete o->parm.mergePalette;
742 ePoint start = o->parm.line->start + m_current_offset, end = o->parm.line->end + m_current_offset;
743 m_pixmap->line(m_current_clip, start, end, m_foreground_color);
747 case gOpcode::addClip:
748 m_clip_stack.push(m_current_clip);
749 o->parm.clip->region.moveBy(m_current_offset);
750 m_current_clip &= o->parm.clip->region;
753 case gOpcode::setClip:
754 o->parm.clip->region.moveBy(m_current_offset);
755 m_current_clip = o->parm.clip->region & eRect(ePoint(0, 0), m_pixmap->size());
758 case gOpcode::popClip:
759 if (!m_clip_stack.empty())
761 m_current_clip = m_clip_stack.top();
765 case gOpcode::setOffset:
766 if (o->parm.setOffset->rel)
767 m_current_offset += o->parm.setOffset->value;
769 m_current_offset = o->parm.setOffset->value;
770 delete o->parm.setOffset;
772 case gOpcode::waitVSync:
778 case gOpcode::enableSpinner:
781 case gOpcode::disableSpinner:
784 case gOpcode::incrementSpinner:
788 eFatal("illegal opcode %d. expect memory leak!", o->opcode);
792 gRGB gDC::getRGB(gColor col)
794 if ((!m_pixmap) || (!m_pixmap->surface->clut.data))
795 return gRGB(col, col, col);
798 eFatal("bla transp");
799 return gRGB(0, 0, 0, 0xFF);
801 return m_pixmap->surface->clut.data[col];
804 void gDC::enableSpinner()
806 ASSERT(m_spinner_saved);
808 /* save the background to restore it later. We need to negative position because we want to blit from the middle of the screen. */
809 m_spinner_saved->blit(*m_pixmap, eRect(-m_spinner_pos.topLeft(), eSize()), gRegion(eRect(ePoint(0, 0), m_spinner_saved->size())), 0);
814 void gDC::disableSpinner()
816 ASSERT(m_spinner_saved);
818 /* restore background */
819 m_pixmap->blit(*m_spinner_saved, eRect(m_spinner_pos.topLeft(), eSize()), gRegion(m_spinner_pos), 0);
822 void gDC::incrementSpinner()
824 ASSERT(m_spinner_saved);
832 for (i = 0; i < 5; ++i)
834 int x = i * 20 + m_spinner_pos.left();
835 int y = m_spinner_pos.top();
837 int col = ((blub - i) * 30) % 256;
839 m_pixmap->fill(eRect(x, y, 10, 10), gRGB(col, col, col));
843 m_spinner_temp->blit(*m_spinner_saved, eRect(0, 0, 0, 0), eRect(ePoint(0, 0), m_spinner_pos.size()));
845 if (m_spinner_pic[m_spinner_i])
846 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);
848 m_pixmap->blit(*m_spinner_temp, eRect(m_spinner_pos.topLeft(), eSize()), gRegion(m_spinner_pos), 0);
850 m_spinner_i %= m_spinner_num;
853 void gDC::setSpinner(eRect pos, ePtr<gPixmap> *pic, int len)
856 ASSERT(m_pixmap->surface);
857 m_spinner_saved = new gPixmap(pos.size(), m_pixmap->surface->bpp);
858 m_spinner_temp = new gPixmap(pos.size(), m_pixmap->surface->bpp);
866 delete[] m_spinner_pic;
868 m_spinner_pic = new ePtr<gPixmap>[len];
870 for (i = 0; i < len; ++i)
871 m_spinner_pic[i] = pic[i];
876 eAutoInitPtr<gRC> init_grc(eAutoInitNumbers::graphic, "gRC");