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>
7 #include <vuplus_gles.h>
11 void *gRC::thread_wrapper(void *ptr)
13 return ((gRC*)ptr)->thread();
19 gRC::gRC(): rp(0), wp(0)
21 ,m_notify_pump(eApp, 0)
23 ,m_notify_pump(eApp, 1)
28 CONNECT(m_notify_pump.recv_msg, gRC::recv_notify);
30 pthread_mutex_init(&mutex, 0);
31 pthread_cond_init(&cond, 0);
32 int res = pthread_create(&the_thread, 0, thread_wrapper, this);
34 eFatal("RC thread couldn't be created");
36 eDebug("RC thread created successfully");
38 m_spinner_enabled = 0;
48 o.opcode=gOpcode::shutdown;
51 eDebug("waiting for gRC thread shutdown");
52 pthread_join(the_thread, 0);
53 eDebug("gRC thread has finished");
57 void gRC::submit(const gOpcode &o)
62 pthread_mutex_lock(&mutex);
70 pthread_cond_signal(&cond); // wakeup gdi thread
71 pthread_mutex_unlock(&mutex);
75 //printf("render buffer full...\n");
77 usleep(1000); // wait 1 msec
86 if (o.opcode==gOpcode::flush||o.opcode==gOpcode::shutdown||o.opcode==gOpcode::notify)
88 pthread_cond_signal(&cond); // wakeup gdi thread
89 pthread_mutex_unlock(&mutex);
100 #ifdef USE_LIBVUGLES2
103 gles_viewport(720, 576, 720 * 4);
114 pthread_mutex_lock(&mutex);
118 /* make sure the spinner is not displayed when we something is painted */
121 gOpcode o(queue[rp++]);
125 pthread_mutex_unlock(&mutex);
127 if (o.opcode==gOpcode::shutdown)
129 else if (o.opcode==gOpcode::notify)
131 else if (o.opcode==gOpcode::setCompositing)
133 m_compositing = o.parm.setCompositing;
134 m_compositing->Release();
138 // o.dc is a gDC* filled with grabref... so we must release it here
147 m_notify_pump.send(1);
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);
158 if (m_spinner_enabled)
160 timeout.tv_nsec += 100*1000*1000;
161 /* yes, this is required. */
162 if (timeout.tv_nsec > 1000*1000*1000)
164 timeout.tv_nsec -= 1000*1000*1000;
173 if (pthread_cond_timedwait(&cond, &mutex, &timeout) == ETIMEDOUT)
175 if (eApp && !eApp->isIdle())
177 int idle_count = eApp->idleCount();
178 if (idle_count == m_prev_idle_count)
181 m_prev_idle_count = idle_count;
187 if (!m_spinner_enabled)
188 eDebug("main thread is non-idle! display spinner!");
193 pthread_mutex_unlock(&mutex);
197 #ifdef USE_LIBVUGLES2
207 void gRC::recv_notify(const int &i)
212 gRC *gRC::getInstance()
217 void gRC::enableSpinner()
221 eDebug("no spinner DC!");
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);
233 void gRC::disableSpinner()
235 if (!m_spinner_enabled)
240 eDebug("no spinner DC!");
244 m_spinner_enabled = 0;
247 o.opcode = gOpcode::disableSpinner;
248 m_spinner_dc->exec(&o);
249 o.opcode = gOpcode::flush;
250 m_spinner_dc->exec(&o);
253 static int gPainter_instances;
255 gPainter::gPainter(gDC *dc, eRect rect): m_dc(dc), m_rc(gRC::getInstance())
257 // ASSERT(!gPainter_instances);
258 gPainter_instances++;
262 gPainter::~gPainter()
265 gPainter_instances--;
268 void gPainter::setBackgroundColor(const gColor &color)
270 if ( m_dc->islocked() )
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;
281 void gPainter::setForegroundColor(const gColor &color)
283 if ( m_dc->islocked() )
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;
294 void gPainter::setBackgroundColor(const gRGB &color)
296 if ( m_dc->islocked() )
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;
307 void gPainter::setForegroundColor(const gRGB &color)
309 if ( m_dc->islocked() )
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;
320 void gPainter::setFont(gFont *font)
322 if ( m_dc->islocked() )
325 o.opcode = gOpcode::setFont;
326 o.dc = m_dc.grabRef();
328 o.parm.setFont = new gOpcode::para::psetFont;
329 o.parm.setFont->font = font;
334 void gPainter::renderText(const eRect &pos, const std::string &string, int flags, gRGB bordercolor, int border)
336 if ( m_dc->islocked() )
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;
350 void gPainter::renderPara(eTextPara *para, ePoint offset)
352 if ( m_dc->islocked() )
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;
362 o.parm.renderPara->textpara = para;
366 void gPainter::fill(const eRect &area)
368 if ( m_dc->islocked() )
371 o.opcode=gOpcode::fill;
373 o.dc = m_dc.grabRef();
374 o.parm.fill = new gOpcode::para::pfillRect;
375 o.parm.fill->area = area;
379 void gPainter::fill(const gRegion ®ion)
381 if ( m_dc->islocked() )
384 o.opcode=gOpcode::fillRegion;
386 o.dc = m_dc.grabRef();
387 o.parm.fillRegion = new gOpcode::para::pfillRegion;
388 o.parm.fillRegion->region = region;
392 void gPainter::clear()
394 if ( m_dc->islocked() )
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();
404 void gPainter::blit(gPixmap *pixmap, ePoint pos, const eRect &clip, int flags)
406 blitScale(pixmap, eRect(pos, eSize()), clip, flags, 0);
409 void gPainter::blitScale(gPixmap *pixmap, const eRect &position, const eRect &clip, int flags, int aflags)
413 if ( m_dc->islocked() )
419 o.opcode=gOpcode::blit;
420 o.dc = m_dc.grabRef();
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;
430 void gPainter::setPalette(gRGB *colors, int start, int len)
432 if ( m_dc->islocked() )
436 o.opcode=gOpcode::setPalette;
437 o.dc = m_dc.grabRef();
438 gPalette *p=new gPalette;
440 o.parm.setPalette = new gOpcode::para::psetPalette;
441 p->data=new gRGB[len];
443 memcpy(p->data, colors, len*sizeof(gRGB));
446 o.parm.setPalette->palette = p;
450 void gPainter::setPalette(gPixmap *source)
453 setPalette(source->surface->clut.data, source->surface->clut.start, source->surface->clut.colors);
456 void gPainter::mergePalette(gPixmap *target)
458 if ( m_dc->islocked() )
462 o.opcode = gOpcode::mergePalette;
463 o.dc = m_dc.grabRef();
465 o.parm.mergePalette = new gOpcode::para::pmergePalette;
466 o.parm.mergePalette->target = target;
470 void gPainter::line(ePoint start, ePoint end)
472 if ( m_dc->islocked() )
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;
483 void gPainter::setOffset(ePoint val)
485 if ( m_dc->islocked() )
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;
496 void gPainter::moveOffset(ePoint rel)
498 if ( m_dc->islocked() )
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;
509 void gPainter::resetOffset()
511 if ( m_dc->islocked() )
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);
522 void gPainter::resetClip(const gRegion ®ion)
524 if ( m_dc->islocked() )
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;
534 void gPainter::clip(const gRegion ®ion)
536 if ( m_dc->islocked() )
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;
546 void gPainter::clippop()
548 if ( m_dc->islocked() )
551 o.opcode = gOpcode::popClip;
552 o.dc = m_dc.grabRef();
556 void gPainter::waitVSync()
558 if ( m_dc->islocked() )
561 o.opcode = gOpcode::waitVSync;
562 o.dc = m_dc.grabRef();
566 void gPainter::flip()
568 if ( m_dc->islocked() )
571 o.opcode = gOpcode::flip;
572 o.dc = m_dc.grabRef();
576 void gPainter::notify()
578 if ( m_dc->islocked() )
581 o.opcode = gOpcode::notify;
582 o.dc = m_dc.grabRef();
586 void gPainter::setCompositing(gCompositingData *comp)
589 o.opcode = gOpcode::setCompositing;
591 o.parm.setCompositing = comp;
592 comp->AddRef(); /* will be freed in ::thread */
596 void gPainter::flush()
598 if ( m_dc->islocked() )
601 o.opcode = gOpcode::flush;
602 o.dc = m_dc.grabRef();
608 if ( m_dc->islocked() )
612 void gPainter::sendShow(ePoint point, eSize size)
614 if ( m_dc->islocked() )
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;
625 void gPainter::sendHide(ePoint point, eSize size)
627 if ( m_dc->islocked() )
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;
638 #ifdef USE_LIBVUGLES2
639 void gPainter::sendShowItem(long dir, ePoint point, eSize size)
641 if ( m_dc->islocked() )
644 o.opcode=gOpcode::sendShowItem;
645 o.dc = m_dc.grabRef();
646 o.parm.setShowItemInfo = new gOpcode::para::psetShowItemInfo;
647 o.parm.setShowItemInfo->dir = dir;
648 o.parm.setShowItemInfo->point = point;
649 o.parm.setShowItemInfo->size = size;
653 void gPainter::setFlush(bool val)
655 if ( m_dc->islocked() )
658 o.opcode=gOpcode::setFlush;
659 o.dc = m_dc.grabRef();
660 o.parm.setFlush = new gOpcode::para::psetFlush;
661 o.parm.setFlush->enable = val;
665 void gPainter::setView(eSize size)
667 if ( m_dc->islocked() )
670 o.opcode=gOpcode::setView;
671 o.dc = m_dc.grabRef();
672 o.parm.setViewInfo = new gOpcode::para::psetViewInfo;
673 o.parm.setViewInfo->size = size;
683 gDC::gDC(gPixmap *pixmap): m_pixmap(pixmap)
690 delete[] m_spinner_pic;
693 void gDC::exec(const gOpcode *o)
697 case gOpcode::setBackgroundColor:
698 m_background_color = o->parm.setColor->color;
699 m_background_color_rgb = getRGB(m_background_color);
700 delete o->parm.setColor;
702 case gOpcode::setForegroundColor:
703 m_foreground_color = o->parm.setColor->color;
704 m_background_color_rgb = getRGB(m_foreground_color);
705 delete o->parm.setColor;
707 case gOpcode::setBackgroundColorRGB:
708 if (m_pixmap->needClut())
709 m_background_color = m_pixmap->surface->clut.findColor(o->parm.setColorRGB->color);
710 m_background_color_rgb = o->parm.setColorRGB->color;
711 delete o->parm.setColorRGB;
713 case gOpcode::setForegroundColorRGB:
714 if (m_pixmap->needClut())
715 m_foreground_color = m_pixmap->surface->clut.findColor(o->parm.setColorRGB->color);
716 m_foreground_color_rgb = o->parm.setColorRGB->color;
717 delete o->parm.setColorRGB;
719 case gOpcode::setFont:
720 m_current_font = o->parm.setFont->font;
721 o->parm.setFont->font->Release();
722 delete o->parm.setFont;
724 case gOpcode::renderText:
726 ePtr<eTextPara> para = new eTextPara(o->parm.renderText->area);
727 int flags = o->parm.renderText->flags;
728 ASSERT(m_current_font);
729 para->setFont(m_current_font);
730 para->renderString(o->parm.renderText->text, (flags & gPainter::RT_WRAP) ? RS_WRAP : 0, o->parm.renderText->border);
731 if (o->parm.renderText->text)
732 free(o->parm.renderText->text);
733 if (flags & gPainter::RT_HALIGN_RIGHT)
734 para->realign(eTextPara::dirRight);
735 else if (flags & gPainter::RT_HALIGN_CENTER)
736 para->realign(eTextPara::dirCenter);
737 else if (flags & gPainter::RT_HALIGN_BLOCK)
738 para->realign(eTextPara::dirBlock);
740 ePoint offset = m_current_offset;
742 if (o->parm.renderText->flags & gPainter::RT_VALIGN_CENTER)
744 eRect bbox = para->getBoundBox();
745 int vcentered_top = o->parm.renderText->area.top() + ((o->parm.renderText->area.height() - bbox.height()) / 2);
746 int correction = vcentered_top - bbox.top();
747 offset += ePoint(0, correction);
750 if (o->parm.renderText->border)
752 para->blit(*this, offset, m_background_color_rgb, o->parm.renderText->bordercolor, true);
753 para->blit(*this, offset, o->parm.renderText->bordercolor, m_foreground_color_rgb);
756 para->blit(*this, offset, m_background_color_rgb, m_foreground_color_rgb);
757 delete o->parm.renderText;
760 case gOpcode::renderPara:
762 o->parm.renderPara->textpara->blit(*this, o->parm.renderPara->offset + m_current_offset, m_background_color_rgb, m_foreground_color_rgb);
763 o->parm.renderPara->textpara->Release();
764 delete o->parm.renderPara;
769 eRect area = o->parm.fill->area;
770 area.moveBy(m_current_offset);
771 gRegion clip = m_current_clip & area;
772 if (m_pixmap->needClut())
773 m_pixmap->fill(clip, m_foreground_color);
775 m_pixmap->fill(clip, m_foreground_color_rgb);
779 case gOpcode::fillRegion:
781 o->parm.fillRegion->region.moveBy(m_current_offset);
782 gRegion clip = m_current_clip & o->parm.fillRegion->region;
783 if (m_pixmap->needClut())
784 m_pixmap->fill(clip, m_foreground_color);
786 m_pixmap->fill(clip, m_foreground_color_rgb);
787 delete o->parm.fillRegion;
791 if (m_pixmap->needClut())
792 m_pixmap->fill(m_current_clip, m_background_color);
794 m_pixmap->fill(m_current_clip, m_background_color_rgb);
800 // this code should be checked again but i'm too tired now
802 o->parm.blit->position.moveBy(m_current_offset);
804 if (o->parm.blit->clip.valid())
806 o->parm.blit->clip.moveBy(m_current_offset);
807 clip.intersect(gRegion(o->parm.blit->clip), m_current_clip);
809 clip = m_current_clip;
811 m_pixmap->blit(*o->parm.blit->pixmap, o->parm.blit->position, clip, o->parm.blit->flags);
812 o->parm.blit->pixmap->Release();
816 case gOpcode::setPalette:
817 if (o->parm.setPalette->palette->start > m_pixmap->surface->clut.colors)
818 o->parm.setPalette->palette->start = m_pixmap->surface->clut.colors;
819 if (o->parm.setPalette->palette->colors > (m_pixmap->surface->clut.colors-o->parm.setPalette->palette->start))
820 o->parm.setPalette->palette->colors = m_pixmap->surface->clut.colors-o->parm.setPalette->palette->start;
821 if (o->parm.setPalette->palette->colors)
822 memcpy(m_pixmap->surface->clut.data+o->parm.setPalette->palette->start, o->parm.setPalette->palette->data, o->parm.setPalette->palette->colors*sizeof(gRGB));
824 delete[] o->parm.setPalette->palette->data;
825 delete o->parm.setPalette->palette;
826 delete o->parm.setPalette;
828 case gOpcode::mergePalette:
829 m_pixmap->mergePalette(*o->parm.mergePalette->target);
830 o->parm.mergePalette->target->Release();
831 delete o->parm.mergePalette;
835 ePoint start = o->parm.line->start + m_current_offset, end = o->parm.line->end + m_current_offset;
836 m_pixmap->line(m_current_clip, start, end, m_foreground_color);
840 case gOpcode::addClip:
841 m_clip_stack.push(m_current_clip);
842 o->parm.clip->region.moveBy(m_current_offset);
843 m_current_clip &= o->parm.clip->region;
846 case gOpcode::setClip:
847 o->parm.clip->region.moveBy(m_current_offset);
848 m_current_clip = o->parm.clip->region & eRect(ePoint(0, 0), m_pixmap->size());
851 case gOpcode::popClip:
852 if (!m_clip_stack.empty())
854 m_current_clip = m_clip_stack.top();
858 case gOpcode::setOffset:
859 if (o->parm.setOffset->rel)
860 m_current_offset += o->parm.setOffset->value;
862 m_current_offset = o->parm.setOffset->value;
863 delete o->parm.setOffset;
865 case gOpcode::waitVSync:
871 case gOpcode::sendShow:
873 case gOpcode::sendHide:
875 #ifdef USE_LIBVUGLES2
876 case gOpcode::sendShowItem:
878 case gOpcode::setFlush:
880 case gOpcode::setView:
883 case gOpcode::enableSpinner:
886 case gOpcode::disableSpinner:
889 case gOpcode::incrementSpinner:
893 eFatal("illegal opcode %d. expect memory leak!", o->opcode);
897 gRGB gDC::getRGB(gColor col)
899 if ((!m_pixmap) || (!m_pixmap->surface->clut.data))
900 return gRGB(col, col, col);
903 eFatal("bla transp");
904 return gRGB(0, 0, 0, 0xFF);
906 return m_pixmap->surface->clut.data[col];
909 void gDC::enableSpinner()
911 ASSERT(m_spinner_saved);
913 /* save the background to restore it later. We need to negative position because we want to blit from the middle of the screen. */
914 m_spinner_saved->blit(*m_pixmap, eRect(-m_spinner_pos.topLeft(), eSize()), gRegion(eRect(ePoint(0, 0), m_spinner_saved->size())), 0);
919 void gDC::disableSpinner()
921 ASSERT(m_spinner_saved);
923 /* restore background */
924 m_pixmap->blit(*m_spinner_saved, eRect(m_spinner_pos.topLeft(), eSize()), gRegion(m_spinner_pos), 0);
927 void gDC::incrementSpinner()
929 ASSERT(m_spinner_saved);
937 for (i = 0; i < 5; ++i)
939 int x = i * 20 + m_spinner_pos.left();
940 int y = m_spinner_pos.top();
942 int col = ((blub - i) * 30) % 256;
944 m_pixmap->fill(eRect(x, y, 10, 10), gRGB(col, col, col));
948 m_spinner_temp->blit(*m_spinner_saved, eRect(0, 0, 0, 0), eRect(ePoint(0, 0), m_spinner_pos.size()));
950 if (m_spinner_pic[m_spinner_i])
951 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);
953 m_pixmap->blit(*m_spinner_temp, eRect(m_spinner_pos.topLeft(), eSize()), gRegion(m_spinner_pos), 0);
955 m_spinner_i %= m_spinner_num;
958 void gDC::setSpinner(eRect pos, ePtr<gPixmap> *pic, int len)
961 ASSERT(m_pixmap->surface);
962 m_spinner_saved = new gPixmap(pos.size(), m_pixmap->surface->bpp);
963 m_spinner_temp = new gPixmap(pos.size(), m_pixmap->surface->bpp);
971 delete[] m_spinner_pic;
973 m_spinner_pic = new ePtr<gPixmap>[len];
975 for (i = 0; i < len; ++i)
976 m_spinner_pic[i] = pic[i];
981 eAutoInitPtr<gRC> init_grc(eAutoInitNumbers::graphic, "gRC");