-// for debugging use:
-// #define SYNC_PAINT
#include <unistd.h>
-#ifndef SYNC_PAINT
-#include <pthread.h>
-#endif
-
#include <lib/gdi/grc.h>
#include <lib/gdi/font.h>
#include <lib/base/init.h>
else
eDebug("RC thread created successfully");
#endif
+ m_spinner_enabled = 0;
}
DEFINE_REF(gRC);
if ( tmp == rp )
{
#ifndef SYNC_PAINT
+ pthread_cond_signal(&cond); // wakeup gdi thread
pthread_mutex_unlock(&mutex);
#else
thread();
queue[wp++]=o;
if ( wp == MAXSIZE )
wp = 0;
- pthread_mutex_unlock(&mutex);
if (o.opcode==gOpcode::flush||o.opcode==gOpcode::shutdown||o.opcode==gOpcode::notify)
#ifndef SYNC_PAINT
pthread_cond_signal(&cond); // wakeup gdi thread
+ pthread_mutex_unlock(&mutex);
#else
thread(); // paint
#endif
while (rp != wp)
{
#endif
+#ifndef SYNC_PAINT
pthread_mutex_lock(&mutex);
+#endif
if ( rp != wp )
{
gOpcode o(queue[rp++]);
if ( rp == MAXSIZE )
rp=0;
+#ifndef SYNC_PAINT
pthread_mutex_unlock(&mutex);
+#endif
if (o.opcode==gOpcode::shutdown)
break;
else if (o.opcode==gOpcode::notify)
need_notify = 1;
else
+ {
o.dc->exec(&o);
+ // o.dc is a gDC* filled with grabref... so we must release it here
+ o.dc->Release();
+ }
}
else
{
m_notify_pump.send(1);
}
#ifndef SYNC_PAINT
- pthread_cond_wait(&cond, &mutex);
+ while(rp == wp)
+ {
+
+ /* when the main thread is non-idle for a too long time without any display output,
+ we want to display a spinner. */
+
+ struct timeval time;
+ struct timespec timeout;
+ gettimeofday(&time, NULL);
+ timeout.tv_sec = time.tv_sec;
+ timeout.tv_nsec = time.tv_usec * 1000;
+
+ if (m_spinner_enabled)
+ timeout.tv_nsec += 100*1000*1000;
+ else
+ timeout.tv_nsec += 500*1000*1000;
+
+ /* yes, this is required. */
+ if (timeout.tv_nsec > 1000*1000*1000)
+ {
+ timeout.tv_nsec -= 1000*1000*1000;
+ timeout.tv_sec++;
+ }
+
+ int idle = 1;
+
+ if (pthread_cond_timedwait(&cond, &mutex, &timeout) == ETIMEDOUT)
+ {
+ if (eApp && !eApp->isIdle())
+ idle = 0;
+ }
+
+ pthread_mutex_unlock(&mutex);
+
+ if (!idle)
+ {
+ if (!m_spinner_enabled)
+ eDebug("main thread is non-idle! display spinner!");
+ enableSpinner();
+ } else
+ disableSpinner();
+ }
#endif
}
}
return instance;
}
+void gRC::enableSpinner()
+{
+ if (!m_spinner_dc)
+ {
+ eDebug("no spinner DC!");
+ return;
+ }
+
+ m_spinner_enabled = 1;
+
+ gOpcode o;
+ o.opcode = m_spinner_enabled ? gOpcode::incrementSpinner : gOpcode::enableSpinner;
+ m_spinner_dc->exec(&o);
+}
+
+void gRC::disableSpinner()
+{
+ if (!m_spinner_enabled)
+ return;
+
+ if (!m_spinner_dc)
+ {
+ eDebug("no spinner DC!");
+ return;
+ }
+
+ m_spinner_enabled = 0;
+
+ gOpcode o;
+ o.opcode = gOpcode::disableSpinner;
+ m_spinner_dc->exec(&o);
+}
+
static int gPainter_instances;
gPainter::gPainter(gDC *dc, eRect rect): m_dc(dc), m_rc(gRC::getInstance())
o.dc = m_dc.grabRef();
o.parm.renderText = new gOpcode::para::prenderText;
o.parm.renderText->area = pos;
- o.parm.renderText->text = string;
+ o.parm.renderText->text = string.empty()?0:strdup(string.c_str());
o.parm.renderText->flags = flags;
m_rc->submit(o);
}
{
case gOpcode::setBackgroundColor:
m_background_color = o->parm.setColor->color;
+ m_background_color_rgb = getRGB(m_background_color);
delete o->parm.setColor;
break;
case gOpcode::setForegroundColor:
m_foreground_color = o->parm.setColor->color;
+ m_background_color_rgb = getRGB(m_foreground_color);
delete o->parm.setColor;
break;
case gOpcode::setBackgroundColorRGB:
- m_background_color = m_pixmap->surface->clut.findColor(o->parm.setColorRGB->color);
+ if (m_pixmap->needClut())
+ m_background_color = m_pixmap->surface->clut.findColor(o->parm.setColorRGB->color);
+ m_background_color_rgb = o->parm.setColorRGB->color;
delete o->parm.setColorRGB;
break;
case gOpcode::setForegroundColorRGB:
- m_foreground_color = m_pixmap->surface->clut.findColor(o->parm.setColorRGB->color);
+ if (m_pixmap->needClut())
+ m_foreground_color = m_pixmap->surface->clut.findColor(o->parm.setColorRGB->color);
+ m_foreground_color_rgb = o->parm.setColorRGB->color;
delete o->parm.setColorRGB;
break;
case gOpcode::setFont:
assert(m_current_font);
para->setFont(m_current_font);
para->renderString(o->parm.renderText->text, (flags & gPainter::RT_WRAP) ? RS_WRAP : 0);
-
+ if (o->parm.renderText->text)
+ free(o->parm.renderText->text);
if (flags & gPainter::RT_HALIGN_RIGHT)
para->realign(eTextPara::dirRight);
else if (flags & gPainter::RT_HALIGN_CENTER)
int correction = vcentered_top - bbox.top();
offset += ePoint(0, correction);
}
- para->blit(*this, offset, getRGB(m_background_color), getRGB(m_foreground_color));
+
+ para->blit(*this, offset, m_background_color_rgb, m_foreground_color_rgb);
delete o->parm.renderText;
break;
}
case gOpcode::renderPara:
{
- o->parm.renderPara->textpara->blit(*this, o->parm.renderPara->offset + m_current_offset, getRGB(m_background_color), getRGB(m_foreground_color));
+ o->parm.renderPara->textpara->blit(*this, o->parm.renderPara->offset + m_current_offset, m_background_color_rgb, m_foreground_color_rgb);
o->parm.renderPara->textpara->Release();
delete o->parm.renderPara;
break;
eRect area = o->parm.fill->area;
area.moveBy(m_current_offset);
gRegion clip = m_current_clip & area;
- m_pixmap->fill(clip, m_foreground_color);
+ if (m_pixmap->needClut())
+ m_pixmap->fill(clip, m_foreground_color);
+ else
+ m_pixmap->fill(clip, m_foreground_color_rgb);
delete o->parm.fill;
break;
}
{
o->parm.fillRegion->region.moveBy(m_current_offset);
gRegion clip = m_current_clip & o->parm.fillRegion->region;
- m_pixmap->fill(clip, m_foreground_color);
+ if (m_pixmap->needClut())
+ m_pixmap->fill(clip, m_foreground_color);
+ else
+ m_pixmap->fill(clip, m_foreground_color_rgb);
delete o->parm.fillRegion;
break;
}
case gOpcode::clear:
- m_pixmap->fill(m_current_clip, m_background_color);
+ if (m_pixmap->needClut())
+ m_pixmap->fill(m_current_clip, m_background_color);
+ else
+ m_pixmap->fill(m_current_clip, m_background_color_rgb);
delete o->parm.fill;
break;
case gOpcode::blit:
break;
case gOpcode::flush:
break;
+ case gOpcode::enableSpinner:
+ break;
+ case gOpcode::disableSpinner:
+ break;
+ case gOpcode::incrementSpinner:
+ break;
default:
eFatal("illegal opcode %d. expect memory leak!", o->opcode);
}