summaryrefslogtreecommitdiffstats
path: root/kcontrol/background/bgsettings.cpp
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit4aed2c8219774f5d797760606b8489a92ddc5163 (patch)
tree3f8c130f7d269626bf6a9447407ef6c35954426a /kcontrol/background/bgsettings.cpp
downloadtdebase-4aed2c8219774f5d797760606b8489a92ddc5163.tar.gz
tdebase-4aed2c8219774f5d797760606b8489a92ddc5163.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdebase@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kcontrol/background/bgsettings.cpp')
-rw-r--r--kcontrol/background/bgsettings.cpp1267
1 files changed, 1267 insertions, 0 deletions
diff --git a/kcontrol/background/bgsettings.cpp b/kcontrol/background/bgsettings.cpp
new file mode 100644
index 000000000..9b657393f
--- /dev/null
+++ b/kcontrol/background/bgsettings.cpp
@@ -0,0 +1,1267 @@
+/* vi: ts=8 sts=4 sw=4
+ * kate: space-indent on; 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 <netwm.h>
+#include <time.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+// Clean up after X.h/Xlib.h
+#undef Bool
+#undef Unsorted
+
+#include <qdir.h>
+#include <qpixmap.h>
+
+#include <dcopclient.h>
+#include <kapplication.h>
+#include <kdebug.h>
+#include <kglobalsettings.h>
+#include <ksimpleconfig.h>
+#include <kstandarddirs.h>
+#include <krandomsequence.h>
+#include <konq_defaults.h>
+
+#include "bgdefaults.h"
+#include "bghash.h"
+#include "bgsettings.h"
+
+
+/**** KBackgroundPattern ****/
+
+
+KBackgroundPattern::KBackgroundPattern(QString name)
+{
+ dirty = false;
+ hashdirty = true;
+
+ m_pDirs = KGlobal::dirs();
+ m_pDirs->addResourceType("dtop_pattern", m_pDirs->kde_default("data") +
+ "kdesktop/patterns");
+ m_pConfig = 0L;
+
+ m_Name = name;
+ if (m_Name.isEmpty())
+ return;
+
+ init();
+ readSettings();
+}
+
+
+KBackgroundPattern::~KBackgroundPattern()
+{
+ delete m_pConfig;
+}
+
+void KBackgroundPattern::copyConfig(const KBackgroundPattern *settings)
+{
+ dirty = hashdirty = true;
+ m_Name = settings->m_Name;
+ m_Comment = settings->m_Comment;
+ m_Pattern = settings->m_Pattern;
+ m_File = settings->m_File;
+}
+
+void KBackgroundPattern::load(QString name)
+{
+ m_Name = name;
+ init();
+ readSettings();
+}
+
+
+void KBackgroundPattern::init(bool force_rw)
+{
+ delete m_pConfig;
+
+ m_File = m_pDirs->findResource("dtop_pattern", m_Name + ".desktop");
+ if (force_rw || m_File.isEmpty()) {
+ m_File = m_pDirs->saveLocation("dtop_pattern") + m_Name + ".desktop";
+ m_pConfig = new KSimpleConfig(m_File);
+ } else
+ m_pConfig = new KSimpleConfig(m_File);
+
+ m_pConfig->setGroup("KDE Desktop Pattern");
+
+ QFileInfo fi(m_File);
+ m_bReadOnly = !fi.isWritable();
+}
+
+
+void KBackgroundPattern::setComment(const QString &comment)
+{
+ if (m_Comment == comment)
+ return;
+ dirty = true;
+ m_Comment = comment;
+}
+
+
+void KBackgroundPattern::setPattern(QString pattern)
+{
+ if (m_Pattern == pattern)
+ return;
+ dirty = hashdirty = true;
+ m_Pattern = pattern;
+}
+
+
+void KBackgroundPattern::readSettings()
+{
+ dirty = false;
+ hashdirty = true;
+
+ m_Pattern = m_pConfig->readPathEntry("File");
+ m_Comment = m_pConfig->readEntry("Comment");
+ if (m_Comment.isEmpty())
+ m_Comment = m_File.mid(m_File.findRev('/')+1);
+}
+
+
+void KBackgroundPattern::writeSettings()
+{
+ if (!dirty)
+ return;
+ if (m_bReadOnly)
+ init(true);
+
+ if ( !m_pConfig )
+ return; // better safe than sorry
+
+ m_pConfig->writePathEntry("File", m_Pattern);
+ m_pConfig->writeEntry("Comment", m_Comment);
+ m_pConfig->sync();
+ dirty = false;
+}
+
+
+bool KBackgroundPattern::isAvailable()
+{
+ if (m_Pattern.isEmpty())
+ return false;
+ QString file = m_Pattern;
+ if (file.at(0) != '/')
+ file = m_pDirs->findResource("dtop_pattern", file);
+ QFileInfo fi(file);
+ return (fi.exists());
+}
+
+
+bool KBackgroundPattern::remove()
+{
+ if (m_bReadOnly)
+ return false;
+ return !unlink(QFile::encodeName(m_File));
+}
+
+
+QString KBackgroundPattern::fingerprint()
+{
+ return m_File;
+}
+
+
+int KBackgroundPattern::hash()
+{
+ if (hashdirty) {
+ m_Hash = QHash(fingerprint());
+ hashdirty = false;
+ }
+ return m_Hash;
+}
+
+
+/* static */
+QStringList KBackgroundPattern::list()
+{
+ KStandardDirs *dirs = KGlobal::dirs();
+ dirs->addResourceType("dtop_pattern", dirs->kde_default("data") +
+ "kdesktop/patterns");
+ QStringList lst = dirs->findAllResources("dtop_pattern", "*.desktop",
+ false, true);
+ QStringList::Iterator it;
+ for (it=lst.begin(); it!=lst.end(); ++it) {
+ // Strip path and suffix
+ int pos = (*it).findRev('/');
+ if (pos != -1)
+ (*it) = (*it).mid(pos+1);
+ pos = (*it).findRev('.');
+ if (pos != -1)
+ (*it) = (*it).left(pos);
+ }
+ return lst;
+}
+
+
+/**** KBackgroundProgram ****/
+
+
+KBackgroundProgram::KBackgroundProgram(QString name)
+{
+ dirty = false;
+ hashdirty = true;
+
+ m_pDirs = KGlobal::dirs();
+ m_pDirs->addResourceType("dtop_program", m_pDirs->kde_default("data") +
+ "kdesktop/programs");
+ m_pConfig = 0L;
+
+ // prevent updates when just constructed.
+ m_LastChange = (int) time(0L);
+
+ m_Name = name;
+ if (m_Name.isEmpty())
+ return;
+
+ init();
+ readSettings();
+}
+
+
+KBackgroundProgram::~KBackgroundProgram()
+{
+ delete m_pConfig;
+}
+
+void KBackgroundProgram::copyConfig(const KBackgroundProgram *settings)
+{
+ dirty = hashdirty = true;
+ m_Refresh = settings->m_Refresh;
+ m_LastChange = settings->m_LastChange;
+ m_Name = settings->m_Name;
+ m_Command = settings->m_Command;
+ m_PreviewCommand = settings->m_PreviewCommand;
+ m_Comment = settings->m_Comment;
+ m_Executable = settings->m_Executable;
+ m_File = settings->m_File;
+}
+
+
+void KBackgroundProgram::init(bool force_rw)
+{
+ delete m_pConfig;
+
+ m_File = m_pDirs->findResource("dtop_program", m_Name + ".desktop");
+ if (force_rw || m_File.isEmpty()) {
+ m_File = m_pDirs->saveLocation("dtop_program") + m_Name + ".desktop";
+ m_pConfig = new KSimpleConfig(m_File);
+ m_bReadOnly = false;
+ } else {
+ m_pConfig = new KSimpleConfig(m_File);
+ m_bReadOnly = (m_File != locateLocal("dtop_program", m_Name + ".desktop"));
+ }
+ m_pConfig->setGroup("KDE Desktop Program");
+}
+
+
+void KBackgroundProgram::load(const QString &name)
+{
+ m_Name = name;
+ init();
+ readSettings();
+}
+
+
+void KBackgroundProgram::setComment(const QString &comment)
+{
+ if (m_Comment == comment)
+ return;
+ dirty = true;
+ m_Comment = comment;
+}
+
+
+void KBackgroundProgram::setExecutable(const QString &executable)
+{
+ if (m_Executable == executable)
+ return;
+ dirty = true;
+ m_Executable = executable;
+}
+
+
+void KBackgroundProgram::setCommand(const QString &command)
+{
+ if (m_Command == command)
+ return;
+ dirty = hashdirty = true;
+ m_Command = command;
+}
+
+
+void KBackgroundProgram::setPreviewCommand(const QString &command)
+{
+ if (m_PreviewCommand == command)
+ return;
+ dirty = true;
+ m_PreviewCommand = command;
+}
+
+
+void KBackgroundProgram::setRefresh(int refresh)
+{
+ if (m_Refresh == refresh)
+ return;
+ dirty = hashdirty = true;
+ m_Refresh = refresh;
+}
+
+
+void KBackgroundProgram::readSettings()
+{
+ dirty = false;
+ hashdirty = true;
+
+ m_Comment = m_pConfig->readEntry("Comment");
+ m_Executable = m_pConfig->readPathEntry("Executable");
+ m_Command = m_pConfig->readPathEntry("Command");
+ m_PreviewCommand = m_pConfig->readPathEntry("PreviewCommand", m_Command);
+ m_Refresh = m_pConfig->readNumEntry("Refresh", 300);
+}
+
+
+void KBackgroundProgram::writeSettings()
+{
+ if (!dirty)
+ return;
+ if (m_bReadOnly)
+ init(true);
+
+ if ( !m_pConfig )
+ return; // better safe than sorry
+
+ m_pConfig->writeEntry("Comment", m_Comment);
+ m_pConfig->writePathEntry("Executable", m_Executable);
+ m_pConfig->writePathEntry("Command", m_Command);
+ m_pConfig->writeEntry("PreviewCommand", m_PreviewCommand);
+ m_pConfig->writeEntry("Refresh", m_Refresh);
+ m_pConfig->sync();
+ dirty = false;
+}
+
+
+bool KBackgroundProgram::isAvailable()
+{
+ return !m_pDirs->findExe(m_Executable).isEmpty();
+}
+
+
+bool KBackgroundProgram::remove()
+{
+ if (m_bReadOnly)
+ return false;
+ return !unlink(QFile::encodeName(m_File));
+}
+
+
+bool KBackgroundProgram::needUpdate()
+{
+ return (m_LastChange + 60*m_Refresh <= time(0L));
+}
+
+
+void KBackgroundProgram::update()
+{
+ m_LastChange = (int) time(0L);
+}
+
+
+QString KBackgroundProgram::fingerprint()
+{
+ return QString("co:%1;re:%2").arg(m_Command).arg(m_Refresh);
+}
+
+
+int KBackgroundProgram::hash()
+{
+ if (hashdirty) {
+ m_Hash = QHash(fingerprint());
+ hashdirty = false;
+ }
+ return m_Hash;
+}
+
+
+/* static */
+QStringList KBackgroundProgram::list()
+{
+ KStandardDirs *dirs = KGlobal::dirs();
+ dirs->addResourceType("dtop_program", dirs->kde_default("data") +
+ "kdesktop/programs");
+ QStringList lst = dirs->findAllResources("dtop_program", "*.desktop",
+ false, true);
+ QStringList::Iterator it;
+ for (it=lst.begin(); it!=lst.end(); ++it) {
+ // Strip path and suffix
+ int pos = (*it).findRev('/');
+ if (pos != -1)
+ (*it) = (*it).mid(pos+1);
+ pos = (*it).findRev('.');
+ if (pos != -1)
+ (*it) = (*it).left(pos);
+ }
+ return lst;
+}
+
+
+/**** KBackgroundSettings ****/
+
+
+KBackgroundSettings::KBackgroundSettings(int desk, int screen, bool drawBackgroundPerScreen, KConfig *config)
+ : KBackgroundPattern(),
+ KBackgroundProgram()
+{
+ dirty = false; hashdirty = true;
+ m_bDrawBackgroundPerScreen = drawBackgroundPerScreen;
+ m_Desk = desk;
+ m_Screen = screen;
+ m_bEnabled = true;
+
+ // Default values.
+ defColorA = _defColorA;
+ defColorB = _defColorB;
+ if (QPixmap::defaultDepth() > 8)
+ defBackgroundMode = _defBackgroundMode;
+ else
+ defBackgroundMode = Flat;
+ defWallpaperMode = _defWallpaperMode;
+ defMultiMode = _defMultiMode;
+ defBlendMode = _defBlendMode;
+ defBlendBalance = _defBlendBalance;
+ defReverseBlending = _defReverseBlending;
+
+ m_MinOptimizationDepth = _defMinOptimizationDepth;
+ m_bShm = _defShm;
+
+ // Background modes
+ #define ADD_STRING(ID) m_BMMap[#ID] = ID; m_BMRevMap[ID] = (char *) #ID;
+ ADD_STRING(Flat)
+ ADD_STRING(Pattern)
+ ADD_STRING(Program)
+ ADD_STRING(HorizontalGradient)
+ ADD_STRING(VerticalGradient)
+ ADD_STRING(PyramidGradient)
+ ADD_STRING(PipeCrossGradient)
+ ADD_STRING(EllipticGradient)
+ #undef ADD_STRING
+
+ // Blend modes
+ #define ADD_STRING(ID) m_BlMMap[#ID] = ID; m_BlMRevMap[ID] = (char *) #ID;
+ ADD_STRING(NoBlending)
+ ADD_STRING(FlatBlending)
+ ADD_STRING(HorizontalBlending)
+ ADD_STRING(VerticalBlending)
+ ADD_STRING(PyramidBlending)
+ ADD_STRING(PipeCrossBlending)
+ ADD_STRING(EllipticBlending)
+ ADD_STRING(IntensityBlending)
+ ADD_STRING(SaturateBlending)
+ ADD_STRING(ContrastBlending)
+ ADD_STRING(HueShiftBlending)
+ #undef ADD_STRING
+
+ // Wallpaper modes
+ #define ADD_STRING(ID) m_WMMap[#ID] = ID; m_WMRevMap[ID] = (char *) #ID;
+ ADD_STRING(NoWallpaper)
+ ADD_STRING(Centred)
+ ADD_STRING(Tiled)
+ ADD_STRING(CenterTiled)
+ ADD_STRING(CentredMaxpect)
+ ADD_STRING(TiledMaxpect)
+ ADD_STRING(Scaled)
+ ADD_STRING(CentredAutoFit)
+ ADD_STRING(ScaleAndCrop)
+ #undef ADD_STRING
+
+ // Multiple wallpaper modes
+ #define ADD_STRING(ID) m_MMMap[#ID] = ID; m_MMRevMap[ID] = (char *) #ID;
+ ADD_STRING(NoMulti)
+ ADD_STRING(InOrder)
+ ADD_STRING(Random)
+ ADD_STRING(NoMultiRandom)
+ #undef ADD_STRING
+
+ m_pDirs = KGlobal::dirs();
+
+ if (!config) {
+ int screen_number = 0;
+ if (qt_xdisplay())
+ screen_number = DefaultScreen(qt_xdisplay());
+ QCString configname;
+ if (screen_number == 0)
+ configname = "kdesktoprc";
+ else
+ configname.sprintf("kdesktop-screen-%drc", screen_number);
+
+ m_pConfig = new KConfig(configname, false, false);
+ m_bDeleteConfig = true;
+ } else {
+ m_pConfig = config;
+ m_bDeleteConfig = false;
+ }
+
+ if (m_Desk == -1)
+ return;
+
+ readSettings();
+}
+
+
+KBackgroundSettings::~KBackgroundSettings()
+{
+ if (m_bDeleteConfig)
+ delete m_pConfig;
+}
+
+void KBackgroundSettings::copyConfig(const KBackgroundSettings *settings)
+{
+ dirty = true;
+ hashdirty = true;
+
+ m_ColorA = settings->m_ColorA;
+ m_ColorB = settings->m_ColorB;
+ m_Wallpaper = settings->m_Wallpaper;
+ m_WallpaperList = settings->m_WallpaperList;
+ m_WallpaperFiles = settings->m_WallpaperFiles;
+
+ m_BackgroundMode = settings->m_BackgroundMode;
+ m_WallpaperMode = settings->m_WallpaperMode;
+ m_BlendMode = settings->m_BlendMode;
+ m_BlendBalance = settings->m_BlendBalance;
+ m_ReverseBlending = settings->m_ReverseBlending;
+ m_MinOptimizationDepth = settings->m_MinOptimizationDepth;
+ m_bShm = settings->m_bShm;
+ m_MultiMode = settings->m_MultiMode;
+ m_Interval = settings->m_Interval;
+ m_CurrentWallpaper = settings->m_CurrentWallpaper;
+ m_CurrentWallpaperName = settings->m_CurrentWallpaperName;
+
+ KBackgroundPattern::copyConfig(settings);
+ KBackgroundProgram::copyConfig(settings);
+}
+
+
+void KBackgroundSettings::load(int desk, int screen, bool drawBackgroundPerScreen, bool reparseConfig)
+{
+ m_Desk = desk;
+ m_Screen = screen;
+ m_bDrawBackgroundPerScreen = drawBackgroundPerScreen;
+ readSettings(reparseConfig);
+}
+
+
+void KBackgroundSettings::setColorA(const QColor& color)
+{
+ if (m_ColorA == color)
+ return;
+ dirty = hashdirty = true;
+ m_ColorA = color;
+}
+
+
+void KBackgroundSettings::setColorB(const QColor& color)
+{
+ if (m_ColorB == color)
+ return;
+ dirty = hashdirty = true;
+ m_ColorB = color;
+}
+
+
+void KBackgroundSettings::setPatternName(QString name)
+{
+ int ohash = KBackgroundPattern::hash();
+ KBackgroundPattern::load(name);
+ if (ohash == KBackgroundPattern::hash())
+ return;
+
+ dirty = hashdirty = true;
+ return;
+}
+
+
+void KBackgroundSettings::setProgram(QString name)
+{
+ int ohash = KBackgroundProgram::hash();
+ KBackgroundProgram::load(name);
+ if (ohash == KBackgroundProgram::hash())
+ return;
+
+ dirty = hashdirty = true;
+ return;
+}
+
+
+void KBackgroundSettings::setBackgroundMode(int mode)
+{
+ if (m_BackgroundMode == mode)
+ return;
+ dirty = hashdirty = true;
+ m_BackgroundMode = mode;
+}
+
+void KBackgroundSettings::setBlendMode(int mode)
+{
+ if (m_BlendMode == mode)
+ return;
+ dirty = hashdirty = true;
+ m_BlendMode = mode;
+}
+
+void KBackgroundSettings::setBlendBalance(int value)
+{
+ if (m_BlendBalance == value)
+ return;
+ dirty = hashdirty = true;
+ m_BlendBalance = value;
+}
+
+void KBackgroundSettings::setReverseBlending(bool value)
+{
+ if (m_ReverseBlending == value)
+ return;
+ dirty = hashdirty = true;
+ m_ReverseBlending = value;
+}
+
+
+void KBackgroundSettings::setWallpaper(QString wallpaper)
+{
+ dirty = hashdirty = true;
+ m_Wallpaper = wallpaper;
+}
+
+
+void KBackgroundSettings::setWallpaperMode(int mode)
+{
+ if (m_WallpaperMode == mode)
+ return;
+ dirty = hashdirty = true;
+ m_WallpaperMode = mode;
+}
+
+
+void KBackgroundSettings::setWallpaperList(QStringList list)
+{
+ KStandardDirs *d = KGlobal::dirs();
+ if (m_WallpaperList == list)
+ return;
+
+ dirty = hashdirty = true;
+ m_WallpaperList.clear();
+ for(QStringList::ConstIterator it = list.begin();
+ it != list.end(); ++it)
+ {
+ QString rpath = d->relativeLocation("wallpaper", *it);
+ m_WallpaperList.append( !rpath.isEmpty() ? rpath : *it );
+ }
+ updateWallpaperFiles();
+ // Try to keep the current wallpaper (-1 to set position to one before it)
+ m_CurrentWallpaper = m_WallpaperFiles.findIndex(m_CurrentWallpaperName) - 1;
+ changeWallpaper(m_CurrentWallpaper < 0);
+}
+
+
+void KBackgroundSettings::setWallpaperChangeInterval(int interval)
+{
+ if (m_Interval == interval)
+ return;
+ dirty = hashdirty = true;
+ m_Interval = interval;
+}
+
+
+void KBackgroundSettings::setMultiWallpaperMode(int mode)
+{
+ if (m_MultiMode == mode)
+ return;
+ dirty = hashdirty = true;
+ m_MultiMode = mode;
+ changeWallpaper(true);
+}
+
+
+void KBackgroundSettings::setMinOptimizationDepth(int mode)
+{
+ if (m_MinOptimizationDepth == mode)
+ return;
+ dirty = hashdirty = true;
+ m_MinOptimizationDepth = mode;
+}
+
+bool KBackgroundSettings::optimize() const
+{
+ switch( m_MinOptimizationDepth )
+ {
+ case AlwaysOpt :
+ return true;
+ case Opt16bpp :
+ return QPixmap::defaultDepth() >= 16;
+ case Opt15bpp :
+ return QPixmap::defaultDepth() >= 15;
+ case NeverOpt :
+ default :
+ return false;
+ }
+}
+
+void KBackgroundSettings::setUseShm(bool use)
+{
+ if (m_bShm == use)
+ return;
+ dirty = hashdirty = true;
+ m_bShm = use;
+}
+
+QString KBackgroundSettings::configGroupName() const
+{
+ QString screenName;
+ if (m_bDrawBackgroundPerScreen)
+ screenName = QString("Screen%1").arg(QString::number(m_Screen));
+ return QString("Desktop%1%2").arg(m_Desk).arg(screenName);
+}
+
+void KBackgroundSettings::readSettings(bool reparse)
+{
+ if (reparse)
+ m_pConfig->reparseConfiguration();
+
+ m_pConfig->setGroup(configGroupName());
+
+ // Background mode (Flat, div. Gradients, Pattern or Program)
+ m_ColorA = m_pConfig->readColorEntry("Color1", &defColorA);
+ m_ColorB = m_pConfig->readColorEntry("Color2", &defColorB);
+
+ QString s = m_pConfig->readPathEntry("Pattern");
+ if (!s.isEmpty())
+ KBackgroundPattern::load(s);
+
+ s = m_pConfig->readPathEntry("Program");
+ if (!s.isEmpty())
+ KBackgroundProgram::load(s);
+
+ m_BackgroundMode = defBackgroundMode;
+ s = m_pConfig->readEntry("BackgroundMode", "invalid");
+
+ if (m_BMMap.contains(s)) {
+ int mode = m_BMMap[s];
+ // consistency check
+ if ( ((mode != Pattern) && (mode != Program)) ||
+ ((mode == Pattern) && !pattern().isEmpty()) ||
+ ((mode == Program) && !command().isEmpty())
+ )
+ m_BackgroundMode = mode;
+ }
+
+ m_BlendMode = defBlendMode;
+ s = m_pConfig->readEntry("BlendMode", "invalid");
+ if (m_BlMMap.contains(s)) {
+ m_BlendMode = m_BlMMap[s];
+ }
+
+ m_BlendBalance = defBlendBalance;
+ int value = m_pConfig->readNumEntry( "BlendBalance", defBlendBalance);
+ if (value > -201 && value < 201)
+ m_BlendBalance = value;
+
+ m_ReverseBlending = m_pConfig->readBoolEntry( "ReverseBlending", defReverseBlending);
+
+ // Multiple wallpaper config
+ m_WallpaperList = m_pConfig->readPathListEntry("WallpaperList");
+
+ m_Interval = m_pConfig->readNumEntry("ChangeInterval", 60);
+ m_LastChange = m_pConfig->readNumEntry("LastChange", 0);
+ m_CurrentWallpaper = m_pConfig->readNumEntry("CurrentWallpaper", 0);
+ m_CurrentWallpaperName = m_pConfig->readEntry("CurrentWallpaperName");
+
+ m_MultiMode = defMultiMode;
+ s = m_pConfig->readEntry("MultiWallpaperMode");
+ if (m_MMMap.contains(s)) {
+ int mode = m_MMMap[s];
+ m_MultiMode = mode;
+ }
+
+ updateWallpaperFiles();
+ if( !m_CurrentWallpaperName.isEmpty())
+ m_CurrentWallpaper = m_WallpaperFiles.findIndex(m_CurrentWallpaperName);
+ if(m_CurrentWallpaper < 0)
+ m_CurrentWallpaper = 0;
+
+ // Wallpaper mode (NoWallpaper, div. tilings)
+ m_WallpaperMode = defWallpaperMode;
+ m_Wallpaper = m_pConfig->readPathEntry("Wallpaper");
+ s = m_pConfig->readEntry("WallpaperMode", "invalid");
+ if (m_WMMap.contains(s)) {
+ int mode = m_WMMap[s];
+ // consistency check.
+ if ((mode == NoWallpaper) || !m_Wallpaper.isEmpty() || (m_MultiMode == InOrder || m_MultiMode == Random))
+ m_WallpaperMode = mode;
+ }
+
+ m_MinOptimizationDepth = m_pConfig->readNumEntry( "MinOptimizationDepth",
+ _defMinOptimizationDepth );
+ m_bShm = m_pConfig->readBoolEntry( "UseSHM", _defShm );
+
+ dirty = reparse; hashdirty = true;
+}
+
+
+void KBackgroundSettings::writeSettings()
+{
+ KBackgroundPattern::writeSettings();
+ KBackgroundProgram::writeSettings();
+
+ if (!dirty)
+ return;
+
+ m_pConfig->setGroup(configGroupName());
+ m_pConfig->writeEntry("Color1", m_ColorA);
+ m_pConfig->writeEntry("Color2", m_ColorB);
+ m_pConfig->writePathEntry("Pattern", KBackgroundPattern::name());
+ m_pConfig->writeEntry("Program", KBackgroundProgram::name());
+ m_pConfig->writeEntry("BackgroundMode", m_BMRevMap[m_BackgroundMode]);
+ m_pConfig->writePathEntry("Wallpaper", m_Wallpaper);
+ m_pConfig->writeEntry("WallpaperMode", m_WMRevMap[m_WallpaperMode]);
+ m_pConfig->writeEntry("MultiWallpaperMode", m_MMRevMap[m_MultiMode]);
+ m_pConfig->writeEntry("BlendMode", m_BlMRevMap[m_BlendMode]);
+ m_pConfig->writeEntry("BlendBalance", m_BlendBalance);
+ m_pConfig->writeEntry("ReverseBlending", m_ReverseBlending);
+ m_pConfig->writeEntry("MinOptimizationDepth", m_MinOptimizationDepth);
+ m_pConfig->writeEntry("UseSHM", m_bShm);
+
+ m_pConfig->writePathEntry("WallpaperList", m_WallpaperList);
+ m_pConfig->writeEntry("ChangeInterval", m_Interval);
+ m_pConfig->writeEntry("LastChange", m_LastChange);
+ m_pConfig->deleteEntry("CurrentWallpaper"); // obsolete, remember name
+ m_pConfig->writeEntry("CurrentWallpaperName", m_CurrentWallpaperName);
+
+ m_pConfig->sync();
+
+ dirty = false;
+}
+
+/*
+ * (re)Build m_WallpaperFiles from m_WallpaperList
+ */
+void KBackgroundSettings::updateWallpaperFiles()
+{
+ QStringList::Iterator it;
+ m_WallpaperFiles.clear();
+ for (it=m_WallpaperList.begin(); it!=m_WallpaperList.end(); ++it) {
+ QString file = locate("wallpaper", *it);
+ if (file.isEmpty())
+ continue;
+ QFileInfo fi(file);
+ if (!fi.exists())
+ continue;
+ if (fi.isFile() && fi.isReadable())
+ m_WallpaperFiles.append(file);
+ if (fi.isDir()) {
+ QDir dir(file);
+ QStringList lst = dir.entryList(QDir::Files | QDir::Readable);
+ QStringList::Iterator it;
+ for (it=lst.begin(); it!=lst.end(); ++it)
+ {
+ file = dir.absFilePath(*it);
+ QFileInfo fi(file);
+ if (fi.isFile() && fi.isReadable())
+ m_WallpaperFiles.append(file);
+ }
+ }
+ }
+
+ if (m_MultiMode == Random)
+ randomizeWallpaperFiles();
+}
+
+// Randomize the m_WallpaperFiles in a non-repeating method.
+void KBackgroundSettings::randomizeWallpaperFiles()
+{
+ if (m_WallpaperFiles.count() < 4)
+ return;
+
+ KRandomSequence rseq;
+ QStringList tmpList = m_WallpaperFiles;
+ QStringList randomList;
+ randomList.append(tmpList.front());
+ tmpList.pop_front();
+ while(tmpList.count())
+ {
+ randomList.insert(randomList.at(
+ rseq.getLong(randomList.count()+1)),
+ 1, tmpList.front());
+
+ tmpList.pop_front();
+ }
+ m_WallpaperFiles = randomList;
+}
+
+QStringList KBackgroundSettings::wallpaperList() const
+{
+ if ( m_WallpaperMode == NoWallpaper )
+ return QStringList();
+ if ( m_MultiMode == NoMulti || m_MultiMode == NoMultiRandom )
+ return QStringList(m_Wallpaper);
+ return m_WallpaperList;
+}
+
+QStringList KBackgroundSettings::wallpaperFiles() const
+{
+ if ( m_WallpaperMode == NoWallpaper )
+ return QStringList();
+ if ( m_MultiMode == NoMulti || m_MultiMode == NoMultiRandom )
+ return QStringList(m_Wallpaper);
+ return m_WallpaperFiles;
+}
+
+/*
+ * Select a new wallpaper from the list.
+ */
+void KBackgroundSettings::changeWallpaper(bool init)
+{
+ if (m_WallpaperFiles.count() == 0) {
+ if( init ) {
+ m_CurrentWallpaper = 0;
+ m_CurrentWallpaperName = QString();
+ }
+ return;
+ }
+
+ switch (m_MultiMode) {
+ case InOrder:
+ m_CurrentWallpaper++;
+ if (init || (m_CurrentWallpaper >= (int) m_WallpaperFiles.count()))
+ m_CurrentWallpaper = 0;
+ break;
+
+ case Random:
+ // Random: m_WallpaperFiles is randomized in a non-repeating
+ // method. Hence we just increment the index.
+ m_CurrentWallpaper++;
+ if (init || (m_CurrentWallpaper >= (int) m_WallpaperFiles.count())) {
+ m_CurrentWallpaper = 0;
+ randomizeWallpaperFiles(); // Get a new random-ordered list.
+ }
+ break;
+ default:
+ break;
+ }
+
+ m_CurrentWallpaperName = m_WallpaperFiles[ m_CurrentWallpaper ];
+ m_LastChange = (int) time(0L);
+ m_pConfig->setGroup(configGroupName());
+ m_pConfig->deleteEntry("CurrentWallpaper"); // obsolete, remember name
+ m_pConfig->writeEntry("CurrentWallpaperName", m_CurrentWallpaperName);
+ m_pConfig->writeEntry("LastChange", m_LastChange);
+ m_pConfig->sync();
+
+ hashdirty = true;
+}
+
+
+QString KBackgroundSettings::currentWallpaper() const
+{
+ if ( m_WallpaperMode == NoWallpaper )
+ return QString::null;
+ if (m_MultiMode == NoMulti || m_MultiMode == NoMultiRandom)
+ return m_Wallpaper;
+
+ if (m_CurrentWallpaper >= 0 && m_CurrentWallpaper < (int) m_WallpaperFiles.count())
+ return m_WallpaperFiles[m_CurrentWallpaper];
+ return QString::null;
+}
+
+bool KBackgroundSettings::discardCurrentWallpaper()
+{
+ if (m_MultiMode == NoMulti || m_MultiMode == NoMultiRandom)
+ {
+ return false;
+ }
+ m_WallpaperFiles.remove(m_WallpaperFiles.at(m_CurrentWallpaper));
+ --m_CurrentWallpaper;
+ changeWallpaper();
+
+ return true;
+}
+
+
+bool KBackgroundSettings::needWallpaperChange()
+{
+ if (m_MultiMode == NoMulti || m_MultiMode == NoMultiRandom)
+ return false;
+
+ return ((m_LastChange + 60*m_Interval) <= time(0L));
+}
+
+
+/*
+ * Create a fingerprint string for this config. Be somewhat (overly) carefull
+ * that only a different final result will give a different fingerprint.
+ */
+
+QString KBackgroundSettings::fingerprint()
+{
+ QString s = QString("bm:%1;en:%2").arg(m_BackgroundMode).arg(m_bEnabled);
+ switch (m_BackgroundMode) {
+ case Flat:
+ s += QString("ca:%1;").arg(m_ColorA.rgb());
+ break;
+ case Program:
+ s += QString("pr:%1;").arg(KBackgroundProgram::hash());
+ break;
+ case Pattern:
+ s += QString("ca:%1;cb:%2;pt:%3;").arg(m_ColorA.rgb())
+ .arg(m_ColorB.rgb()).arg(KBackgroundPattern::hash());
+ break;
+ default:
+ s += QString("ca:%1;cb:%2;").arg(m_ColorA.rgb()).arg(m_ColorB.rgb());
+ break;
+ }
+
+ s += QString("wm:%1;").arg(m_WallpaperMode);
+ if (m_WallpaperMode != NoWallpaper)
+ {
+ Q_UINT32 rh = KGlobal::dirs()->calcResourceHash("wallpaper", currentWallpaper(), false);
+ s += QString("wp:%2:%1;").arg(rh).arg(currentWallpaper());
+
+ }
+ s += QString("blm:%1;").arg(m_BlendMode);
+ if (m_BlendMode != NoBlending) {
+ s += QString("blb:%1;").arg(m_BlendBalance);
+ s += QString("rbl:%1;").arg(int(m_ReverseBlending));
+ }
+ s += QString::number( m_bShm );
+ s += QString::number( m_MinOptimizationDepth );
+
+ return s;
+}
+
+
+int KBackgroundSettings::hash()
+{
+ if (hashdirty) {
+ m_Hash = QHash(fingerprint());
+ hashdirty = false;
+ }
+ return m_Hash;
+}
+
+void KBackgroundSettings::setEnabled(const bool enable)
+{
+ if (m_bEnabled == enable)
+ return;
+
+ m_bEnabled= enable;
+ hashdirty = true;
+}
+
+/**** KGlobalBackgroundSettings ****/
+
+KGlobalBackgroundSettings::KGlobalBackgroundSettings(KConfig *_config)
+{
+ m_pConfig = _config;
+
+ readSettings();
+}
+
+
+QString KGlobalBackgroundSettings::deskName(int desk)
+{
+ return m_Names[desk];
+}
+
+
+/*
+void KGlobalBackgroundSettings::setDeskName(int desk, QString name)
+{
+ if (name == m_Names[desk])
+ return;
+ dirty = true;
+ m_Names[desk] = name;
+}
+*/
+
+
+void KGlobalBackgroundSettings::setCacheSize(int size)
+{
+ if (size == m_CacheSize)
+ return;
+ dirty = true;
+ m_CacheSize = size;
+}
+
+
+void KGlobalBackgroundSettings::setLimitCache(bool limit)
+{
+ if (limit == m_bLimitCache)
+ return;
+ dirty = true;
+ m_bLimitCache = limit;
+}
+
+
+bool KGlobalBackgroundSettings::drawBackgroundPerScreen(int desk) const
+{
+ if ( desk > int(m_bDrawBackgroundPerScreen.size()) )
+ return _defDrawBackgroundPerScreen;
+ return m_bDrawBackgroundPerScreen[desk];
+}
+
+
+void KGlobalBackgroundSettings::setDrawBackgroundPerScreen(int desk, bool perScreen)
+{
+ if ( desk >= int(m_bDrawBackgroundPerScreen.size()) )
+ return;
+
+ if ( m_bDrawBackgroundPerScreen[desk] == perScreen )
+ return;
+
+ dirty = true;
+ m_bDrawBackgroundPerScreen[desk] = perScreen;
+}
+
+
+void KGlobalBackgroundSettings::setCommonScreenBackground(bool common)
+{
+ if (common == m_bCommonScreen)
+ return;
+ dirty = true;
+ m_bCommonScreen = common;
+}
+
+
+void KGlobalBackgroundSettings::setCommonDeskBackground(bool common)
+{
+ if (common == m_bCommonDesk)
+ return;
+ dirty = true;
+ m_bCommonDesk = common;
+}
+
+
+void KGlobalBackgroundSettings::setDockPanel(bool dock)
+{
+ if (dock == m_bDock)
+ return;
+ dirty = true;
+ m_bDock = dock;
+}
+
+
+void KGlobalBackgroundSettings::setExportBackground(bool _export)
+{
+ if (_export == m_bExport)
+ return;
+ dirty = true;
+ m_bExport = _export;
+}
+
+void KGlobalBackgroundSettings::setTextColor(QColor _color)
+{
+ if (_color == m_TextColor)
+ return;
+ dirty = true;
+ m_TextColor = _color;
+}
+
+void KGlobalBackgroundSettings::setTextBackgroundColor(QColor _color)
+{
+ if (_color == m_TextBackgroundColor)
+ return;
+ dirty = true;
+ m_TextBackgroundColor = _color;
+}
+
+void KGlobalBackgroundSettings::setShadowEnabled(bool enabled)
+{
+ if (enabled == m_shadowEnabled)
+ return;
+ dirty = true;
+ m_shadowEnabled = enabled;
+}
+
+void KGlobalBackgroundSettings::setTextLines(int lines)
+{
+ if (lines == m_textLines)
+ return;
+ dirty = true;
+ m_textLines = lines;
+}
+
+void KGlobalBackgroundSettings::setTextWidth(int width)
+{
+ if (width == m_textWidth)
+ return;
+ dirty = true;
+ m_textWidth = width;
+}
+
+void KGlobalBackgroundSettings::readSettings()
+{
+ m_pConfig->setGroup("Background Common");
+ m_bCommonScreen = m_pConfig->readBoolEntry("CommonScreen", _defCommonScreen);
+ m_bCommonDesk = m_pConfig->readBoolEntry("CommonDesktop", _defCommonDesk);
+ m_bDock = m_pConfig->readBoolEntry("Dock", _defDock);
+ m_bExport = m_pConfig->readBoolEntry("Export", _defExport);
+ m_bLimitCache = m_pConfig->readBoolEntry("LimitCache", _defLimitCache);
+ m_CacheSize = m_pConfig->readNumEntry("CacheSize", _defCacheSize);
+
+ m_Names.clear();
+ NETRootInfo info( qt_xdisplay(), NET::DesktopNames | NET::NumberOfDesktops );
+ m_bDrawBackgroundPerScreen.resize(info.numberOfDesktops());
+ for ( int i = 0 ; i < info.numberOfDesktops() ; ++i )
+ m_bDrawBackgroundPerScreen[i] = m_pConfig->readBoolEntry( QString("DrawBackgroundPerScreen_%1").arg(i), _defDrawBackgroundPerScreen );
+
+ m_TextColor = KGlobalSettings::textColor();
+ m_pConfig->setGroup("FMSettings");
+ m_TextColor = m_pConfig->readColorEntry("NormalTextColor", &m_TextColor);
+ m_TextBackgroundColor = m_pConfig->readColorEntry("ItemTextBackground");
+ m_shadowEnabled = m_pConfig->readBoolEntry("ShadowEnabled", true);
+ m_textLines = m_pConfig->readNumEntry("TextHeight", DEFAULT_TEXTHEIGHT);
+ m_textWidth = m_pConfig->readNumEntry("TextWidth", DEFAULT_TEXTWIDTH);
+
+ for ( int i = 0 ; i < info.numberOfDesktops() ; ++i )
+ m_Names.append( QString::fromUtf8(info.desktopName(i+1)) );
+
+ dirty = false;
+}
+
+void KGlobalBackgroundSettings::writeSettings()
+{
+ if (!dirty)
+ return;
+
+ m_pConfig->setGroup("Background Common");
+ m_pConfig->writeEntry("CommonScreen", m_bCommonScreen);
+ m_pConfig->writeEntry("CommonDesktop", m_bCommonDesk);
+ m_pConfig->writeEntry("Dock", m_bDock);
+ m_pConfig->writeEntry("Export", m_bExport);
+ m_pConfig->writeEntry("LimitCache", m_bLimitCache);
+ m_pConfig->writeEntry("CacheSize", m_CacheSize);
+
+ for ( unsigned i = 0 ; i < m_bDrawBackgroundPerScreen.size() ; ++i )
+ m_pConfig->writeEntry(QString("DrawBackgroundPerScreen_%1").arg(i), m_bDrawBackgroundPerScreen[i] );
+
+ m_pConfig->setGroup("FMSettings");
+ m_pConfig->writeEntry("NormalTextColor", m_TextColor);
+ m_pConfig->writeEntry("ItemTextBackground", m_TextBackgroundColor);
+ m_pConfig->writeEntry("ShadowEnabled", m_shadowEnabled);
+ m_pConfig->writeEntry("TextHeight", m_textLines);
+ m_pConfig->writeEntry("TextWidth", m_textWidth);
+
+ m_pConfig->sync();
+ dirty = false;
+
+ // tell kdesktop to get it's butt in gear and pick up the new settings
+ QByteArray data;
+ kapp->dcopClient()->send("kdesktop", "KDesktopIface", "configure()", data);
+}
+