Attachment #1356 for bug #1499

By default, Bugzilla does not search the list of RESOLVED bugs.
You can force it to do so by putting the upper-case word ALL in front of your search query, e.g.: ALL tdelibs
We recommend searching for bugs this way, as you may discover that your bug has already been resolved and fixed in a later release. View | Details | Raw Unified | Return to bug 1499
Collapse All | Expand All




/* 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,2000 Geert Jansen <jansen@kde.org>
 *
 * You can Freely distribute this program under the GNU General Public
 * License. See the file "COPYING" for the exact licensing terms.
 */

#ifndef __crossfade_h_Included__
#define __crossfade_h_Included__

#include <tqtimer.h>
#include <tqpainter.h>
#include <tqpixmap.h>
#include <X11/X.h>
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <X11/extensions/Xrender.h>
#include <kdebug.h>
#include <unistd.h>



inline TQPixmap crossFade(const TQPixmap &pix1, const TQPixmap &pix2, double r_alpha,
	                bool sync = false){

    TQPixmap pix = TQPixmap(1,1,8); 
    int mw,mh;
    mw = pix1.width();
    mh = pix1.height();

    int alpha = 0xffff * (1-r_alpha);
    
    XRenderColor clr = { 0, 0, 0, alpha }; 
    XRenderPictureAttributes pa;
    pa.repeat = True;
    Picture pic = XRenderCreatePicture(pix.x11Display(), pix.handle(),
	    XRenderFindStandardFormat (pix.x11Display(), PictStandardA8),
	    CPRepeat, &pa);
    XRenderFillRectangle(pix.x11Display(), PictOpSrc, pic,
			 &clr, 0, 0, 1, 1);
    TQPixmap dst(pix1);
    dst.detach();
    XRenderComposite(pix.x11Display(), PictOpOver, pix2.x11RenderHandle(),
	    pic, dst.x11RenderHandle(),0,0, 0,0, 0,0, mw,mh);

    if (sync) {
       XSync(pix.x11Display(), false);	
    }
    XRenderFreePicture(pix.x11Display(), pic);
    return dst;
}

#endif // __crossfade_h_Included__

Lines 28-34 Link Here

(-)./kcontrol/background/CMakeLists.txt.ORI (-1 / +1 lines)
28	##### bgnd (static) #############################	28	##### bgnd (static) #############################
29		29
30	tde_add_library( bgnd STATIC_PIC AUTOMOC	30	tde_add_library( bgnd STATIC_PIC AUTOMOC
31	SOURCES bgrender.cpp bgsettings.cpp	31	SOURCES bgrender.cpp bgsettings.cpp KCrossBGRender.cc
32	LINK ${LIBART_LIBRARIES}	32	LINK ${LIBART_LIBRARIES}
33	)	33	)
34		34

Lines 10-15 Link Here

(-)./kcontrol/background/bgrender.cpp.ORI (-3 / +7 lines)
10		10
11	#include <config.h>	11	#include <config.h>
12		12
		13	#include "KCrossBGRender.h"
		14
