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;
152 timeout.tv_nsec += 500*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();
577 gDC::gDC(gPixmap *pixmap): m_pixmap(pixmap)
585 void gDC::exec(gOpcode *o)
589 case gOpcode::setBackgroundColor:
590 m_background_color = o->parm.setColor->color;
591 m_background_color_rgb = getRGB(m_background_color);
592 delete o->parm.setColor;
594 case gOpcode::setForegroundColor:
595 m_foreground_color = o->parm.setColor->color;
596 m_background_color_rgb = getRGB(m_foreground_color);
597 delete o->parm.setColor;
599 case gOpcode::setBackgroundColorRGB:
600 if (m_pixmap->needClut())
601 m_background_color = m_pixmap->surface->clut.findColor(o->parm.setColorRGB->color);
602 m_background_color_rgb = o->parm.setColorRGB->color;
603 delete o->parm.setColorRGB;
605 case gOpcode::setForegroundColorRGB:
606 if (m_pixmap->needClut())
607 m_foreground_color = m_pixmap->surface->clut.findColor(o->parm.setColorRGB->color);
608 m_foreground_color_rgb = o->parm.setColorRGB->color;
609 delete o->parm.setColorRGB;
611 case gOpcode::setFont:
612 m_current_font = o->parm.setFont->font;
613 o->parm.setFont->font->Release();
614 delete o->parm.setFont;
616 case gOpcode::renderText:
618 ePtr<eTextPara> para = new eTextPara(o->parm.renderText->area);
619 int flags = o->parm.renderText->flags;
620 assert(m_current_font);
621 para->setFont(m_current_font);
622 para->renderString(o->parm.renderText->text, (flags & gPainter::RT_WRAP) ? RS_WRAP : 0);
623 if (o->parm.renderText->text)
624 free(o->parm.renderText->text);
625 if (flags & gPainter::RT_HALIGN_RIGHT)
626 para->realign(eTextPara::dirRight);
627 else if (flags & gPainter::RT_HALIGN_CENTER)
628 para->realign(eTextPara::dirCenter);
629 else if (flags & gPainter::RT_HALIGN_BLOCK)
630 para->realign(eTextPara::dirBlock);
632 ePoint offset = m_current_offset;
634 if (o->parm.renderText->flags & gPainter::RT_VALIGN_CENTER)
636 eRect bbox = para->getBoundBox();
637 int vcentered_top = o->parm.renderText->area.top() + ((o->parm.renderText->area.height() - bbox.height()) / 2);
638 int correction = vcentered_top - bbox.top();
639 offset += ePoint(0, correction);
642 para->blit(*this, offset, m_background_color_rgb, m_foreground_color_rgb);
643 delete o->parm.renderText;
646 case gOpcode::renderPara:
648 o->parm.renderPara->textpara->blit(*this, o->parm.renderPara->offset + m_current_offset, m_background_color_rgb, m_foreground_color_rgb);
649 o->parm.renderPara->textpara->Release();
650 delete o->parm.renderPara;
655 eRect area = o->parm.fill->area;
656 area.moveBy(m_current_offset);
657 gRegion clip = m_current_clip & area;
658 if (m_pixmap->needClut())
659 m_pixmap->fill(clip, m_foreground_color);
661 m_pixmap->fill(clip, m_foreground_color_rgb);
665 case gOpcode::fillRegion:
667 o->parm.fillRegion->region.moveBy(m_current_offset);
668 gRegion clip = m_current_clip & o->parm.fillRegion->region;
669 if (m_pixmap->needClut())
670 m_pixmap->fill(clip, m_foreground_color);
672 m_pixmap->fill(clip, m_foreground_color_rgb);
673 delete o->parm.fillRegion;
677 if (m_pixmap->needClut())
678 m_pixmap->fill(m_current_clip, m_background_color);
680 m_pixmap->fill(m_current_clip, m_background_color_rgb);
686 // this code should be checked again but i'm too tired now
688 o->parm.blit->position += m_current_offset;
690 if (o->parm.blit->clip.valid())
692 o->parm.blit->clip.moveBy(m_current_offset);
693 clip.intersect(gRegion(o->parm.blit->clip), m_current_clip);
695 clip = m_current_clip;
697 m_pixmap->blit(*o->parm.blit->pixmap, o->parm.blit->position, clip, o->parm.blit->flags);
698 o->parm.blit->pixmap->Release();
702 case gOpcode::setPalette:
703 if (o->parm.setPalette->palette->start > m_pixmap->surface->clut.colors)
704 o->parm.setPalette->palette->start = m_pixmap->surface->clut.colors;
705 if (o->parm.setPalette->palette->colors > (m_pixmap->surface->clut.colors-o->parm.setPalette->palette->start))
706 o->parm.setPalette->palette->colors = m_pixmap->surface->clut.colors-o->parm.setPalette->palette->start;
707 if (o->parm.setPalette->palette->colors)
708 memcpy(m_pixmap->surface->clut.data+o->parm.setPalette->palette->start, o->parm.setPalette->palette->data, o->parm.setPalette->palette->colors*sizeof(gRGB));
710 delete[] o->parm.setPalette->palette->data;
711 delete o->parm.setPalette->palette;
712 delete o->parm.setPalette;
714 case gOpcode::mergePalette:
715 m_pixmap->mergePalette(*o->parm.mergePalette->target);
716 o->parm.mergePalette->target->Release();
717 delete o->parm.mergePalette;
721 ePoint start = o->parm.line->start + m_current_offset, end = o->parm.line->end + m_current_offset;
722 m_pixmap->line(m_current_clip, start, end, m_foreground_color);
726 case gOpcode::addClip:
727 m_clip_stack.push(m_current_clip);
728 o->parm.clip->region.moveBy(m_current_offset);
729 m_current_clip &= o->parm.clip->region;
732 case gOpcode::setClip:
733 o->parm.clip->region.moveBy(m_current_offset);
734 m_current_clip = o->parm.clip->region & eRect(ePoint(0, 0), m_pixmap->size());
737 case gOpcode::popClip:
738 if (!m_clip_stack.empty())
740 m_current_clip = m_clip_stack.top();
744 case gOpcode::setOffset:
745 if (o->parm.setOffset->rel)
746 m_current_offset += o->parm.setOffset->value;
748 m_current_offset = o->parm.setOffset->value;
749 delete o->parm.setOffset;
751 case gOpcode::waitVSync:
757 case gOpcode::enableSpinner:
760 case gOpcode::disableSpinner:
763 case gOpcode::incrementSpinner:
767 eFatal("illegal opcode %d. expect memory leak!", o->opcode);
771 gRGB gDC::getRGB(gColor col)
773 if ((!m_pixmap) || (!m_pixmap->surface->clut.data))
774 return gRGB(col, col, col);
777 eFatal("bla transp");
778 return gRGB(0, 0, 0, 0xFF);
780 return m_pixmap->surface->clut.data[col];
783 void gDC::enableSpinner()
785 ASSERT(m_spinner_saved);
787 /* save the background to restore it later. We need to negative position because we want to blit from the middle of the screen. */
788 m_spinner_saved->blit(*m_pixmap, -m_spinner_pos.topLeft(), gRegion(eRect(ePoint(0, 0), m_spinner_saved->size())), 0);
793 void gDC::disableSpinner()
795 ASSERT(m_spinner_saved);
797 /* restore background */
798 m_pixmap->blit(*m_spinner_saved, m_spinner_pos.topLeft(), gRegion(m_spinner_pos), 0);
801 void gDC::incrementSpinner()
803 ASSERT(m_spinner_saved);
810 for (i = 0; i < 5; ++i)
812 int x = i * 20 + m_spinner_pos.left();
813 int y = m_spinner_pos.top();
815 int col = ((blub - i) * 30) % 256;
817 m_pixmap->fill(eRect(x, y, 10, 10), gRGB(col, col, col));
821 void gDC::setSpinner(eRect pos)
824 ASSERT(m_pixmap->surface);
825 m_spinner_saved = new gPixmap(pos.size(), m_pixmap->surface->bpp);
831 eAutoInitPtr<gRC> init_grc(eAutoInitNumbers::graphic, "gRC");