/*!
Draw the canvas
Paints all plot items to the canvasRect, using QwtPolarPlot::drawCanvas
and updates the paint cache.
\sa QwtPolarPlot::drawCanvas, setPaintAttributes(), testPaintAttributes()
*/
void QwtPolarCanvas::drawCanvas( QPainter *painter,
const QwtDoubleRect& canvasRect )
{
if ( !canvasRect.isValid() )
return;
if ( testPaintAttribute( PaintCached ) && d_data->cache )
{
*d_data->cache = QPixmap( contentsRect().size() );
#ifdef Q_WS_X11
#if QT_VERSION >= 0x040000
if ( d_data->cache->x11Info().screen() != x11Info().screen() )
d_data->cache->x11SetScreen( x11Info().screen() );
#else
if ( d_data->cache->x11Screen() != x11Screen() )
d_data->cache->x11SetScreen( x11Screen() );
#endif
#endif
d_data->cache->fill( this, d_data->cache->rect().topLeft() );
QPainter cachePainter( d_data->cache );
cachePainter.translate( -contentsRect().x(),
-contentsRect().y() );
plot()->drawCanvas( &cachePainter, canvasRect );
cachePainter.end();
painter->drawPixmap( canvasRect.topLeft().toPoint(), *d_data->cache );
}
else
plot()->drawCanvas( painter, canvasRect );
}
QPixmap QPixmap::copy( bool ignoreMask ) const
{
#if defined(Q_WS_X11)
int old = x11SetDefaultScreen( x11Screen() );
#endif // Q_WS_X11
QPixmap pm( data->w, data->h, data->d, data->bitmap, data->optim );
if ( !pm.isNull() ) { // copy the bitmap
#if defined(Q_WS_X11)
pm.cloneX11Data( this );
#endif // Q_WS_X11
if ( ignoreMask )
bitBlt( &pm, 0, 0, this, 0, 0, data->w, data->h, Qt::CopyROP, TRUE );
else
copyBlt( &pm, 0, 0, this, 0, 0, data->w, data->h );
}
#if defined(Q_WS_X11)
x11SetDefaultScreen( old );
#endif // Q_WS_X11
return pm;
}
bool NetscapePlugin::platformPostInitializeWindowless()
{
Display* display = x11HostDisplay();
m_npWindow.type = NPWindowTypeDrawable;
m_npWindow.window = 0;
int depth = displayDepth();
#if PLATFORM(QT)
ASSERT(depth == 16 || depth == 24 || depth == 32);
#endif
NPSetWindowCallbackStruct* callbackStruct = static_cast<NPSetWindowCallbackStruct*>(m_npWindow.ws_info);
callbackStruct->display = display;
callbackStruct->depth = depth;
XVisualInfo visualTemplate;
visualTemplate.screen = x11Screen();
visualTemplate.depth = depth;
visualTemplate.c_class = TrueColor;
int numMatching;
XVisualInfo* visualInfo = XGetVisualInfo(display, VisualScreenMask | VisualDepthMask | VisualClassMask,
&visualTemplate, &numMatching);
ASSERT(visualInfo);
Visual* visual = visualInfo[0].visual;
ASSERT(visual);
XFree(visualInfo);
callbackStruct->visual = visual;
callbackStruct->colormap = XCreateColormap(display, rootWindowID(), visual, AllocNone);
callSetWindow();
return true;
}
void QwtPlotCanvas::drawCanvas(QPainter *painter)
{
if ( !contentsRect().isValid() )
return;
QRect clipRect = contentsRect();
if ( !cacheMode() || !QwtPaintBuffer::isEnabled() )
{
// If we don´t need the paint buffer as cache we can
// use the clip for painting to the buffer too.
if ( painter && !painter->clipRegion().isNull() )
clipRect = painter->clipRegion().boundingRect();
}
QwtPaintBuffer paintBuffer(this, clipRect, painter);
((QwtPlot *)parent())->drawCanvas(paintBuffer.painter());
if ( cacheMode() )
{
if ( d_cache == NULL )
{
d_cache = new QPixmap(contentsRect().size());
#if QT_VERSION >= 300
#ifdef Q_WS_X11
if ( d_cache->x11Screen() != x11Screen() )
d_cache->x11SetScreen(x11Screen());
#endif
#endif
}
else
d_cache->resize(contentsRect().size());
if ( QwtPaintBuffer::isEnabled() )
*d_cache = paintBuffer.buffer();
else
{
d_cache->fill(this, 0, 0);
QPainter cachePainter(d_cache);
cachePainter.translate(-contentsRect().x(),
-contentsRect().y());
((QwtPlot *)parent())->drawCanvas(&cachePainter);
}
}
}
static inline int displayDepth()
{
#if PLATFORM(QT)
return XDefaultDepth(NetscapePlugin::x11HostDisplay(), x11Screen());
#elif PLATFORM(GTK)
return gdk_visual_get_depth(gdk_screen_get_system_visual(gdk_screen_get_default()));
#else
return 0;
#endif
}
static inline int displayDepth()
{
#if PLATFORM(QT)
return XDefaultDepth(NetscapePlugin::x11HostDisplay(), x11Screen());
#elif PLATFORM(GTK)
return gdk_visual_get_depth(gdk_screen_get_system_visual(gdk_screen_get_default()));
#elif PLATFORM(EFL) && defined(HAVE_ECORE_X)
return ecore_x_default_depth_get(NetscapePlugin::x11HostDisplay(), ecore_x_default_screen_get());
#else
return 0;
#endif
}
void QPixmap::setMask( const QBitmap &newmask )
{
const QPixmap *tmp = &newmask; // dec cxx bug
if ( (data == tmp->data) ||
( newmask.handle() && newmask.handle() == handle() ) ) {
QPixmap m = tmp->copy( TRUE );
setMask( *((QBitmap*)&m) );
data->selfmask = TRUE; // mask == pixmap
return;
}
if ( newmask.isNull() ) { // reset the mask
if (data->mask) {
detach();
data->selfmask = FALSE;
delete data->mask;
data->mask = 0;
}
return;
}
detach();
data->selfmask = FALSE;
if ( newmask.width() != width() || newmask.height() != height() ) {
#if defined(QT_CHECK_RANGE)
qWarning( "QPixmap::setMask: The pixmap and the mask must have "
"the same size" );
#endif
return;
}
#if defined(Q_WS_MAC) || (defined(Q_WS_X11) && !defined(QT_NO_XFTFREETYPE))
// when setting the mask, we get rid of the alpha channel completely
delete data->alphapm;
data->alphapm = 0;
#endif // Q_WS_X11 && !QT_NO_XFTFREETYPE
delete data->mask;
QBitmap* newmaskcopy;
if ( newmask.mask() )
newmaskcopy = (QBitmap*)new QPixmap( tmp->copy( TRUE ) );
else
newmaskcopy = new QBitmap( newmask );
#ifdef Q_WS_X11
newmaskcopy->x11SetScreen( x11Screen() );
#endif
data->mask = newmaskcopy;
}
void *QXcbNativeInterface::nativeResourceForIntegration(const QByteArray &resourceString)
{
void *result = 0;
switch (resourceType(resourceString)) {
case StartupId:
result = startupId();
break;
case X11Screen:
result = x11Screen();
break;
case RootWindow:
result = rootWindow();
break;
default:
break;
}
return result;
}
void QPixmap::resize( int w, int h )
{
if ( w < 1 || h < 1 ) { // becomes null
QPixmap pm( 0, 0, 0, data->bitmap, data->optim );
*this = pm;
return;
}
int d;
if ( depth() > 0 )
d = depth();
else
d = isQBitmap() ? 1 : -1;
// Create new pixmap
QPixmap pm( w, h, d, data->bitmap, data->optim );
#ifdef Q_WS_X11
pm.x11SetScreen( x11Screen() );
#endif // Q_WS_X11
if ( !data->uninit && !isNull() ) // has existing pixmap
bitBlt( &pm, 0, 0, this, 0, 0, // copy old pixmap
QMIN(width(), w),
QMIN(height(),h), CopyROP, TRUE );
#if defined(Q_WS_MAC)
if(data->alphapm) {
data->alphapm->resize(w, h);
} else
#elif defined(Q_WS_X11) && !defined(QT_NO_XFTFREETYPE)
if (data->alphapm)
qWarning("QPixmap::resize: TODO: resize alpha data");
else
#endif // Q_WS_X11
if ( data->mask ) { // resize mask as well
if ( data->selfmask ) { // preserve self-mask
pm.setMask( *((QBitmap*)&pm) );
} else { // independent mask
QBitmap m = *data->mask;
m.resize( w, h );
pm.setMask( m );
}
}
*this = pm;
}
NetscapePluginX11::NetscapePluginX11(NetscapePlugin& plugin, Display* display)
: m_plugin(plugin)
, m_pluginDisplay(display)
{
Display* hostDisplay = x11HostDisplay();
int depth = displayDepth();
m_setWindowCallbackStruct.display = hostDisplay;
m_setWindowCallbackStruct.depth = depth;
XVisualInfo visualTemplate;
visualTemplate.screen = x11Screen();
visualTemplate.depth = depth;
visualTemplate.c_class = TrueColor;
int numMatching;
XUniquePtr<XVisualInfo> visualInfo(XGetVisualInfo(hostDisplay, VisualScreenMask | VisualDepthMask | VisualClassMask, &visualTemplate, &numMatching));
ASSERT(visualInfo);
Visual* visual = visualInfo.get()[0].visual;
ASSERT(visual);
m_setWindowCallbackStruct.visual = visual;
m_setWindowCallbackStruct.colormap = XCreateColormap(hostDisplay, rootWindowID(), visual, AllocNone);
}
void KuickShow::initImlibParams( ImData *idata, ImlibInitParams *par )
{
par->flags = ( PARAMS_REMAP | PARAMS_VISUALID | PARAMS_SHAREDMEM | PARAMS_SHAREDPIXMAPS |
PARAMS_FASTRENDER | PARAMS_HIQUALITY | PARAMS_DITHER |
PARAMS_IMAGECACHESIZE | PARAMS_PIXMAPCACHESIZE );
Visual* defaultvis = DefaultVisual(x11Display(), x11Screen());
par->paletteoverride = idata->ownPalette ? 1 : 0;
par->remap = idata->fastRemap ? 1 : 0;
par->fastrender = idata->fastRender ? 1 : 0;
par->hiquality = idata->dither16bit ? 1 : 0;
par->dither = idata->dither8bit ? 1 : 0;
par->sharedmem = 1;
par->sharedpixmaps = 1;
par->visualid = defaultvis->visualid;
uint maxcache = idata->maxCache;
// 0 == no cache
par->imagecachesize = maxcache * 1024;
par->pixmapcachesize = maxcache * 1024;
}
/*!
Draw the the canvas
Paints all plot items to the contentsRect(), using QwtPlot::drawCanvas
and updates the paint cache.
\param painter Painter
\sa QwtPlot::drawCanvas(), setPaintAttributes(), testPaintAttributes()
*/
void QwtPlotCanvas::drawCanvas(QPainter *painter)
{
if ( !contentsRect().isValid() )
return;
QBrush bgBrush;
#if QT_VERSION >= 0x040000
bgBrush = palette().brush(backgroundRole());
#else
QColorGroup::ColorRole role =
QPalette::backgroundRoleFromMode( backgroundMode() );
bgBrush = colorGroup().brush( role );
#endif
if ( d_data->paintAttributes & PaintCached && d_data->cache )
{
*d_data->cache = QPixmap(contentsRect().size());
#ifdef Q_WS_X11
#if QT_VERSION >= 0x040000
if ( d_data->cache->x11Info().screen() != x11Info().screen() )
d_data->cache->x11SetScreen(x11Info().screen());
#else
if ( d_data->cache->x11Screen() != x11Screen() )
d_data->cache->x11SetScreen(x11Screen());
#endif
#endif
if ( d_data->paintAttributes & PaintPacked )
{
QPainter bgPainter(d_data->cache);
bgPainter.setPen(Qt::NoPen);
bgPainter.setBrush(bgBrush);
bgPainter.drawRect(d_data->cache->rect());
}
else
d_data->cache->fill(this, d_data->cache->rect().topLeft());
QPainter cachePainter(d_data->cache);
cachePainter.translate(-contentsRect().x(),
-contentsRect().y());
((QwtPlot *)parent())->drawCanvas(&cachePainter);
cachePainter.end();
painter->drawPixmap(contentsRect(), *d_data->cache);
}
else
{
#if QT_VERSION >= 0x040000
if ( d_data->paintAttributes & PaintPacked )
#endif
{
painter->save();
painter->setPen(Qt::NoPen);
painter->setBrush(bgBrush);
painter->drawRect(contentsRect());
painter->restore();
}
((QwtPlot *)parent())->drawCanvas(painter);
}
}