13	#include <time.h>	15	#include <time.h>
14	#include <stdlib.h>	16	#include <stdlib.h>
15	#include <utime.h>	17	#include <utime.h>
Lines 1061-1067 Link Here
1061	}	1063	}
1062		1064
1063		1065
1064	KBackgroundRenderer * KVirtualBGRenderer::renderer(unsigned screen)	1066	KCrossBGRender * KVirtualBGRenderer::renderer(unsigned screen)
1065	{	1067	{
1066	return m_renderer[screen];	1068	return m_renderer[screen];
1067	}	1069	}
Lines 1220-1226 Link Here
1220	for (unsigned i=0; i<m_numRenderers; ++i)	1222	for (unsigned i=0; i<m_numRenderers; ++i)
1221	{	1223	{
1222	int eScreen = m_bCommonScreen ? 0 : i;	1224	int eScreen = m_bCommonScreen ? 0 : i;
1223	KBackgroundRenderer * r = new KBackgroundRenderer( m_desk, eScreen, m_bDrawBackgroundPerScreen, m_pConfig );	1225	//KBackgroundRenderer * r = new KBackgroundRenderer( m_desk, eScreen, m_bDrawBackgroundPerScreen, m_pConfig );
		1226	KCrossBGRender *r = new KCrossBGRender(m_desk, eScreen, m_bDrawBackgroundPerScreen, m_pConfig);
1224	m_renderer.insert( i, r );	1227	m_renderer.insert( i, r );
1225	r->setSize(renderSize(i));	1228	r->setSize(renderSize(i));
1226	connect( r, TQT_SIGNAL(imageDone(int,int)), this, TQT_SLOT(screenDone(int,int)) );	1229	connect( r, TQT_SIGNAL(imageDone(int,int)), this, TQT_SLOT(screenDone(int,int)) );
Lines 1250-1256 Link Here
1250	Q_UNUSED(_desk);	1253	Q_UNUSED(_desk);
1251	Q_UNUSED(_screen);	1254	Q_UNUSED(_screen);
1252		1255
1253	const KBackgroundRenderer * sender = dynamic_cast<const KBackgroundRenderer*>(this->sender());	1256	//const KBackgroundRenderer * sender = dynamic_cast<const KBackgroundRenderer*>(this->sender());
		1257	const KCrossBGRender * sender = dynamic_cast<const KCrossBGRender*>(this->sender());
1254	int screen = m_renderer.find(sender);	1258	int screen = m_renderer.find(sender);
1255	if (screen == -1)	1259	if (screen == -1)
1256	//??	1260	//??




/*
 * Copyright (C) 2008 Danilo Cesar Lemes de Paula <danilo@mandriva.com>
 * Copyright (C) 2008 Gustavo Boiko <boiko@mandriva.com>
 * Mandriva Conectiva
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License version 2 as published by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
*/

#ifndef __KCrossBGRender_h_Included__
#define __KCrossBGRender_h_Included__


#include <tqvaluelist.h>
#include <tqpixmap.h>
#include <tqvaluelist.h>
#include <tqdatetime.h>

#include "bgrender.h"

class TQDomElement;

typedef struct crossEvent{
	bool transition;
	TQString pix1;
	TQString pix2;
	TQTime stime; //start time
	TQTime etime; //end time
} KBGCrossEvent;


class KCrossBGRender: public KBackgroundRenderer{
	
TQ_OBJECT

public:
	KCrossBGRender(int desk, int screen, bool drawBackgroundPerScreen, TDEConfig *config=0);
	~KCrossBGRender();

	bool needWallpaperChange();
	void changeWallpaper(bool init=false);
	TQPixmap pixmap();
	bool usingCrossXml(){return useCrossEfect;};


private:
	TQPixmap pix;
	int secs;
	TQString xmlFileName;
	bool useCrossEfect;
	
	int actualPhase;
	 
	void createStartTime(TQDomElement e);
	void createTransition(TQDomElement e);
	void createStatic(TQDomElement e);
	bool setCurrentEvent(bool init = false);
	void initCrossFade(TQString xml);
	void fixEnabled();
	TQPixmap getCurrentPixmap();
	KBGCrossEvent current;
	TQValueList<KBGCrossEvent> timeList;
};

#endif // __KCrossBGRender_h_Included__ 




class KTempFile;
class KShellProcess;
class TDEStandardDirs;
class KCrossBGRender;

/**
 * This class renders a desktop background to a TQImage. The operation is

    KVirtualBGRenderer(int desk, TDEConfig *config=0l);
    ~KVirtualBGRenderer();
    
    KCrossBGRender * renderer(unsigned screen);
    unsigned numRenderers() const { return m_numRenderers; }

    TQPixmap pixmap();

    TQSize m_size;
    
    TQMemArray<bool> m_bFinished;
    //TQPtrVector<KBackgroundRenderer> m_renderer;
    TQPtrVector<KCrossBGRender> m_renderer;
    TQPixmap *m_pPixmap;
};





/*
 * Copyright (C) 2008 Danilo Cesar Lemes de Paula <danilo@mandriva.com>
 * Copyright (C) 2008 Gustavo Boiko <boiko@mandriva.com>
 * Mandriva Conectiva
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License version 2 as published by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#include <tqdom.h>
#include <tqfile.h>

#include <kdebug.h>

#include "KCrossBGRender.h"
//#include "crossfade.h"
#include <tqapplication.h>
#include <kimageeffect.h>


KCrossBGRender::KCrossBGRender(int desk, int screen, bool drawBackgroundPerScreen, TDEConfig *config): KBackgroundRenderer(desk,screen,drawBackgroundPerScreen,config)
{
	useCrossEfect = false;
	if ( wallpaperList()[0].endsWith("xml",false) ) {
		initCrossFade(wallpaperList()[0]);
	}
}
		

void KCrossBGRender::initCrossFade(TQString xmlFile)
{	
	useCrossEfect = true;
	if (xmlFile.isEmpty()){
		useCrossEfect = false;
		return;
	}
	secs = 0;
	timeList.empty();

	// read the XMLfile
	TQDomDocument xmldoc = TQDomDocument(xmlFile);
	TQFile file( xmlFile );
	if ( !file.open( IO_ReadOnly ) ) {
		useCrossEfect = false;
		return;
	}
	if ( !xmldoc.setContent( &file ) ) {
		useCrossEfect = false;
		file.close();
		return;
	}
	file.close();

	TQDomElement docElem = xmldoc.documentElement();
	TQDomNode n = docElem.firstChild();
	while( !n.isNull() ) {
		TQDomElement e = n.toElement(); // try to convert the node to an element.
		if( !e.isNull() ) {
			if (e.tagName() == "starttime") {
				createStartTime(e);	
			} else if (e.tagName() == "transition") {
				createTransition(e);
			} else if (e.tagName() == "static") {
				createStatic(e);
			}
		}
		n = n.nextSibling();
	}

	// Setting "now" state
	setCurrentEvent(true);
	pix = getCurrentPixmap();
	
	useCrossEfect = true;
}


KCrossBGRender::~KCrossBGRender(){
}

TQPixmap KCrossBGRender::pixmap() {
	fixEnabled();	
	if (!useCrossEfect){
		TQPixmap p = KBackgroundRenderer::pixmap();
		kdDebug() << "Inherited " << p.size() << endl;
		if (p.width() == 0 && p.height() == 0){
			p.convertFromImage(image());
		}
		return p;
	}
	
	return pix;
}

bool KCrossBGRender::needWallpaperChange(){
	if (!useCrossEfect) {
		return KBackgroundRenderer::needWallpaperChange();
	}

	bool forceChange = setCurrentEvent();    // If we change the current state
	if (forceChange){			 // do not matter what hapens
		actualPhase = 0;                 // we need to change background
		return true;
	}

	// Return false if it's not a transition
	if (!current.transition) {
		return false;
	}

	double timeLeft, timeTotal;
	TQTime now = TQTime::currentTime();

	timeLeft = now.secsTo(current.etime);
	if (timeLeft < 0) {
		timeLeft += 86400; // before midnight
	}
	timeTotal = current.stime.secsTo(current.etime);
	if (timeTotal < 0) {
		timeTotal += 86400;
	}

	double passed  = timeTotal - timeLeft;
	double timeCell   =  timeTotal/60; //Time cell size

	//kdDebug() << "\ntimeleft:" << timeLeft << " timeTotal:" << timeTotal 
	//          << "\npassed:" << passed << " timeCell:" << timeCell
	//	  << "\nactualPhase: " << actualPhase << endl;	

	int aux = passed/timeCell;	
	if(actualPhase != aux){
		//kdDebug() << "needWallpaperChange() => returned true" << endl;
		actualPhase = passed/timeCell;
		return true;
	}

	//kdDebug() << "needWallpaperChange() => returned false" << endl;
	return false;
}

/* 
 * This method change the enabledEffect flag to TRUE of FALSE, according 
 * with multiWallpaperMode and FileName (it needs to be a XML)
 */
void KCrossBGRender::fixEnabled(){

	
	TQString w = wallpaperList()[0];
	useCrossEfect = false;	
	if(multiWallpaperMode() == Random || multiWallpaperMode() == InOrder){
		
		if ( w != xmlFileName ){
			// New XML File
			xmlFileName = w;
			if (w.endsWith("xml",false)){
				initCrossFade(wallpaperList()[0]);
				//useCrossEfect = true;	
			}else{
				// Not, it's not a xml file
				useCrossEfect = false;
			}
		}else if (w.endsWith("xml",false)){
			//xmlFile doesn't change
			//but it's there
			useCrossEfect = true;
		}else{
			// it's not a XML file
			useCrossEfect = false;
		}
	}
}

void KCrossBGRender::changeWallpaper(bool init){



	fixEnabled();

	if (!useCrossEfect){
		KBackgroundRenderer::changeWallpaper(init);
		return;
	}

	pix = getCurrentPixmap();


}


bool KCrossBGRender::setCurrentEvent(bool init){
	TQTime now = TQTime::currentTime();
	

	//Verify if is need to change
	if (!(init || now <= current.stime || now >= current.etime )) {
		return false;
	}

	TQValueList<KBGCrossEvent>::iterator it;
	for ( it = timeList.begin(); it != timeList.end(); ++it ){

		// Look for time
		if ( ((*it).stime <= now && now <= (*it).etime) ||   //normal situation
		     ((*it).etime <= (*it).stime && (now >= (*it).stime ||
		     				     now <= (*it).etime) ) )	
		{
			current = *it;
			actualPhase = 0;

			//kdDebug() << "Cur: " << current.stime << "< now <" << current.etime << endl;
			return true;
		}
	}
}

TQPixmap KCrossBGRender::getCurrentPixmap()
{
	float alpha;
	TQPixmap ret;
	TQImage tmp;
	TQImage p1;
	if (!tmp.load(current.pix1))
		return TQPixmap();

	// scale the pixmap to fit in the screen
	//p1 = TQPixmap(QApplication::desktop()->screenGeometry().size());
	//TQPainter p(&p1);
	//p.drawPixmap(p1.rect(), tmp);
	//
	p1 = tmp.smoothScale(TQApplication::desktop()->screenGeometry().size());

	if (current.transition){
		TQTime now = TQTime::currentTime();
		double timeLeft,timeTotal;

		TQImage p2;

		if (!tmp.load(current.pix2) )
			return NULL;

		p2 = tmp.smoothScale(TQApplication::desktop()->screenGeometry().size());
		//TQPainter p(&p2);
		//p.drawPixmap(p2.rect(), tmp);

		timeLeft = now.secsTo(current.etime);
		if (timeLeft < 0)
			timeLeft += 86400;
		timeTotal = current.stime.secsTo(current.etime);
		if (timeTotal < 0)
			timeTotal += 86400;
		
		alpha = (timeTotal - timeLeft)/timeTotal;

		//ret = crossFade(p2,p1,alpha);
		tmp = KImageEffect::blend(p2,p1,alpha);
		ret.convertFromImage(tmp);
		return ret;
	}else{
		ret.convertFromImage(p1);
		return ret;
	}	
	

}

void KCrossBGRender::createStartTime(TQDomElement docElem)
{	
	int hour;
	int minutes;

	TQDomNode n = docElem.firstChild();
	while( !n.isNull() ) {
		TQDomElement e = n.toElement();
		if( !e.isNull() ) {
			if (e.tagName() == "hour"){
				hour =  e.text().toInt();
			}else if ( e.tagName() == "minute" ){
				minutes = e.text().toInt();
			}
			
		}
		
		n = n.nextSibling();
	}
	secs = hour*60*60 + minutes*60;
}
void KCrossBGRender::createTransition(TQDomElement docElem)
{
	int duration;
	TQString from;
	TQString to;

	TQDomNode n = docElem.firstChild();
	while( !n.isNull() ) {
		TQDomElement e = n.toElement();
		if( !e.isNull() ) {
			if (e.tagName() == "duration"){
				duration = e.text().toFloat();
			}else if ( e.tagName() == "from" ){
				from = e.text();
			}
			else if ( e.tagName() == "to" ){
				to = e.text();
			}
			
		}
		n = n.nextSibling();
	}
	TQTime startTime(0,0,0);
	startTime = startTime.addSecs(secs);
	TQTime endTime(0,0,0);
	endTime = endTime.addSecs(secs+duration);

	secs += duration;
	
	KBGCrossEvent l = {true, from, to, startTime,endTime};

	timeList.append(l);

}
void KCrossBGRender::createStatic(TQDomElement docElem)
{	
	int duration;
	TQString file;
	
	TQDomNode n = docElem.firstChild();
	while( !n.isNull() ) {
		TQDomElement e = n.toElement();
		if( !e.isNull() ) {
			if (e.tagName() == "duration"){
				duration = e.text().toFloat();
			}else if ( e.tagName() == "file" ){
				file = e.text();
			}
			
		}
		n = n.nextSibling();
	}
	
	TQTime startTime(0,0,0);
	startTime = startTime.addSecs(secs);
	TQTime endTime(0,0,0);
	endTime = endTime.addSecs(secs+duration);
	
	secs += duration;

	KBGCrossEvent l = {false, file, NULL, startTime,endTime};
	timeList.append(l);
}

#include "KCrossBGRender.moc"

Lines 27-32 Link Here

(-)./tdm/kfrontend/krootimage.h.ORI (+1 lines)
27	#include <tqtimer.h>	27	#include <tqtimer.h>
28		28
29	#include <bgrender.h>	29	#include <bgrender.h>
		30	#include <KCrossBGRender.h>
30		31
31		32
32	class MyApplication : public TDEApplication	33	class MyApplication : public TDEApplication

Lines 16-25 Link Here

(-)./kdesktop/bgmanager.cc.ORI (-10 / +94 lines)
16	#include "bgsettings.h"	16	#include "bgsettings.h"
17	#include "kdesktopapp.h"	17	#include "kdesktopapp.h"
18		18
		19	//FIXME
		20	#include "KCrossBGRender.h"
		21	#include "crossfade.h"
		22
19	#include <assert.h>	23	#include <assert.h>
20		24
21	#include <tqtimer.h>	25	#include <tqtimer.h>
22	#include <tqscrollview.h>	26	#include <tqscrollview.h>
		27	#include <tqpainter.h>
		28	#include <tqdesktopwidget.h>
23		29
24	#include <kiconloader.h>	30	#include <kiconloader.h>
25	#include <tdeconfig.h>	31	#include <tdeconfig.h>
Lines 34-39 Link Here
34	#include <X11/X.h>	40	#include <X11/X.h>
35	#include <X11/Xlib.h>	41	#include <X11/Xlib.h>
36	#include <X11/Xatom.h>	42	#include <X11/Xatom.h>
		43	#include <X11/extensions/Xrender.h>
		44	#include <unistd.h>
37		45
38	#ifndef None	46	#ifndef None
39	#define None 0L	47	#define None 0L
Lines 47-53 Link Here
47		55
48	#include "pixmapserver.h"	56	#include "pixmapserver.h"
49		57
50	template class TQPtrVector<KBackgroundRenderer>;	58	//template class TQPtrVector<KBackgroundRenderer>;
		59	template class TQPtrVector<KCrossBGRender>;
51	template class TQPtrVector<KBackgroundCacheEntry>;	60	template class TQPtrVector<KBackgroundCacheEntry>;
52	template class TQMemArray<int>;	61	template class TQMemArray<int>;
53		62
Lines 108-113 Link Here
108	connect(m_pTimer, TQT_SIGNAL(timeout()), TQT_SLOT(slotTimeout()));	117	connect(m_pTimer, TQT_SIGNAL(timeout()), TQT_SLOT(slotTimeout()));
109	m_pTimer->start( 60000 );	118	m_pTimer->start( 60000 );
110		119
		120	/CrossFade's config/
		121	m_crossTimer = new TQTimer(this);
		122	connect(m_crossTimer, TQT_SIGNAL(timeout()), TQT_SLOT(slotCrossFadeTimeout()));
		123	/Ends here/
		124
		125
111	connect(m_pKwinmodule, TQT_SIGNAL(currentDesktopChanged(int)),	126	connect(m_pKwinmodule, TQT_SIGNAL(currentDesktopChanged(int)),
112	TQT_SLOT(slotChangeDesktop(int)));	127	TQT_SLOT(slotChangeDesktop(int)));
113	connect(m_pKwinmodule, TQT_SIGNAL(numberOfDesktopsChanged(int)),	128	connect(m_pKwinmodule, TQT_SIGNAL(numberOfDesktopsChanged(int)),
Lines 577-582 Link Here
577		592
578		593
579	/*	594	/*
		595	* This slot is called when the Timeout is executed
		596	*/
		597	void KBackgroundManager::slotCrossFadeTimeout()
		598	{
		599	KVirtualBGRenderer *r = m_Renderer[fadeDesk];
		600	if (crossInit) {
		601	mBenchmark.start();
		602	}
		603
		604	if (mAlpha <= 0.0 \|\| mBenchmark.elapsed() > 300 ) {
		605	bool do_cleanup = true;
		606	mAlpha = 1;
		607	m_crossTimer->stop();
		608	KPixmap pixm(mNextScreen);
		609	setPixmap(&pixm, r->hash(), fadeDesk);
		610	return;
		611	}
		612	// Reset Timer
		613	mBenchmark.start();
		614
		615	TQPixmap dst = crossFade(*mOldScreen, mNextScreen, mAlpha, crossInit);
		616	KPixmap pixm(dst);
		617	setPixmap(&pixm, r->hash(), fadeDesk);
		618
		619	mAlpha -=0.03;
		620	crossInit = false;
		621	}
		622
		623
		624	/*
580	* This slot is called when a renderer is done.	625	* This slot is called when a renderer is done.
581	*/	626	*/
582	void KBackgroundManager::slotImageDone(int desk)	627	void KBackgroundManager::slotImageDone(int desk)
Lines 592-597 Link Here
592	KPixmap *pm = new KPixmap();	637	KPixmap *pm = new KPixmap();
593	KVirtualBGRenderer *r = m_Renderer[desk];	638	KVirtualBGRenderer *r = m_Renderer[desk];
594	bool do_cleanup = true;	639	bool do_cleanup = true;
		640	fadeDesk = desk;
		641	mAlpha = 1.0;
		642	int width,height;
		643
595		644
596	*pm = r->pixmap();	645	*pm = r->pixmap();
597	// If current: paint it	646	// If current: paint it
Lines 603-609 Link Here
603	//setPixmap(viewport_background, r->hash(), desk);	652	//setPixmap(viewport_background, r->hash(), desk);
604	//delete viewport_background;	653	//delete viewport_background;
605		654
606	setPixmap(pm, r->hash(), desk);	655	//START
		656	if (m_Renderer[effectiveDesktop()]->renderer(0)->crossFadeBg() && !m_Renderer[effectiveDesktop()]->renderer(0)->usingCrossXml()){
		657	int mode = m_Renderer[effectiveDesktop()]->renderer(0)->wallpaperMode();
		658	width = TQApplication::desktop()->screenGeometry().width(); //m_pDesktop->width();
		659	height = TQApplication::desktop()->screenGeometry().height();// m_pDesktop->height();
		660
		661	if (mode == KBackgroundSettings::NoWallpaper \|\| mode == KBackgroundSettings::Tiled \|\| mode == KBackgroundSettings::CenterTiled ){
		662	mNextScreen = TQPixmap(width,height);
		663	TQPainter p (&mNextScreen);
		664	p.drawTiledPixmap(0,0,width,height,*pm);
		665	} else {
		666	mNextScreen = TQPixmap(*pm);
		667	}
		668
		669	if (m_pDesktop){
		670	mOldScreen = const_cast<TQPixmap *>( m_pDesktop->backgroundPixmap() );
		671	}else{
		672	mOldScreen = const_cast<TQPixmap *>(
		673	TQApplication::desktop()->screen()->backgroundPixmap() );
		674	}
		675
		676	//TODO Find a way to discover if CrossFade effect needs to run
		677	if (mOldScreen){
		678	crossInit = true;
		679	m_crossTimer->start(70);
		680	} else{
		681	setPixmap(pm, r->hash(), desk);
		682	}
		683	}else{
		684	setPixmap(pm, r->hash(), desk);
		685	}
		686	//ENDS HERE */
		687
		688	//setPixmap(pm, r->hash(), desk);
		689
607	if (!m_bBgInitDone)	690	if (!m_bBgInitDone)
608	{	691	{
609	m_bBgInitDone = true;	692	m_bBgInitDone = true;
Lines 801-807 Link Here
801	TQString KBackgroundManager::currentWallpaper(int desk)	884	TQString KBackgroundManager::currentWallpaper(int desk)
802	{	885	{
803	//TODO Is the behaviour of this function appropriate for multiple screens?	886	//TODO Is the behaviour of this function appropriate for multiple screens?
804	KBackgroundRenderer *r = m_Renderer[validateDesk(desk)]->renderer(0);	887	//KBackgroundRenderer *r = m_Renderer[validateDesk(desk)]->renderer(0);
		888	KCrossBGRender *r = m_Renderer[validateDesk(desk)]->renderer(0);
805		889
806	return r->currentWallpaper();	890	return r->currentWallpaper();
807	}	891	}
Lines 818-824 Link Here
818	// DCOP exported	902	// DCOP exported
819	void KBackgroundManager::setExport(int _export)	903	void KBackgroundManager::setExport(int _export)
820	{	904	{
821	kdDebug() << "KBackgroundManager enabling exports.\n";	905	// kdDebug() << "KBackgroundManager enabling exports.\n";
822	applyExport(_export);	906	applyExport(_export);
823	slotChangeDesktop(0);	907	slotChangeDesktop(0);
824	}	908	}
Lines 843-849 Link Here
843	//TODO Is the behaviour of this function appropriate for multiple screens?	927	//TODO Is the behaviour of this function appropriate for multiple screens?
844	for (unsigned i=0; i < m_Renderer[effectiveDesktop()]->numRenderers(); ++i)	928	for (unsigned i=0; i < m_Renderer[effectiveDesktop()]->numRenderers(); ++i)
845	{	929	{
846	KBackgroundRenderer *r = m_Renderer[effectiveDesktop()]->renderer(i);	930	KCrossBGRender *r = m_Renderer[effectiveDesktop()]->renderer(i);
847	r->stop();	931	r->stop();
848	r->setWallpaperMode(mode);	932	r->setWallpaperMode(mode);
849	r->setMultiWallpaperMode(KBackgroundSettings::NoMulti);	933	r->setMultiWallpaperMode(KBackgroundSettings::NoMulti);
Lines 856-862 Link Here
856	void KBackgroundManager::setWallpaper(TQString wallpaper)	940	void KBackgroundManager::setWallpaper(TQString wallpaper)
857	{	941	{
858	//TODO Is the behaviour of this function appropriate for multiple screens?	942	//TODO Is the behaviour of this function appropriate for multiple screens?
859	KBackgroundRenderer *r = m_Renderer[effectiveDesktop()]->renderer(0);	943	KCrossBGRender *r = m_Renderer[effectiveDesktop()]->renderer(0);
860	int mode = r->wallpaperMode();	944	int mode = r->wallpaperMode();
861	if (mode == KBackgroundSettings::NoWallpaper)	945	if (mode == KBackgroundSettings::NoWallpaper)
862	mode = KBackgroundSettings::Tiled;	946	mode = KBackgroundSettings::Tiled;
Lines 869-875 Link Here
869	TQStringList KBackgroundManager::wallpaperFiles(int desk)	953	TQStringList KBackgroundManager::wallpaperFiles(int desk)
870	{	954	{
871	//TODO Is the behaviour of this function appropriate for multiple screens?	955	//TODO Is the behaviour of this function appropriate for multiple screens?
872	KBackgroundRenderer *r = m_Renderer[validateDesk(desk)]->renderer(0);	956	KCrossBGRender *r = m_Renderer[validateDesk(desk)]->renderer(0);
873		957
874	return r->wallpaperFiles();	958	return r->wallpaperFiles();
875	}	959	}
Lines 880-886 Link Here
880	TQStringList KBackgroundManager::wallpaperList(int desk)	964	TQStringList KBackgroundManager::wallpaperList(int desk)
881	{	965	{
882	//TODO Is the behaviour of this function appropriate for multiple screens?	966	//TODO Is the behaviour of this function appropriate for multiple screens?
883	KBackgroundRenderer *r = m_Renderer[validateDesk(desk)]->renderer(0);;	967	KCrossBGRender *r = m_Renderer[validateDesk(desk)]->renderer(0);;
884		968
885	return r->wallpaperList();	969	return r->wallpaperList();
886	}	970	}
Lines 907-913 Link Here
907	//TODO Is the behaviour of this function appropriate for multiple screens?	991	//TODO Is the behaviour of this function appropriate for multiple screens?
908	for (unsigned i=0; i < m_Renderer[sdesk]->numRenderers(); ++i)	992	for (unsigned i=0; i < m_Renderer[sdesk]->numRenderers(); ++i)
909	{	993	{
910	KBackgroundRenderer *r = m_Renderer[sdesk]->renderer(i);	994	KCrossBGRender *r = m_Renderer[sdesk]->renderer(i);
911		995
912	setCommon(false); // Force each desktop to have it's own wallpaper	996	setCommon(false); // Force each desktop to have it's own wallpaper
913		997
Lines 974-980 Link Here
974	//TODO Is the behaviour of this function appropriate for multiple screens?	1058	//TODO Is the behaviour of this function appropriate for multiple screens?
975	for (unsigned i=0; i < m_Renderer[effectiveDesktop()]->numRenderers(); ++i)	1059	for (unsigned i=0; i < m_Renderer[effectiveDesktop()]->numRenderers(); ++i)
976	{	1060	{
977	KBackgroundRenderer *r = m_Renderer[effectiveDesktop()]->renderer(i);	1061	KCrossBGRender *r = m_Renderer[effectiveDesktop()]->renderer(i);
978	r->stop();	1062	r->stop();
979		1063
980	if (isColorA)	1064	if (isColorA)




#include <tqstring.h>
#include <tqptrvector.h>

#include <tqdatetime.h>
#include <KBackgroundIface.h>

#if defined(Q_WS_X11) && defined(HAVE_XRENDER) && TQT_VERSION >= 0x030300

    void desktopResized();
    void clearRoot();
    void saveImages();
    void slotCrossFadeTimeout();
    void slotCmBackgroundChanged(bool);

private:

    KPixmapServer *m_pPixmapServer;
    
    unsigned long m_xrootpmap;

    /*CrossFade vars*/
    TQTimer * m_crossTimer;
    double mAlpha;
    TQPixmap  mNextScreen;
    TQPixmap  * mOldScreen;
    int fadeDesk;
    TQTime mBenchmark;
    bool crossInit;
};

#endif // __BGManager_h_Included__




&lt;/ul&gt;&lt;/qt&gt;</string>
                    </property>
                </widget>
                <widget class="TQCheckBox" row="8" column="1">
                    <property name="name">
                        <cstring>m_cbCrossFadeBg</cstring>
                    </property>
                    <property name="text">
                        <string>Cross-fading background</string>
                    </property>
                    <property name="whatsThis" stdset="0">
                        <string>Enables a smooth fading effect when changing background image.</string>
                    </property>
                </widget>
                <widget class="TQComboBox" row="5" column="1">
                    <property name="name">
                        <cstring>m_comboBlend</cstring>

Lines 34-38 Link Here

(-)trinity-tdebase-3.5.13.2~pre102+43d29f86/kcontrol/background/bgdefaults.h.ORI (+1 lines)
34	#define _defBlendMode KBackgroundSettings::NoBlending	34	#define _defBlendMode KBackgroundSettings::NoBlending
35	#define _defBlendBalance 100	35	#define _defBlendBalance 100
36	#define _defReverseBlending false	36	#define _defReverseBlending false
		37	#define _defCrossFadeBg false
37		38
38	#endif // __BGDefaults_h_Included__	39	#endif // __BGDefaults_h_Included__

Lines 198-203 Link Here

(-)trinity-tdebase-3.5.13.2~pre102+43d29f86/kcontrol/background/bgsettings.h.ORI (+4 lines)
198	void setReverseBlending(bool value);	198	void setReverseBlending(bool value);
199	bool reverseBlending() const { return m_ReverseBlending; }	199	bool reverseBlending() const { return m_ReverseBlending; }
200		200
		201	void setCrossFadeBg(bool value);
		202	bool crossFadeBg() const { return m_CrossFadeBg; }
		203
201	void setBlendBalance(int value);	204	void setBlendBalance(int value);
202	int blendBalance() const { return m_BlendBalance; }	205	int blendBalance() const { return m_BlendBalance; }
203		206
Lines 273-278 Link Here
273	int m_BlendMode, defBlendMode;	276	int m_BlendMode, defBlendMode;
274	int m_BlendBalance, defBlendBalance;	277	int m_BlendBalance, defBlendBalance;
275	bool m_ReverseBlending, defReverseBlending;	278	bool m_ReverseBlending, defReverseBlending;
		279	bool m_CrossFadeBg, defCrossFadeBg;
276	int m_MinOptimizationDepth;	280	int m_MinOptimizationDepth;
277	bool m_bShm;	281	bool m_bShm;
278	bool m_bDrawBackgroundPerScreen;	282	bool m_bDrawBackgroundPerScreen;




    defBlendMode = _defBlendMode;
    defBlendBalance = _defBlendBalance;
    defReverseBlending = _defReverseBlending;
    defCrossFadeBg = _defCrossFadeBg;

    m_MinOptimizationDepth = _defMinOptimizationDepth;
    m_bShm = _defShm;

    m_BlendMode = settings->m_BlendMode;
    m_BlendBalance = settings->m_BlendBalance;
    m_ReverseBlending = settings->m_ReverseBlending;
    m_CrossFadeBg = settings->m_CrossFadeBg;
    m_MinOptimizationDepth = settings->m_MinOptimizationDepth;
    m_bShm = settings->m_bShm;
    m_MultiMode = settings->m_MultiMode;

}


void KBackgroundSettings::setCrossFadeBg(bool value)
{
    if (m_CrossFadeBg == value)
	return;
    dirty = hashdirty = true;
    m_CrossFadeBg = value;
}


void KBackgroundSettings::setWallpaper(TQString wallpaper)
{
    dirty = hashdirty = true;


    m_ReverseBlending = m_pConfig->readBoolEntry( "ReverseBlending", defReverseBlending);

    m_CrossFadeBg = m_pConfig->readBoolEntry( "CrossFadeBg", defCrossFadeBg);

    // Multiple wallpaper config
    m_WallpaperList = m_pConfig->readPathListEntry("WallpaperList");


    m_pConfig->writeEntry("BlendMode", m_BlMRevMap[m_BlendMode]);
    m_pConfig->writeEntry("BlendBalance", m_BlendBalance);
    m_pConfig->writeEntry("ReverseBlending", m_ReverseBlending);
    m_pConfig->writeEntry("CrossFadeBg", m_CrossFadeBg);
    m_pConfig->writeEntry("MinOptimizationDepth", m_MinOptimizationDepth);
    m_pConfig->writeEntry("UseSHM", m_bShm);


Lines 80-85 Link Here

(-)trinity-tdebase-3.5.13.2~pre102+43d29f86/kcontrol/background/bgdialog.h.ORI (+1 lines)
80	void slotBlendReverse(bool b);	80	void slotBlendReverse(bool b);
81	void desktopResized();	81	void desktopResized();
82	void setBlendingEnabled(bool);	82	void setBlendingEnabled(bool);
		83	void slotCrossFadeBg(bool);
83		84
84	protected:	85	protected:
85	void getEScreen();	86	void getEScreen();

Lines 174-179 Link Here

(-)trinity-tdebase-3.5.13.2~pre102+43d29f86/kcontrol/background/bgdialog.cpp.ORI (+18 lines)
174	connect(m_cbBlendReverse, TQT_SIGNAL(toggled(bool)),	174	connect(m_cbBlendReverse, TQT_SIGNAL(toggled(bool)),
175	TQT_SLOT(slotBlendReverse(bool)));	175	TQT_SLOT(slotBlendReverse(bool)));
176		176
		177	// Crossfading background
		178	connect(m_cbCrossFadeBg, TQT_SIGNAL(toggled(bool)),
		179	TQT_SLOT(slotCrossFadeBg(bool)));
		180
177	// advanced options	181	// advanced options
178	connect(m_buttonAdvanced, TQT_SIGNAL(clicked()),	182	connect(m_buttonAdvanced, TQT_SIGNAL(clicked()),
179	TQT_SLOT(slotAdvanced()));	183	TQT_SLOT(slotAdvanced()));
Lines 304-309 Link Here
304	m_cbBlendReverse->setEnabled( false );	308	m_cbBlendReverse->setEnabled( false );
305	m_buttonAdvanced->setEnabled( false );	309	m_buttonAdvanced->setEnabled( false );
306	m_buttonGetNew->setEnabled( false );	310	m_buttonGetNew->setEnabled( false );
		311	m_cbCrossFadeBg->setEnabled( false );
307	}	312	}
308		313
309	void BGDialog::load( bool useDefaults )	314	void BGDialog::load( bool useDefaults )
Lines 781-786 Link Here
781	m_cbBlendReverse->setChecked(r->reverseBlending());	786	m_cbBlendReverse->setChecked(r->reverseBlending());
782	m_sliderBlend->setValue( r->blendBalance() / 10 );	787	m_sliderBlend->setValue( r->blendBalance() / 10 );
783		788
		789	m_cbCrossFadeBg->setChecked(r->crossFadeBg());
		790
784	m_comboBlend->blockSignals(false);	791	m_comboBlend->blockSignals(false);
785	m_sliderBlend->blockSignals(false);	792	m_sliderBlend->blockSignals(false);
786		793
Lines 1295-1300 Link Here
1295	eRenderer()->start(true);	1302	eRenderer()->start(true);
1296	}	1303	}
1297		1304
		1305	void BGDialog::slotCrossFadeBg(bool b)
		1306	{
		1307	if (b == eRenderer()->crossFadeBg())
		1308	return;
		1309	emit changed(true);
		1310
		1311	eRenderer()->stop();
		1312	eRenderer()->setCrossFadeBg(b);
		1313	eRenderer()->start(true);
		1314	}
		1315
1298	void BGDialog::desktopResized()	1316	void BGDialog::desktopResized()
1299	{	1317	{
1300	for (unsigned i = 0; i < m_renderer.size(); ++i)	1318	for (unsigned i = 0; i < m_renderer.size(); ++i)

Return to bug 1499

Lines 376-381 Link Here

(-)trinity-tdebase-3.5.13.2~pre102+43d29f86/kcontrol/background/bgdialog_ui.ui.ORI (+11 lines)
376	</ul></qt></string>	376	</ul></qt></string>
377	</property>	377	</property>
378	</widget>	378	</widget>
		379	<widget class="TQCheckBox" row="8" column="1">
		380	<property name="name">
		381	<cstring>m_cbCrossFadeBg</cstring>
		382	</property>
		383	<property name="text">
		384	<string>Cross-fading background</string>
		385	</property>
		386	<property name="whatsThis" stdset="0">
		387	<string>Enables a smooth fading effect when changing background image.</string>
		388	</property>
		389	</widget>
379	<widget class="TQComboBox" row="5" column="1">	390	<widget class="TQComboBox" row="5" column="1">
380	<property name="name">	391	<property name="name">
381	<cstring>m_comboBlend</cstring>	392	<cstring>m_comboBlend</cstring>

Line 0 Link Here

(-)kdebase-3.5.9/kcontrol/background/crossfade.h.crossfade-efect (+56 lines)
	1	/* vi: ts=8 sts=4 sw=4
	2	* kate: space-indent on; tab-width 8; indent-width 4; indent-mode cstyle;
	3	*
	4	* This file is part of the KDE project, module kdesktop.
	5	* Copyright (C) 1999,2000 Geert Jansen <jansen@kde.org>
	6	*
	7	* You can Freely distribute this program under the GNU General Public
	8	* License. See the file "COPYING" for the exact licensing terms.
	9	*/
	10
	11	#ifndef __crossfade_h_Included__
	12	#define __crossfade_h_Included__
	13
	14	#include <tqtimer.h>
	15	#include <tqpainter.h>
	16	#include <tqpixmap.h>
	17	#include <X11/X.h>
	18	#include <X11/Xlib.h>
	19	#include <X11/Xatom.h>
	20	#include <X11/extensions/Xrender.h>
	21	#include <kdebug.h>
	22	#include <unistd.h>
	23
	24
	25
	26	inline TQPixmap crossFade(const TQPixmap &pix1, const TQPixmap &pix2, double r_alpha,
	27	bool sync = false){
	28
	29	TQPixmap pix = TQPixmap(1,1,8);
	30	int mw,mh;
	31	mw = pix1.width();
	32	mh = pix1.height();
	33
	34	int alpha = 0xffff * (1-r_alpha);
	35
	36	XRenderColor clr = { 0, 0, 0, alpha };
	37	XRenderPictureAttributes pa;
	38	pa.repeat = True;
	39	Picture pic = XRenderCreatePicture(pix.x11Display(), pix.handle(),
	40	XRenderFindStandardFormat (pix.x11Display(), PictStandardA8),
	41	CPRepeat, &pa);
	42	XRenderFillRectangle(pix.x11Display(), PictOpSrc, pic,
	43	&clr, 0, 0, 1, 1);
	44	TQPixmap dst(pix1);
	45	dst.detach();
	46	XRenderComposite(pix.x11Display(), PictOpOver, pix2.x11RenderHandle(),
	47	pic, dst.x11RenderHandle(),0,0, 0,0, 0,0, mw,mh);
	48
	49	if (sync) {
	50	XSync(pix.x11Display(), false);
	51	}
	52	XRenderFreePicture(pix.x11Display(), pic);
	53	return dst;
	54	}
	55
	56	#endif // __crossfade_h_Included__

Line 0 Link Here

(-)kdebase-3.5.9/kcontrol/background/KCrossBGRender.h.crossfade-efect (+76 lines)
		1	/*
		2	* Copyright (C) 2008 Danilo Cesar Lemes de Paula <danilo@mandriva.com>
		3	* Copyright (C) 2008 Gustavo Boiko <boiko@mandriva.com>
		4	* Mandriva Conectiva
		5	*
		6	* This library is free software; you can redistribute it and/or
		7	* modify it under the terms of the GNU Library General Public
		8	* License version 2 as published by the Free Software Foundation.
		9	*
		10	* This library is distributed in the hope that it will be useful,
		11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		13	* Library General Public License for more details.
		14	*
		15	* You should have received a copy of the GNU Library General Public License
		16	* along with this library; see the file COPYING.LIB. If not, write to
		17	* the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
		18	* Boston, MA 02111-1307, USA.
		19	*/
		20
		21	#ifndef __KCrossBGRender_h_Included__
		22	#define __KCrossBGRender_h_Included__
		23
		24
		25	#include <tqvaluelist.h>
		26	#include <tqpixmap.h>
		27	#include <tqvaluelist.h>
		28	#include <tqdatetime.h>
		29
		30	#include "bgrender.h"
		31
		32	class TQDomElement;
		33
		34	typedef struct crossEvent{
		35	bool transition;
		36	TQString pix1;
		37	TQString pix2;
		38	TQTime stime; //start time
		39	TQTime etime; //end time
		40	} KBGCrossEvent;
		41
		42
		43	class KCrossBGRender: public KBackgroundRenderer{
		44
		45	TQ_OBJECT
		46
		47	public:
		48	KCrossBGRender(int desk, int screen, bool drawBackgroundPerScreen, TDEConfig *config=0);
		49	~KCrossBGRender();
		50
		51	bool needWallpaperChange();
		52	void changeWallpaper(bool init=false);
		53	TQPixmap pixmap();
		54	bool usingCrossXml(){return useCrossEfect;};
		55
		56
		57	private:
		58	TQPixmap pix;
		59	int secs;
		60	TQString xmlFileName;
		61	bool useCrossEfect;
		62
		63	int actualPhase;
		64
65	void createStartTime(TQDomElement e);
66	void createTransition(TQDomElement e);
67	void createStatic(TQDomElement e);
68	bool setCurrentEvent(bool init = false);
69	void initCrossFade(TQString xml);
70	void fixEnabled();
71	TQPixmap getCurrentPixmap();
72	KBGCrossEvent current;
73	TQValueList<KBGCrossEvent> timeList;
74	};
75
76	#endif // __KCrossBGRender_h_Included__

Lines 28-33 Link Here

(-)./kcontrol/background/bgrender.h.ORI (-2 / +4 lines)
28	class KTempFile;	28	class KTempFile;
29	class KShellProcess;	29	class KShellProcess;
30	class TDEStandardDirs;	30	class TDEStandardDirs;
		31	class KCrossBGRender;
31		32
32	/**	33	/**
33	* This class renders a desktop background to a TQImage. The operation is	34	* This class renders a desktop background to a TQImage. The operation is
Lines 127-133 Link Here
127	KVirtualBGRenderer(int desk, TDEConfig *config=0l);	128	KVirtualBGRenderer(int desk, TDEConfig *config=0l);
128	~KVirtualBGRenderer();	129	~KVirtualBGRenderer();
129		130
130	KBackgroundRenderer * renderer(unsigned screen);	131	KCrossBGRender * renderer(unsigned screen);
131	unsigned numRenderers() const { return m_numRenderers; }	132	unsigned numRenderers() const { return m_numRenderers; }
132		133
133	TQPixmap pixmap();	134	TQPixmap pixmap();
Lines 173-179 Link Here
173	TQSize m_size;	174	TQSize m_size;
174		175
175	TQMemArray<bool> m_bFinished;	176	TQMemArray<bool> m_bFinished;
176	TQPtrVector<KBackgroundRenderer> m_renderer;	177	//TQPtrVector<KBackgroundRenderer> m_renderer;
		178	TQPtrVector<KCrossBGRender> m_renderer;
177	TQPixmap *m_pPixmap;	179	TQPixmap *m_pPixmap;
178	};	180	};
179		181

Lines 13-18 Link Here

(-)./kdesktop/bgmanager.h.ORI (+11 lines)
13	#include <tqstring.h>	13	#include <tqstring.h>
14	#include <tqptrvector.h>	14	#include <tqptrvector.h>
15		15
		16	#include <tqdatetime.h>
16	#include <KBackgroundIface.h>	17	#include <KBackgroundIface.h>
17		18
18	#if defined(Q_WS_X11) && defined(HAVE_XRENDER) && TQT_VERSION >= 0x030300	19	#if defined(Q_WS_X11) && defined(HAVE_XRENDER) && TQT_VERSION >= 0x030300
Lines 89-94 Link Here
89	void desktopResized();	90	void desktopResized();
90	void clearRoot();	91	void clearRoot();
91	void saveImages();	92	void saveImages();
		93	void slotCrossFadeTimeout();
92	void slotCmBackgroundChanged(bool);	94	void slotCmBackgroundChanged(bool);
93		95
94	private:	96	private:
Lines 131-136 Link Here
131	KPixmapServer *m_pPixmapServer;	133	KPixmapServer *m_pPixmapServer;
132		134
133	unsigned long m_xrootpmap;	135	unsigned long m_xrootpmap;
		136
		137	/CrossFade vars/
		138	TQTimer * m_crossTimer;
		139	double mAlpha;
		140	TQPixmap mNextScreen;
		141	TQPixmap * mOldScreen;
		142	int fadeDesk;
		143	TQTime mBenchmark;
		144	bool crossInit;
134	};	145	};
135		146
136	#endif // __BGManager_h_Included__	147	#endif // __BGManager_h_Included__

Lines 437-442 Link Here

(-)trinity-tdebase-3.5.13.2~pre102+43d29f86/kcontrol/background/bgsettings.cpp.ORI (+14 lines)
437	defBlendMode = _defBlendMode;	437	defBlendMode = _defBlendMode;
438	defBlendBalance = _defBlendBalance;	438	defBlendBalance = _defBlendBalance;
439	defReverseBlending = _defReverseBlending;	439	defReverseBlending = _defReverseBlending;
		440	defCrossFadeBg = _defCrossFadeBg;
440		441
441	m_MinOptimizationDepth = _defMinOptimizationDepth;	442	m_MinOptimizationDepth = _defMinOptimizationDepth;
442	m_bShm = _defShm;	443	m_bShm = _defShm;
Lines 537-542 Link Here
537	m_BlendMode = settings->m_BlendMode;	538	m_BlendMode = settings->m_BlendMode;
538	m_BlendBalance = settings->m_BlendBalance;	539	m_BlendBalance = settings->m_BlendBalance;
539	m_ReverseBlending = settings->m_ReverseBlending;	540	m_ReverseBlending = settings->m_ReverseBlending;
		541	m_CrossFadeBg = settings->m_CrossFadeBg;
540	m_MinOptimizationDepth = settings->m_MinOptimizationDepth;	542	m_MinOptimizationDepth = settings->m_MinOptimizationDepth;
541	m_bShm = settings->m_bShm;	543	m_bShm = settings->m_bShm;
542	m_MultiMode = settings->m_MultiMode;	544	m_MultiMode = settings->m_MultiMode;
Lines 633-638 Link Here
633	}	635	}
634		636
635		637
		638	void KBackgroundSettings::setCrossFadeBg(bool value)
		639	{
		640	if (m_CrossFadeBg == value)
		641	return;
		642	dirty = hashdirty = true;
		643	m_CrossFadeBg = value;
		644	}
		645
		646
636	void KBackgroundSettings::setWallpaper(TQString wallpaper)	647	void KBackgroundSettings::setWallpaper(TQString wallpaper)
637	{	648	{
638	dirty = hashdirty = true;	649	dirty = hashdirty = true;
Lines 774-779 Link Here
774		785
775	m_ReverseBlending = m_pConfig->readBoolEntry( "ReverseBlending", defReverseBlending);	786	m_ReverseBlending = m_pConfig->readBoolEntry( "ReverseBlending", defReverseBlending);
776		787
		788	m_CrossFadeBg = m_pConfig->readBoolEntry( "CrossFadeBg", defCrossFadeBg);
		789
777	// Multiple wallpaper config	790	// Multiple wallpaper config
778	m_WallpaperList = m_pConfig->readPathListEntry("WallpaperList");	791	m_WallpaperList = m_pConfig->readPathListEntry("WallpaperList");
779		792
Lines 834-839 Link Here
834	m_pConfig->writeEntry("BlendMode", m_BlMRevMap[m_BlendMode]);	847	m_pConfig->writeEntry("BlendMode", m_BlMRevMap[m_BlendMode]);
835	m_pConfig->writeEntry("BlendBalance", m_BlendBalance);	848	m_pConfig->writeEntry("BlendBalance", m_BlendBalance);
836	m_pConfig->writeEntry("ReverseBlending", m_ReverseBlending);	849	m_pConfig->writeEntry("ReverseBlending", m_ReverseBlending);
		850	m_pConfig->writeEntry("CrossFadeBg", m_CrossFadeBg);
837	m_pConfig->writeEntry("MinOptimizationDepth", m_MinOptimizationDepth);	851	m_pConfig->writeEntry("MinOptimizationDepth", m_MinOptimizationDepth);
838	m_pConfig->writeEntry("UseSHM", m_bShm);	852	m_pConfig->writeEntry("UseSHM", m_bShm);
839		853