You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1358 lines
35 KiB
1358 lines
35 KiB
/* vi: ts=8 sts=4 sw=4
|
|
* kate: space-indent on; tab-width 8; indent-width 4; indent-mode cstyle;
|
|
*
|
|
* This file is part of the KDE project, module kdesktop.
|
|
* Copyright (C) 1999 Geert Jansen <g.t.jansen@stud.tue.nl>
|
|
*
|
|
* You can Freely distribute this program under the GNU Library General
|
|
* Public License. See the file "COPYING.LIB" for the exact licensing terms.
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#include <time.h>
|
|
#include <stdlib.h>
|
|
#include <utime.h>
|
|
|
|
#include <tqtimer.h>
|
|
#include <tqpainter.h>
|
|
#include <tqimage.h>
|
|
#include <tqfileinfo.h>
|
|
#include <tqdir.h>
|
|
|
|
#include <dcopclient.h>
|
|
#include <tdeapplication.h>
|
|
#include <kdebug.h>
|
|
#include <kstandarddirs.h>
|
|
#include <kimageeffect.h>
|
|
#include <kprocess.h>
|
|
#include <kpixmapio.h>
|
|
#include <tdetempfile.h>
|
|
#include <kcursor.h>
|
|
#include <kmimetype.h>
|
|
#include <tdefilemetainfo.h>
|
|
|
|
#ifdef HAVE_LIBART
|
|
#include <ksvgiconengine.h>
|
|
#endif
|
|
|
|
#include "bgdefaults.h"
|
|
#include "bghash.h"
|
|
#include "bgrender.h"
|
|
|
|
#include <X11/Xlib.h>
|
|
|
|
#include <config.h>
|
|
|
|
/**** KBackgroundRenderer ****/
|
|
|
|
|
|
KBackgroundRenderer::KBackgroundRenderer(int desk, int screen, bool drawBackgroundPerScreen, TDEConfig *config)
|
|
: KBackgroundSettings(desk, screen, drawBackgroundPerScreen, config)
|
|
{
|
|
m_State = 0;
|
|
m_isBusyCursor = false;
|
|
m_enableBusyCursor = false;
|
|
m_pDirs = TDEGlobal::dirs();
|
|
m_rSize = m_Size = drawBackgroundPerScreen ? TDEApplication::desktop()->screenGeometry(screen).size() : TDEApplication::desktop()->geometry().size();
|
|
m_pProc = 0L;
|
|
m_Tempfile = 0L;
|
|
m_bPreview = false;
|
|
m_Cached = false;
|
|
m_TilingEnabled = false;
|
|
|
|
m_pTimer = new TQTimer(this);
|
|
connect(m_pTimer, TQT_SIGNAL(timeout()), TQT_SLOT(render()));
|
|
}
|
|
|
|
|
|
KBackgroundRenderer::~KBackgroundRenderer()
|
|
{
|
|
cleanup();
|
|
delete m_Tempfile;
|
|
m_Tempfile = 0;
|
|
}
|
|
|
|
|
|
void KBackgroundRenderer::setSize(const TQSize &size)
|
|
{
|
|
m_rSize = m_Size = size;
|
|
}
|
|
|
|
/*
|
|
* Re-configure because the desktop has been resized.
|
|
*/
|
|
void KBackgroundRenderer::desktopResized()
|
|
{
|
|
m_State = 0;
|
|
m_rSize = drawBackgroundPerScreen() ? TDEApplication::desktop()->screenGeometry(screen()).size() : TDEApplication::desktop()->geometry().size();
|
|
if( !m_bPreview )
|
|
m_Size = m_rSize;
|
|
}
|
|
|
|
|
|
void KBackgroundRenderer::tile(TQImage& dest, TQRect rect, const TQImage& src)
|
|
{
|
|
rect &= dest.rect();
|
|
|
|
int x, y;
|
|
int h = rect.height(), w = rect.width();
|
|
int offx = rect.x(), offy = rect.y();
|
|
int sw = src.width(), sh = src.height();
|
|
|
|
for (y=offy; y<offy+h; y++)
|
|
for (x=offx; x<offx+w; x++)
|
|
dest.setPixel(x, y, src.pixel(x%sw, y%sh));
|
|
}
|
|
|
|
|
|
/*
|
|
* Build a command line to run the program.
|
|
*/
|
|
|
|
TQString KBackgroundRenderer::buildCommand()
|
|
{
|
|
TQString num;
|
|
int pos = 0;
|
|
|
|
TQString cmd;
|
|
if (m_bPreview)
|
|
cmd = previewCommand();
|
|
else
|
|
cmd = command();
|
|
|
|
if (cmd.isEmpty())
|
|
return TQString();
|
|
|
|
while ((pos = cmd.find('%', pos)) != -1) {
|
|
|
|
if (pos == (int) (cmd.length() - 1))
|
|
break;
|
|
|
|
switch (cmd.at(pos+1).latin1()) {
|
|
case 'f':
|
|
createTempFile();
|
|
cmd.replace(pos, 2, KShellProcess::quote(m_Tempfile->name()));
|
|
pos += m_Tempfile->name().length() - 2;
|
|
break;
|
|
|
|
case 'x':
|
|
num.setNum(m_Size.width());
|
|
cmd.replace(pos, 2, num);
|
|
pos += num.length() - 2;
|
|
break;
|
|
|
|
case 'y':
|
|
num.setNum(m_Size.height());
|
|
cmd.replace(pos, 2, num);
|
|
pos += num.length() - 2;
|
|
break;
|
|
|
|
case '%':
|
|
cmd.replace(pos, 2, "%");
|
|
pos--;
|
|
break;
|
|
default:
|
|
++pos; // avoid infinite loop
|
|
break;
|
|
}
|
|
|
|
}
|
|
return cmd;
|
|
}
|
|
|
|
|
|
/*
|
|
* Create a background tile. If the background mode is `Program',
|
|
* this is asynchronous.
|
|
*/
|
|
int KBackgroundRenderer::doBackground(bool quit)
|
|
{
|
|
if (m_State & BackgroundDone)
|
|
return Done;
|
|
int bgmode = backgroundMode();
|
|
|
|
if (!enabled())
|
|
bgmode= Flat;
|
|
|
|
if (quit) {
|
|
if (bgmode == Program && m_pProc)
|
|
m_pProc->kill();
|
|
return Done;
|
|
}
|
|
|
|
int retval = Done;
|
|
TQString file;
|
|
|
|
static unsigned int tileWidth = 0;
|
|
static unsigned int tileHeight = 0;
|
|
if( tileWidth == 0 )
|
|
{
|
|
int tile_val = TQPixmap::defaultDepth() >= 24 ? 1 : 2;
|
|
// some dithering may be needed even with bpb==15/16, so don't use tileWidth==1
|
|
// for them
|
|
// with tileWidth>2, repainting the desktop causes nasty effect (XFree86 4.1.0 )
|
|
if( XQueryBestTile( tqt_xdisplay(), tqt_xrootwin(), tile_val, tile_val,
|
|
&tileWidth, &tileHeight ) != Success )
|
|
tileWidth = tileHeight = tile_val; // some defaults
|
|
}
|
|
switch (bgmode) {
|
|
|
|
case Flat:
|
|
// this can be tiled correctly without problems
|
|
m_Background.create( tileWidth, tileHeight, 32);
|
|
m_Background.fill(colorA().rgb());
|
|
break;
|
|
|
|
case Pattern:
|
|
{
|
|
if (pattern().isEmpty())
|
|
break;
|
|
file = m_pDirs->findResource("dtop_pattern", pattern());
|
|
if (file.isEmpty())
|
|
break;
|
|
|
|
m_Background.load(file);
|
|
if (m_Background.isNull())
|
|
break;
|
|
int w = m_Background.width();
|
|
int h = m_Background.height();
|
|
if ((w > m_Size.width()) || (h > m_Size.height())) {
|
|
w = TQMIN(w, m_Size.width());
|
|
h = TQMIN(h, m_Size.height());
|
|
m_Background = m_Background.copy(0, 0, w, h);
|
|
}
|
|
KImageEffect::flatten(m_Background, colorA(), colorB(), 0);
|
|
break;
|
|
}
|
|
case Program:
|
|
if (m_State & BackgroundStarted)
|
|
break;
|
|
m_State |= BackgroundStarted;
|
|
createTempFile();
|
|
|
|
file = buildCommand();
|
|
if (file.isEmpty())
|
|
break;
|
|
|
|
delete m_pProc;
|
|
m_pProc = new KShellProcess;
|
|
*m_pProc << file;
|
|
connect(m_pProc, TQT_SIGNAL(processExited(TDEProcess *)),
|
|
TQT_SLOT(slotBackgroundDone(TDEProcess *)));
|
|
m_pProc->start(KShellProcess::NotifyOnExit);
|
|
retval = Wait;
|
|
break;
|
|
|
|
case HorizontalGradient:
|
|
{
|
|
TQSize size = m_Size;
|
|
// on <16bpp displays the gradient sucks when tiled because of dithering
|
|
if( canTile())
|
|
size.setHeight( tileHeight );
|
|
m_Background = KImageEffect::gradient(size, colorA(), colorB(),
|
|
KImageEffect::HorizontalGradient, 0);
|
|
break;
|
|
}
|
|
case VerticalGradient:
|
|
{
|
|
TQSize size = m_Size;
|
|
// on <16bpp displays the gradient sucks when tiled because of dithering
|
|
if( canTile())
|
|
size.setWidth( tileWidth );
|
|
m_Background = KImageEffect::gradient(size, colorA(), colorB(),
|
|
KImageEffect::VerticalGradient, 0);
|
|
break;
|
|
}
|
|
case PyramidGradient:
|
|
m_Background = KImageEffect::gradient(m_Size, colorA(), colorB(),
|
|
KImageEffect::PyramidGradient, 0);
|
|
break;
|
|
|
|
case PipeCrossGradient:
|
|
m_Background = KImageEffect::gradient(m_Size, colorA(), colorB(),
|
|
KImageEffect::PipeCrossGradient, 0);
|
|
break;
|
|
|
|
case EllipticGradient:
|
|
m_Background = KImageEffect::gradient(m_Size, colorA(), colorB(),
|
|
KImageEffect::EllipticGradient, 0);
|
|
break;
|
|
}
|
|
|
|
if (retval == Done)
|
|
m_State |= BackgroundDone;
|
|
|
|
return retval;
|
|
}
|
|
|
|
|
|
int KBackgroundRenderer::doWallpaper(bool quit)
|
|
{
|
|
if (m_State & WallpaperDone)
|
|
return Done;
|
|
|
|
if (quit)
|
|
// currently no asynch. wallpapers
|
|
return Done;
|
|
|
|
int wpmode= enabled()?wallpaperMode():NoWallpaper;
|
|
|
|
m_Wallpaper = TQImage();
|
|
if (wpmode != NoWallpaper) {
|
|
wp_load:
|
|
if (currentWallpaper().isEmpty()) {
|
|
wpmode = NoWallpaper;
|
|
goto wp_out;
|
|
}
|
|
TQString file = m_pDirs->findResource("wallpaper", currentWallpaper());
|
|
if (file.isEmpty()) {
|
|
wpmode = NoWallpaper;
|
|
goto wp_out;
|
|
}
|
|
|
|
// _Don't_ use KMimeType, as it relies on tdesycoca which we really
|
|
// don't want in krootimage (tdm context).
|
|
//if ( KMimeType::findByPath( file )->is( "image/svg+xml" ) ) {
|
|
if (file.endsWith(".svg") || file.endsWith(".svgz")) {
|
|
#ifdef HAVE_LIBART
|
|
// Special stuff for SVG icons
|
|
KSVGIconEngine* svgEngine = new KSVGIconEngine();
|
|
|
|
//FIXME
|
|
//ksvgiconloader doesn't seem to let us find out the
|
|
//ratio of width to height so for the most part we just
|
|
//assume it's a square
|
|
int svgWidth;
|
|
int svgHeight;
|
|
switch (wpmode)
|
|
{
|
|
case Centred:
|
|
case CentredAutoFit:
|
|
svgHeight = (int)(m_Size.height() * 0.8);
|
|
svgWidth = svgHeight;
|
|
break;
|
|
case Tiled:
|
|
case CenterTiled:
|
|
svgHeight = (int)(m_Size.height() * 0.5);
|
|
svgWidth = svgHeight;
|
|
break;
|
|
case Scaled:
|
|
svgHeight = m_Size.height();
|
|
svgWidth = m_Size.width();
|
|
break;
|
|
case CentredMaxpect:
|
|
case ScaleAndCrop:
|
|
case TiledMaxpect:
|
|
svgHeight = m_Size.height();
|
|
svgWidth = svgHeight;
|
|
break;
|
|
case NoWallpaper:
|
|
default:
|
|
kdWarning() << k_funcinfo << "unknown diagram type" << endl;
|
|
svgHeight = m_Size.height();
|
|
svgWidth = svgHeight;
|
|
break;
|
|
}
|
|
//FIXME hack due to strangeness with
|
|
//background control modules
|
|
if ( svgHeight < 200 ) {
|
|
svgHeight *= 6;
|
|
svgWidth *= 6;
|
|
}
|
|
|
|
if (svgEngine->load(svgWidth, svgHeight, file )) {
|
|
TQImage *image = svgEngine->image();
|
|
m_Wallpaper = *image;
|
|
delete image;
|
|
} else {
|
|
kdWarning() << "failed to load SVG file " << file << endl;
|
|
}
|
|
|
|
delete svgEngine;
|
|
#else //not libart
|
|
kdWarning() << k_funcinfo
|
|
<< "tried to load SVG file but libart not installed" << endl;
|
|
#endif
|
|
} else {
|
|
m_Wallpaper.load(file);
|
|
}
|
|
if (m_Wallpaper.isNull()) {
|
|
if (discardCurrentWallpaper())
|
|
goto wp_load;
|
|
wpmode = NoWallpaper;
|
|
goto wp_out;
|
|
}
|
|
m_Wallpaper = m_Wallpaper.convertDepth(32, Qt::DiffuseAlphaDither);
|
|
|
|
// If we're previewing, scale the wallpaper down to make the preview
|
|
// look more like the real desktop.
|
|
if (m_bPreview) {
|
|
int xs = m_Wallpaper.width() * m_Size.width() / m_rSize.width();
|
|
int ys = m_Wallpaper.height() * m_Size.height() / m_rSize.height();
|
|
if ((xs < 1) || (ys < 1))
|
|
{
|
|
xs = ys = 1;
|
|
}
|
|
if( m_Wallpaper.size() != TQSize( xs, ys ))
|
|
m_Wallpaper = m_Wallpaper.smoothScale(xs, ys);
|
|
}
|
|
|
|
// HACK: Use KFileMetaInfo only when we're attached to DCOP.
|
|
// KFileMetaInfo needs tdesycoca and so on, but this code is
|
|
// used also in krootimage (which in turn is used by tdm).
|
|
if( kapp->dcopClient()->isAttached()) {
|
|
KFileMetaInfo metaInfo(file);
|
|
if (metaInfo.isValid() && metaInfo.item("Orientation").isValid()) {
|
|
switch (metaInfo.item("Orientation").string().toInt()) {
|
|
case 2:
|
|
// Flipped horizontally
|
|
m_Wallpaper = m_Wallpaper.mirror(true, false);
|
|
break;
|
|
case 3:
|
|
// Rotated 180 degrees
|
|
m_Wallpaper = KImageEffect::rotate(m_Wallpaper, KImageEffect::Rotate180);
|
|
break;
|
|
case 4:
|
|
// Flipped vertically
|
|
m_Wallpaper = m_Wallpaper.mirror(false, true);
|
|
break;
|
|
case 5:
|
|
// Rotated 90 degrees & flipped horizontally
|
|
m_Wallpaper = KImageEffect::rotate(m_Wallpaper, KImageEffect::Rotate90).mirror(true, false);
|
|
break;
|
|
case 6:
|
|
// Rotated 90 degrees
|
|
m_Wallpaper = KImageEffect::rotate(m_Wallpaper, KImageEffect::Rotate90);
|
|
break;
|
|
case 7:
|
|
// Rotated 90 degrees & flipped vertically
|
|
m_Wallpaper = KImageEffect::rotate(m_Wallpaper, KImageEffect::Rotate90).mirror(false, true);
|
|
break;
|
|
case 8:
|
|
// Rotated 270 degrees
|
|
m_Wallpaper = KImageEffect::rotate(m_Wallpaper, KImageEffect::Rotate270);
|
|
break;
|
|
case 1:
|
|
default:
|
|
// Normal or invalid orientation
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
wp_out:
|
|
|
|
if (m_Background.isNull()) {
|
|
m_Background.create(8, 8, 32);
|
|
m_Background.fill(colorA().rgb());
|
|
}
|
|
|
|
int retval = Done;
|
|
|
|
int w = m_Size.width(); // desktop width/height
|
|
int h = m_Size.height();
|
|
|
|
int ww = m_Wallpaper.width(); // wallpaper width/height
|
|
int wh = m_Wallpaper.height();
|
|
|
|
m_WallpaperRect = TQRect(); // to be filled destination rectangle; may exceed desktop!
|
|
|
|
switch (wpmode)
|
|
{
|
|
case NoWallpaper:
|
|
break;
|
|
case Centred:
|
|
m_WallpaperRect.setRect((w - ww) / 2, (h - wh) / 2, ww, wh);
|
|
break;
|
|
case Tiled:
|
|
m_WallpaperRect.setRect(0, 0, w, h);
|
|
break;
|
|
case CenterTiled:
|
|
m_WallpaperRect.setCoords(-ww + ((w - ww) / 2) % ww, -wh + ((h - wh) / 2) % wh, w-1, h-1);
|
|
break;
|
|
case Scaled:
|
|
ww = w;
|
|
wh = h;
|
|
if( m_WallpaperRect.size() != TQSize( w, h ))
|
|
m_Wallpaper = m_Wallpaper.smoothScale( w, h );
|
|
m_WallpaperRect.setRect(0, 0, w, h);
|
|
break;
|
|
case CentredAutoFit:
|
|
if( ww <= w && wh <= h ) {
|
|
m_WallpaperRect.setRect((w - ww) / 2, (h - wh) / 2, ww, wh); // like Centred
|
|
break;
|
|
}
|
|
// fall through
|
|
case CentredMaxpect:
|
|
{
|
|
double sx = (double) w / ww;
|
|
double sy = (double) h / wh;
|
|
if (sx > sy) {
|
|
ww = (int)(sy * ww);
|
|
wh = h;
|
|
} else {
|
|
wh = (int)(sx * wh);
|
|
ww = w;
|
|
}
|
|
if( m_WallpaperRect.size() != TQSize( ww, wh ))
|
|
m_Wallpaper = m_Wallpaper.smoothScale(ww, wh);
|
|
m_WallpaperRect.setRect((w - ww) / 2, (h - wh) / 2, ww, wh);
|
|
break;
|
|
}
|
|
case TiledMaxpect:
|
|
{
|
|
double sx = (double) w / ww;
|
|
double sy = (double) h / wh;
|
|
if (sx > sy) {
|
|
ww = (int)(sy * ww);
|
|
wh = h;
|
|
} else {
|
|
wh = (int)(sx * wh);
|
|
ww = w;
|
|
}
|
|
if( m_WallpaperRect.size() != TQSize( ww, wh ))
|
|
m_Wallpaper = m_Wallpaper.smoothScale(ww, wh);
|
|
m_WallpaperRect.setRect(0, 0, w, h);
|
|
break;
|
|
}
|
|
case ScaleAndCrop:
|
|
{
|
|
double sx = (double) w / ww;
|
|
double sy = (double) h / wh;
|
|
if (sx > sy) {
|
|
//Case 1: x needs bigger scaling. Lets increase x and leave part of y offscreen
|
|
ww = w;
|
|
wh=(int)(sx * wh);
|
|
} else {
|
|
//Case 2: y needs bigger scaling. Lets increase y and leave part of x offscreen
|
|
wh = h;
|
|
ww = (int)(sy*ww);
|
|
}
|
|
if( m_WallpaperRect.size() != TQSize( ww, wh ))
|
|
m_Wallpaper = m_Wallpaper.smoothScale(ww, wh);
|
|
m_WallpaperRect.setRect((w - ww) / 2, (h - wh) / 2,w, h);
|
|
break;
|
|
}
|
|
}
|
|
|
|
wallpaperBlend();
|
|
|
|
if (retval == Done)
|
|
m_State |= WallpaperDone;
|
|
|
|
return retval;
|
|
}
|
|
|
|
bool KBackgroundRenderer::canTile() const
|
|
{
|
|
return m_TilingEnabled && optimize();
|
|
}
|
|
|
|
extern bool tqt_use_xrender; // in Qt ( qapplication_x11.cpp )
|
|
|
|
void KBackgroundRenderer::wallpaperBlend()
|
|
{
|
|
if( !enabled() || wallpaperMode() == NoWallpaper
|
|
|| (blendMode() == NoBlending && ( tqt_use_xrender || !m_Wallpaper.hasAlphaBuffer()))) {
|
|
fastWallpaperBlend();
|
|
}
|
|
else {
|
|
fullWallpaperBlend();
|
|
}
|
|
}
|
|
|
|
// works only for NoBlending and no alpha in wallpaper
|
|
// but is much faster than TQImage fidling
|
|
void KBackgroundRenderer::fastWallpaperBlend()
|
|
{
|
|
m_Image = TQImage();
|
|
// copy background to m_pPixmap
|
|
if( !enabled() || (wallpaperMode() == NoWallpaper && canTile())) {
|
|
// if there's no wallpaper, no need to tile the pixmap to the size of desktop, as X does
|
|
// that automatically and using a smaller pixmap should save some memory
|
|
m_Pixmap.convertFromImage( m_Background );
|
|
return;
|
|
}
|
|
else if( wallpaperMode() == Tiled && !m_Wallpaper.hasAlphaBuffer() && canTile() && !m_bPreview ) {
|
|
// tiles will be tiled by X automatically
|
|
if( useShm()) {
|
|
KPixmapIO io;
|
|
m_Pixmap = io.convertToPixmap( m_Wallpaper );
|
|
}
|
|
else
|
|
m_Pixmap.convertFromImage( m_Wallpaper );
|
|
return;
|
|
}
|
|
else if( m_WallpaperRect.contains( TQRect( TQPoint( 0, 0 ), m_Size ))
|
|
&& !m_Wallpaper.hasAlphaBuffer()) // wallpaper covers all and no blending
|
|
m_Pixmap = TQPixmap( m_Size );
|
|
else if (m_Background.size() == m_Size)
|
|
m_Pixmap.convertFromImage( m_Background );
|
|
else {
|
|
m_Pixmap = TQPixmap( m_Size );
|
|
TQPainter p( &m_Pixmap );
|
|
TQPixmap pm;
|
|
pm.convertFromImage( m_Background );
|
|
p.drawTiledPixmap( 0, 0, m_Size.width(), m_Size.height(), pm );
|
|
}
|
|
|
|
// paint/alpha-blend wallpaper to destination rectangle of m_pPixmap
|
|
if (m_WallpaperRect.isValid()) {
|
|
TQPixmap wp_pixmap;
|
|
if( useShm() && !m_Wallpaper.hasAlphaBuffer()) {
|
|
KPixmapIO io;
|
|
wp_pixmap = io.convertToPixmap( m_Wallpaper );
|
|
}
|
|
else
|
|
wp_pixmap.convertFromImage( m_Wallpaper );
|
|
int ww = m_Wallpaper.width();
|
|
int wh = m_Wallpaper.height();
|
|
for (int y = m_WallpaperRect.top(); y < m_WallpaperRect.bottom(); y += wh) {
|
|
for (int x = m_WallpaperRect.left(); x < m_WallpaperRect.right(); x += ww) {
|
|
bitBlt( &m_Pixmap, x, y, &wp_pixmap, 0, 0, ww, wh );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void KBackgroundRenderer::fullWallpaperBlend()
|
|
{
|
|
m_Pixmap = TQPixmap();
|
|
int w = m_Size.width(); // desktop width/height
|
|
int h = m_Size.height();
|
|
// copy background to m_pImage
|
|
if (m_Background.size() == m_Size) {
|
|
m_Image = m_Background.copy();
|
|
|
|
if (m_Image.depth() < 32)
|
|
m_Image = m_Image.convertDepth(32, Qt::DiffuseAlphaDither);
|
|
|
|
} else {
|
|
m_Image.create(w, h, 32);
|
|
tile(m_Image, TQRect(0, 0, w, h), m_Background);
|
|
}
|
|
|
|
// blend wallpaper to destination rectangle of m_pImage
|
|
if (m_WallpaperRect.isValid())
|
|
{
|
|
int blendFactor = 100;
|
|
if (blendMode() == FlatBlending)
|
|
blendFactor = (blendBalance()+200)/4;
|
|
int ww = m_Wallpaper.width();
|
|
int wh = m_Wallpaper.height();
|
|
for (int y = m_WallpaperRect.top(); y < m_WallpaperRect.bottom(); y += wh) {
|
|
for (int x = m_WallpaperRect.left(); x < m_WallpaperRect.right(); x += ww) {
|
|
blend(m_Image, TQRect(x, y, ww, wh), m_Wallpaper,
|
|
TQPoint(-TQMIN(x, 0), -TQMIN(y, 0)), blendFactor);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// blend whole desktop
|
|
if ( wallpaperMode() != NoWallpaper) {
|
|
int bal = blendBalance();
|
|
|
|
switch( blendMode() ) {
|
|
case HorizontalBlending:
|
|
KImageEffect::blend( m_Image, m_Background,
|
|
KImageEffect::HorizontalGradient,
|
|
bal, 100 );
|
|
break;
|
|
|
|
case VerticalBlending:
|
|
KImageEffect::blend( m_Image, m_Background,
|
|
KImageEffect::VerticalGradient,
|
|
100, bal );
|
|
break;
|
|
|
|
case PyramidBlending:
|
|
KImageEffect::blend( m_Image, m_Background,
|
|
KImageEffect::PyramidGradient,
|
|
bal, bal );
|
|
break;
|
|
|
|
case PipeCrossBlending:
|
|
KImageEffect::blend( m_Image, m_Background,
|
|
KImageEffect::PipeCrossGradient,
|
|
bal, bal );
|
|
break;
|
|
|
|
case EllipticBlending:
|
|
KImageEffect::blend( m_Image, m_Background,
|
|
KImageEffect::EllipticGradient,
|
|
bal, bal );
|
|
break;
|
|
|
|
case IntensityBlending:
|
|
KImageEffect::modulate( m_Image, m_Background, reverseBlending(),
|
|
KImageEffect::Intensity, bal, KImageEffect::All );
|
|
break;
|
|
|
|
case SaturateBlending:
|
|
KImageEffect::modulate( m_Image, m_Background, reverseBlending(),
|
|
KImageEffect::Saturation, bal, KImageEffect::Gray );
|
|
break;
|
|
|
|
case ContrastBlending:
|
|
KImageEffect::modulate( m_Image, m_Background, reverseBlending(),
|
|
KImageEffect::Contrast, bal, KImageEffect::All );
|
|
break;
|
|
|
|
case HueShiftBlending:
|
|
KImageEffect::modulate( m_Image, m_Background, reverseBlending(),
|
|
KImageEffect::HueShift, bal, KImageEffect::Gray );
|
|
break;
|
|
|
|
case FlatBlending:
|
|
// Already handled
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Alpha blend an area from <src> with offset <soffs> to rectangle <dr> of <dst>
|
|
* Default offset is TQPoint(0, 0).
|
|
* blendfactor = [0, 100%]
|
|
*/
|
|
void KBackgroundRenderer::blend(TQImage& dst, TQRect dr, const TQImage& src, TQPoint soffs, int blendFactor)
|
|
{
|
|
int x, y, a;
|
|
dr &= dst.rect();
|
|
|
|
for (y = 0; y < dr.height(); y++) {
|
|
if (dst.scanLine(dr.y() + y) && src.scanLine(soffs.y() + y)) {
|
|
TQRgb *b, *d;
|
|
for (x = 0; x < dr.width(); x++) {
|
|
b = reinterpret_cast<TQRgb*>(dst.scanLine(dr.y() + y)
|
|
+ (dr.x() + x) * sizeof(TQRgb));
|
|
d = reinterpret_cast<TQRgb*>(const_cast<TQImage&>(src).scanLine(soffs.y() + y)
|
|
+ (soffs.x() + x) * sizeof(TQRgb));
|
|
a = (tqAlpha(*d) * blendFactor) / 100;
|
|
*b = tqRgb(tqRed(*b) - (((tqRed(*b) - tqRed(*d)) * a) >> 8),
|
|
tqGreen(*b) - (((tqGreen(*b) - tqGreen(*d)) * a) >> 8),
|
|
tqBlue(*b) - (((tqBlue(*b) - tqBlue(*d)) * a) >> 8));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void KBackgroundRenderer::slotBackgroundDone(TDEProcess *process)
|
|
{
|
|
Q_ASSERT(process == m_pProc);
|
|
m_State |= BackgroundDone;
|
|
|
|
if (m_pProc->normalExit() && !m_pProc->exitStatus()) {
|
|
m_Background.load(m_Tempfile->name());
|
|
m_State |= BackgroundDone;
|
|
}
|
|
|
|
m_Tempfile->unlink();
|
|
delete m_Tempfile; m_Tempfile = 0;
|
|
m_pTimer->start(0, true);
|
|
setBusyCursor(false);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Starts the rendering process.
|
|
*/
|
|
void KBackgroundRenderer::start(bool enableBusyCursor)
|
|
{
|
|
m_enableBusyCursor = enableBusyCursor;
|
|
setBusyCursor(true);
|
|
|
|
m_Cached = false;
|
|
|
|
m_State = Rendering;
|
|
m_pTimer->start(0, true);
|
|
}
|
|
|
|
|
|
/*
|
|
* This slot is connected to a timer event. It is called repeatedly until
|
|
* the rendering is done.
|
|
*/
|
|
void KBackgroundRenderer::render()
|
|
{
|
|
setBusyCursor(true);
|
|
if (!(m_State & Rendering))
|
|
return;
|
|
|
|
if( !(m_State & InitCheck)) {
|
|
TQString f = cacheFileName();
|
|
if( useCacheFile()) {
|
|
TQString w = m_pDirs->findResource("wallpaper", currentWallpaper());
|
|
TQFileInfo wi( w );
|
|
TQFileInfo fi( f );
|
|
if( wi.lastModified().isValid() && fi.lastModified().isValid()
|
|
&& wi.lastModified() < fi.lastModified()) {
|
|
TQImage im;
|
|
if( im.load( f, "PNG" )) {
|
|
m_Image = im;
|
|
m_Pixmap = TQPixmap( m_Size );
|
|
m_Pixmap.convertFromImage( m_Image );
|
|
m_Cached = true;
|
|
m_State |= InitCheck | BackgroundDone | WallpaperDone;
|
|
}
|
|
}
|
|
}
|
|
m_pTimer->start(0, true);
|
|
m_State |= InitCheck;
|
|
return;
|
|
}
|
|
|
|
int ret;
|
|
|
|
if (!(m_State & BackgroundDone)) {
|
|
ret = doBackground();
|
|
if (ret != Wait)
|
|
m_pTimer->start(0, true);
|
|
return;
|
|
}
|
|
|
|
// No async wallpaper
|
|
doWallpaper();
|
|
|
|
done();
|
|
setBusyCursor(false);
|
|
}
|
|
|
|
|
|
/*
|
|
* Rendering is finished.
|
|
*/
|
|
void KBackgroundRenderer::done()
|
|
{
|
|
setBusyCursor(false);
|
|
m_State |= AllDone;
|
|
emit imageDone(desk(), screen());
|
|
if(backgroundMode() == Program && m_pProc &&
|
|
m_pProc->normalExit() && m_pProc->exitStatus()) {
|
|
emit programFailure(desk(), m_pProc->exitStatus());
|
|
} else if(backgroundMode() == Program && m_pProc &&
|
|
!m_pProc->normalExit()) {
|
|
emit programFailure(desk(), -1);
|
|
} else if(backgroundMode() == Program) {
|
|
emit programSuccess(desk());
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* This function toggles a busy cursor on and off, for use in rendering.
|
|
* It is useful because of the ASYNC nature of the rendering - it is hard
|
|
* to make sure we don't set the busy cursor twice, but only restore
|
|
* once.
|
|
*/
|
|
void KBackgroundRenderer::setBusyCursor(bool isBusy) {
|
|
if(m_isBusyCursor == isBusy)
|
|
return;
|
|
if (isBusy && !m_enableBusyCursor)
|
|
return;
|
|
m_isBusyCursor = isBusy;
|
|
if(isBusy)
|
|
TQApplication::setOverrideCursor( KCursor::workingCursor() );
|
|
else
|
|
TQApplication::restoreOverrideCursor();
|
|
}
|
|
|
|
/*
|
|
* Stop the rendering.
|
|
*/
|
|
void KBackgroundRenderer::stop()
|
|
{
|
|
if (!(m_State & Rendering))
|
|
return;
|
|
|
|
doBackground(true);
|
|
doWallpaper(true);
|
|
m_State = 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Cleanup after rendering.
|
|
*/
|
|
void KBackgroundRenderer::cleanup()
|
|
{
|
|
setBusyCursor(false);
|
|
m_Background = TQImage();
|
|
m_Image = TQImage();
|
|
m_Pixmap = TQPixmap();
|
|
m_Wallpaper = TQImage();
|
|
delete m_pProc; m_pProc = 0L;
|
|
m_State = 0;
|
|
m_WallpaperRect = TQRect();
|
|
m_Cached = false;
|
|
}
|
|
|
|
|
|
void KBackgroundRenderer::setPreview(const TQSize &size)
|
|
{
|
|
if (size.isNull())
|
|
m_bPreview = false;
|
|
else {
|
|
m_bPreview = true;
|
|
m_Size = size;
|
|
}
|
|
}
|
|
|
|
|
|
TQPixmap KBackgroundRenderer::pixmap()
|
|
{
|
|
if (m_State & AllDone) {
|
|
if( m_Pixmap.isNull())
|
|
m_Pixmap.convertFromImage( m_Image );
|
|
return m_Pixmap;
|
|
}
|
|
return TQPixmap();
|
|
}
|
|
|
|
TQImage KBackgroundRenderer::image()
|
|
{
|
|
if (m_State & AllDone) {
|
|
if( m_Image.isNull())
|
|
fullWallpaperBlend(); // create from m_Pixmap
|
|
return m_Image;
|
|
}
|
|
return TQImage();
|
|
}
|
|
|
|
|
|
void KBackgroundRenderer::load(int desk, int screen, bool drawBackgroundPerScreen, bool reparseConfig)
|
|
{
|
|
if (m_State & Rendering)
|
|
stop();
|
|
|
|
cleanup();
|
|
m_bPreview = false;
|
|
m_Size = m_rSize;
|
|
|
|
KBackgroundSettings::load(desk, screen, drawBackgroundPerScreen, reparseConfig);
|
|
}
|
|
|
|
void KBackgroundRenderer::createTempFile()
|
|
{
|
|
if( !m_Tempfile )
|
|
m_Tempfile = new KTempFile();
|
|
}
|
|
|
|
TQString KBackgroundRenderer::cacheFileName()
|
|
{
|
|
TQString f = fingerprint();
|
|
f.replace ( ':', '_' ); // avoid characters that shouldn't be in filenames
|
|
f.replace ( '/', '#' );
|
|
f = locateLocal( "cache", TQString( "background/%1x%2_%3.png" )
|
|
.arg( m_Size.width()).arg( m_Size.height()).arg( f ));
|
|
return f;
|
|
}
|
|
|
|
bool KBackgroundRenderer::useCacheFile() const
|
|
{
|
|
if( !enabled())
|
|
return false;
|
|
if( backgroundMode() == Program )
|
|
return false; // don't cache these at all
|
|
if( wallpaperMode() == NoWallpaper )
|
|
return false; // generating only background patterns should be always faster
|
|
TQString file = currentWallpaper();
|
|
if( file.endsWith(".svg") || file.endsWith(".svgz"))
|
|
return true; // cache these, they can be bloody slow
|
|
switch( backgroundMode())
|
|
{
|
|
case NoWallpaper:
|
|
case Centred:
|
|
case Tiled:
|
|
case CenterTiled:
|
|
return false; // these don't need scaling
|
|
case CentredMaxpect:
|
|
case TiledMaxpect:
|
|
case Scaled:
|
|
case CentredAutoFit:
|
|
case ScaleAndCrop:
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
void KBackgroundRenderer::saveCacheFile()
|
|
{
|
|
if( !( m_State & AllDone ))
|
|
return;
|
|
if( !useCacheFile())
|
|
return;
|
|
if( m_Image.isNull())
|
|
fullWallpaperBlend(); // generate from m_Pixmap
|
|
TQString f = cacheFileName();
|
|
if( TDEStandardDirs::exists( f ) || m_Cached )
|
|
utime( TQFile::encodeName( f ), NULL );
|
|
else {
|
|
m_Image.save( f, "PNG" );
|
|
// remove old entries from the cache
|
|
TQDir dir( locateLocal( "cache", "background/" ));
|
|
if( const TQFileInfoList* list = dir.entryInfoList( "*.png", TQDir::Files, TQDir::Time | TQDir::Reversed )) {
|
|
int size = 0;
|
|
for( TQFileInfoListIterator it( *list );
|
|
TQFileInfo* info = it.current();
|
|
++it )
|
|
size += info->size();
|
|
for( TQFileInfoListIterator it( *list );
|
|
TQFileInfo* info = it.current();
|
|
++it ) {
|
|
if( size < 8 * 1024 * 1024 )
|
|
break;
|
|
// keep everything newer than 10 minutes if the total size is less than 50M (just in case)
|
|
if( size < 50 * 1024 * 1024
|
|
&& ( time_t ) info->lastModified().toTime_t() >= time( NULL ) - 10 * 60 )
|
|
break;
|
|
size -= info->size();
|
|
TQFile::remove( info->absFilePath());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//BEGIN class KVirtualBGRenderer
|
|
KVirtualBGRenderer::KVirtualBGRenderer( int desk, TDEConfig *config )
|
|
{
|
|
m_pPixmap = 0l;
|
|
m_desk = desk;
|
|
m_numRenderers = 0;
|
|
m_scaleX = 1;
|
|
m_scaleY = 1;
|
|
|
|
// The following code is borrowed from KBackgroundSettings::KBackgroundSettings
|
|
if (!config) {
|
|
int screen_number = 0;
|
|
if (tqt_xdisplay())
|
|
screen_number = DefaultScreen(tqt_xdisplay());
|
|
TQCString configname;
|
|
if (screen_number == 0)
|
|
configname = "kdesktoprc";
|
|
else
|
|
configname.sprintf("kdesktop-screen-%drc", screen_number);
|
|
|
|
m_pConfig = new TDEConfig(configname, false, false);
|
|
m_bDeleteConfig = true;
|
|
} else {
|
|
m_pConfig = config;
|
|
m_bDeleteConfig = false;
|
|
}
|
|
|
|
initRenderers();
|
|
m_size = TDEApplication::desktop()->geometry().size();
|
|
}
|
|
|
|
KVirtualBGRenderer::~KVirtualBGRenderer()
|
|
{
|
|
for (unsigned i=0; i<m_numRenderers; ++i)
|
|
delete m_renderer[i];
|
|
|
|
delete m_pPixmap;
|
|
|
|
if (m_bDeleteConfig)
|
|
delete m_pConfig;
|
|
}
|
|
|
|
|
|
KBackgroundRenderer * KVirtualBGRenderer::renderer(unsigned screen)
|
|
{
|
|
return m_renderer[screen];
|
|
}
|
|
|
|
|
|
TQPixmap KVirtualBGRenderer::pixmap()
|
|
{
|
|
if (m_numRenderers == 1)
|
|
return m_renderer[0]->pixmap();
|
|
|
|
return *m_pPixmap;
|
|
}
|
|
|
|
|
|
bool KVirtualBGRenderer::needProgramUpdate()
|
|
{
|
|
for (unsigned i=0; i<m_numRenderers; ++i)
|
|
{
|
|
if ( m_renderer[i]->backgroundMode() == KBackgroundSettings::Program &&
|
|
m_renderer[i]->KBackgroundProgram::needUpdate() )
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
void KVirtualBGRenderer::programUpdate()
|
|
{
|
|
for (unsigned i=0; i<m_numRenderers; ++i)
|
|
{
|
|
if ( m_renderer[i]->backgroundMode() == KBackgroundSettings::Program &&
|
|
m_renderer[i]->KBackgroundProgram::needUpdate() )
|
|
{
|
|
m_renderer[i]->KBackgroundProgram::update();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
bool KVirtualBGRenderer::needWallpaperChange()
|
|
{
|
|
for (unsigned i=0; i<m_numRenderers; ++i)
|
|
{
|
|
if ( m_renderer[i]->needWallpaperChange() )
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
void KVirtualBGRenderer::changeWallpaper()
|
|
{
|
|
for (unsigned i=0; i<m_numRenderers; ++i)
|
|
{
|
|
m_renderer[i]->changeWallpaper();
|
|
}
|
|
}
|
|
|
|
|
|
int KVirtualBGRenderer::hash()
|
|
{
|
|
TQString fp;
|
|
for (unsigned i=0; i<m_numRenderers; ++i)
|
|
{
|
|
fp += m_renderer[i]->fingerprint();
|
|
}
|
|
//kdDebug() << k_funcinfo << " fp=\""<<fp<<"\" h="<<QHash(fp)<<endl;
|
|
return TQHash(fp);
|
|
}
|
|
|
|
|
|
bool KVirtualBGRenderer::isActive()
|
|
{
|
|
for (unsigned i=0; i<m_numRenderers; ++i)
|
|
{
|
|
if ( m_renderer[i]->isActive() )
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
void KVirtualBGRenderer::setEnabled(bool enable)
|
|
{
|
|
for (unsigned i=0; i<m_numRenderers; ++i)
|
|
m_renderer[i]->setEnabled(enable);
|
|
}
|
|
|
|
|
|
void KVirtualBGRenderer::desktopResized()
|
|
{
|
|
m_size = TDEApplication::desktop()->geometry().size();
|
|
|
|
if (m_pPixmap)
|
|
{
|
|
delete m_pPixmap;
|
|
m_pPixmap = new TQPixmap(m_size);
|
|
m_pPixmap->fill(Qt::black);
|
|
}
|
|
|
|
initRenderers();
|
|
}
|
|
|
|
|
|
void KVirtualBGRenderer::setPreview(const TQSize & size)
|
|
{
|
|
if (m_size == size)
|
|
return;
|
|
|
|
m_size = size;
|
|
|
|
if (m_pPixmap)
|
|
m_pPixmap->resize(m_size);
|
|
|
|
// Scaling factors
|
|
m_scaleX = float(m_size.width()) / float(TQApplication::desktop()->size().width());
|
|
m_scaleY = float(m_size.height()) / float(TQApplication::desktop()->size().height());
|
|
|
|
// Scale renderers appropriately
|
|
for (unsigned i=0; i<m_renderer.size(); ++i)
|
|
{
|
|
TQSize unscaledRendererSize = renderSize(i);
|
|
|
|
m_renderer[i]->setPreview( TQSize(
|
|
int(unscaledRendererSize.width() * m_scaleX),
|
|
int(unscaledRendererSize.height() * m_scaleY) ) );
|
|
}
|
|
}
|
|
|
|
|
|
TQSize KVirtualBGRenderer::renderSize(int screen)
|
|
{
|
|
return m_bDrawBackgroundPerScreen ? TDEApplication::desktop()->screenGeometry(screen).size() : TDEApplication::desktop()->geometry().size();
|
|
}
|
|
|
|
|
|
void KVirtualBGRenderer::initRenderers()
|
|
{
|
|
m_pConfig->setGroup("Background Common");
|
|
m_bDrawBackgroundPerScreen = m_pConfig->readBoolEntry( TQString("DrawBackgroundPerScreen_%1").arg(m_desk), _defDrawBackgroundPerScreen );
|
|
|
|
m_bCommonScreen = m_pConfig->readBoolEntry("CommonScreen", _defCommonScreen);
|
|
|
|
m_numRenderers = m_bDrawBackgroundPerScreen ? TDEApplication::desktop()->numScreens() : 1;
|
|
|
|
m_bFinished.resize(m_numRenderers);
|
|
m_bFinished.fill(false);
|
|
|
|
if (m_numRenderers == m_renderer.size())
|
|
return;
|
|
|
|
for (unsigned i=0; i<m_renderer.size(); ++i)
|
|
delete m_renderer[i];
|
|
|
|
m_renderer.resize(m_numRenderers);
|
|
for (unsigned i=0; i<m_numRenderers; ++i)
|
|
{
|
|
int eScreen = m_bCommonScreen ? 0 : i;
|
|
KBackgroundRenderer * r = new KBackgroundRenderer( m_desk, eScreen, m_bDrawBackgroundPerScreen, m_pConfig );
|
|
m_renderer.insert( i, r );
|
|
r->setSize(renderSize(i));
|
|
connect( r, TQT_SIGNAL(imageDone(int,int)), this, TQT_SLOT(screenDone(int,int)) );
|
|
}
|
|
}
|
|
|
|
|
|
void KVirtualBGRenderer::load(int desk, bool reparseConfig)
|
|
{
|
|
m_desk = desk;
|
|
|
|
m_pConfig->setGroup("Background Common");
|
|
m_bCommonScreen = m_pConfig->readBoolEntry("CommonScreen", _defCommonScreen);
|
|
|
|
initRenderers();
|
|
|
|
for (unsigned i=0; i<m_numRenderers; ++i)
|
|
{
|
|
unsigned eScreen = m_bCommonScreen ? 0 : i;
|
|
m_renderer[i]->load(desk, eScreen, m_bDrawBackgroundPerScreen, reparseConfig);
|
|
}
|
|
}
|
|
|
|
|
|
void KVirtualBGRenderer::screenDone(int _desk, int _screen)
|
|
{
|
|
Q_UNUSED(_desk);
|
|
Q_UNUSED(_screen);
|
|
|
|
const KBackgroundRenderer * sender = dynamic_cast<const KBackgroundRenderer*>(this->sender());
|
|
int screen = m_renderer.find(sender);
|
|
if (screen == -1)
|
|
//??
|
|
return;
|
|
|
|
m_bFinished[screen] = true;
|
|
|
|
|
|
if (m_pPixmap)
|
|
{
|
|
// There's more than one renderer, so we are drawing each output to our own pixmap
|
|
|
|
TQRect overallGeometry;
|
|
for (int i=0; i < TDEApplication::desktop()->numScreens(); ++i) {
|
|
overallGeometry |= TDEApplication::desktop()->screenGeometry(i);
|
|
}
|
|
|
|
TQPoint drawPos = TDEApplication::desktop()->screenGeometry(screen).topLeft() - overallGeometry.topLeft();
|
|
drawPos.setX( int(drawPos.x() * m_scaleX) );
|
|
drawPos.setY( int(drawPos.y() * m_scaleY) );
|
|
|
|
TQPixmap source = m_renderer[screen]->pixmap();
|
|
TQSize renderSize = this->renderSize(screen);
|
|
renderSize.setWidth( int(renderSize.width() * m_scaleX) );
|
|
renderSize.setHeight( int(renderSize.height() * m_scaleY) );
|
|
|
|
TQPainter p(m_pPixmap);
|
|
|
|
if (renderSize == source.size())
|
|
p.drawPixmap( drawPos, source );
|
|
|
|
else
|
|
p.drawTiledPixmap( drawPos.x(), drawPos.y(), renderSize.width(), renderSize.height(), source );
|
|
|
|
p.end();
|
|
}
|
|
|
|
for (unsigned i=0; i<m_bFinished.size(); ++i)
|
|
{
|
|
if (!m_bFinished[i])
|
|
return;
|
|
}
|
|
|
|
emit imageDone(m_desk);
|
|
}
|
|
|
|
|
|
void KVirtualBGRenderer::start()
|
|
{
|
|
if (m_pPixmap)
|
|
{
|
|
delete m_pPixmap;
|
|
m_pPixmap = 0l;
|
|
}
|
|
|
|
if (m_numRenderers > 1)
|
|
{
|
|
m_pPixmap = new TQPixmap(m_size);
|
|
// If are screen sizes do not properly tile the overall virtual screen
|
|
// size, then we want the untiled parts to be black for use in desktop
|
|
// previews, etc
|
|
m_pPixmap->fill(Qt::black);
|
|
}
|
|
|
|
m_bFinished.fill(false);
|
|
for (unsigned i=0; i<m_numRenderers; ++i)
|
|
m_renderer[i]->start();
|
|
}
|
|
|
|
|
|
void KVirtualBGRenderer::stop()
|
|
{
|
|
for (unsigned i=0; i<m_numRenderers; ++i)
|
|
m_renderer[i]->stop();
|
|
}
|
|
|
|
|
|
void KVirtualBGRenderer::cleanup()
|
|
{
|
|
m_bFinished.fill(false);
|
|
|
|
for (unsigned i=0; i<m_numRenderers; ++i)
|
|
m_renderer[i]->cleanup();
|
|
|
|
delete m_pPixmap;
|
|
m_pPixmap = 0l;
|
|
}
|
|
|
|
void KVirtualBGRenderer::saveCacheFile()
|
|
{
|
|
for (unsigned i=0; i<m_numRenderers; ++i)
|
|
m_renderer[i]->saveCacheFile();
|
|
}
|
|
|
|
void KVirtualBGRenderer::enableTiling( bool enable )
|
|
{
|
|
for (unsigned i=0; i<m_numRenderers; ++i)
|
|
m_renderer[i]->enableTiling( enable );
|
|
}
|
|
|
|
//END class KVirtualBGRenderer
|
|
|
|
|
|
#include "bgrender.moc"
|