workspace/kcontrol/kdm/background/bgdialog.cpp

   1 /*
   2    kate: space-indent on; indent-width 3; indent-mode cstyle;
   3
   4    This file is part of the KDE libraries
   5
   6    Copyright (c) 2005 David Saxton <david@bluehaze.org>
   7    Copyright (c) 2003 Waldo Bastian <bastian@kde.org>
   8    Copyright (c) 1999 Geert Jansen <g.t.jansen@stud.tue.nl>
   9    Copyright (c) 1996 Martin R. Jones
  10    Copyright (c) 1997 Matthias Hoelzer
  11    Copyright (c) 1997 Mark Donohoe
  12    Copyright (c) 1998 Stephan Kulow
  13    Copyright (c) 1998 Matej Koss
  14
  15    This program is free software; you can redistribute it and/or
  16    modify it under the terms of the GNU General Public License
  17    version 2 as published by the Free Software Foundation.
  18
  19    This library is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22    Library General Public License for more details.
  23
  24    You should have received a copy of the GNU Library General Public License
  25    along with this library; see the file COPYING.LIB.  If not, write to
  26    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  27    Boston, MA 02110-1301, USA.
  28 */
  29
  30 #include <QCheckBox>
  31 #include <QLabel>
  32 #include <QPainter>
  33 #include <QRadioButton>
  34 #include <QSlider>
  35 #include <QTimer>
  36
  37
  38 #include <QApplication>
  39 #include <QPixmap>
  40 #include <QDesktopWidget>
  41
  42 #include <kconfig.h>
  43 #include <kdebug.h>
  44 #include <kfiledialog.h>
  45 #include <kfilemetainfo.h>
  46 #include <kglobal.h>
  47 #include <kiconloader.h>
  48 #include <kimageio.h>
  49 #include <klocale.h>
  50 #include <kstandarddirs.h>
  51 #include <kstringhandler.h>
  52 #include <kurlrequester.h>
  53 #include <kwindowsystem.h>
  54 #include <kdesktopfile.h>
  55 #include <kimagefilepreview.h>
  56 #include <knewstuff2/engine.h>
  57
  58 #include <stdlib.h>
  59
  60 #include "bgmonitor.h"
  61 #include "bgwallpaper.h"
  62 #include "bgadvanced.h"
  63 #include "bgdialog.h"
  64
  65 #define NR_PREDEF_PATTERNS 6
  66
  67 BGDialog::BGDialog(QWidget* parent, const KSharedConfigPtr &_config, bool _kdmMode)
  68   : BGDialog_UI(parent)
  69 {
  70    m_pGlobals = new KGlobalBackgroundSettings(_config);
  71    m_pDirs = KGlobal::dirs();
  72    m_kdmMode = _kdmMode;
  73    m_previewUpdates = true;
  74
  75    m_numDesks = !m_kdmMode ? KWindowSystem::numberOfDesktops() : 1;
  76    m_numScreens = QApplication::desktop()->numScreens();
  77
  78    QString multiHead = getenv("KDE_MULTIHEAD");
  79    if (multiHead.toLower() == "true")
  80    {
  81       m_numScreens = 1;
  82    }
  83
  84    m_desk = !m_kdmMode ? KWindowSystem::currentDesktop() : 1;
  85    m_screen = QApplication::desktop()->screenNumber(this);
  86    if (m_screen >= (int)m_numScreens)
  87       m_screen = m_numScreens-1;
  88
  89    m_eDesk = m_pGlobals->commonDeskBackground() ? 0 : m_desk;
  90    getEScreen();
  91    m_copyAllDesktops = true;
  92    m_copyAllScreens = true;
  93
  94    if (m_kdmMode)
  95    {
  96       m_pDesktopLabel->hide();
  97       m_comboDesktop->hide();
  98    }
  99
 100    if (m_numScreens < 2)
 101    {
 102       m_comboScreen->hide();
 103       m_buttonIdentifyScreens->hide();
 104       m_screen = 0;
 105       m_eScreen = 0;
 106    }
 107
 108    connect(m_buttonIdentifyScreens, SIGNAL(clicked()), SLOT(slotIdentifyScreens()));
 109
 110    // preview monitor
 111    m_pMonitorArrangement = new BGMonitorArrangement(m_screenArrangement);
 112    m_pMonitorArrangement->setObjectName("monitor arrangement");
 113    connect(m_pMonitorArrangement, SIGNAL(imageDropped(const QString &)), SLOT(slotImageDropped(const QString &)));
 114    if( !m_kdmMode)
 115      {
 116        // desktop
 117        connect(m_comboDesktop, SIGNAL(activated(int)),
 118                SLOT(slotSelectDesk(int)));
 119      }
 120    if (m_numScreens > 1)
 121    {
 122        connect(m_comboScreen, SIGNAL(activated(int)),
 123                SLOT(slotSelectScreen(int)));
 124    }
 125
 126    // background image settings
 127    QIcon iconSet = KIcon(QLatin1String("document-open"));
 128    QPixmap pixMap = iconSet.pixmap( QIcon::Small, QIcon::Normal );
 129    m_urlWallpaperButton->setIcon( iconSet );
 130    m_urlWallpaperButton->setFixedSize( pixMap.width()+8, pixMap.height()+8 );
 131    m_urlWallpaperButton->setToolTip( i18n("Open file dialog"));
 132
 133    connect(m_buttonGroupBackground, SIGNAL(clicked(int)),
 134            SLOT(slotWallpaperTypeChanged(int)));
 135    connect(m_urlWallpaperBox, SIGNAL(activated(int)),
 136            SLOT(slotWallpaper(int)));
 137    connect(m_urlWallpaperButton, SIGNAL(clicked()),
 138            SLOT(slotWallpaperSelection()));
 139    connect(m_comboWallpaperPos, SIGNAL(activated(int)),
 140            SLOT(slotWallpaperPos(int)));
 141    connect(m_buttonSetupWallpapers, SIGNAL(clicked()),
 142            SLOT(slotSetupMulti()));
 143
 144    // set up the background colour stuff
 145    connect(m_colorPrimary, SIGNAL(changed(const QColor &)),
 146            SLOT(slotPrimaryColor(const QColor &)));
 147    connect(m_colorSecondary, SIGNAL(changed(const QColor &)),
 148            SLOT(slotSecondaryColor(const QColor &)));
 149    connect(m_comboPattern, SIGNAL(activated(int)),
 150            SLOT(slotPattern(int)));
 151
 152    // blend
 153    connect(m_comboBlend, SIGNAL(activated(int)), SLOT(slotBlendMode(int)));
 154    connect(m_sliderBlend, SIGNAL(valueChanged(int)),
 155            SLOT(slotBlendBalance(int)));
 156    connect(m_cbBlendReverse, SIGNAL(toggled(bool)),
 157            SLOT(slotBlendReverse(bool)));
 158
 159    // advanced options
 160    connect(m_buttonAdvanced, SIGNAL(clicked()),
 161            SLOT(slotAdvanced()));
 162
 163    connect(m_buttonGetNew, SIGNAL(clicked()),
 164            SLOT(slotGetNewStuff()));
 165
 166    // renderers
 167    m_renderer.resize(m_numDesks+1);
 168
 169    if (m_numScreens > 1)
 170    {
 171       for (unsigned i = 0; i < m_numDesks+1; ++i)
 172       {
 173          m_renderer[i].resize(m_numScreens+2);
 174          m_renderer[i].setAutoDelete(true);
 175
 176          int eDesk = i>0 ? i-1 : 0;
 177
 178          // Setup the merged-screen renderer
 179          KBackgroundRenderer * r = new KBackgroundRenderer(eDesk, 0, false, _config, _kdmMode);
 180          m_renderer[i].insert( 0, r );
 181          connect( r, SIGNAL(imageDone(int,int)), SLOT(slotPreviewDone(int,int)) );
 182
 183          // Setup the common-screen renderer
 184          r = new KBackgroundRenderer(eDesk, 0, true, _config, _kdmMode);
 185          m_renderer[i].insert( 1, r );
 186          connect( r, SIGNAL(imageDone(int,int)), SLOT(slotPreviewDone(int,int)) );
 187
 188          // Setup the remaining renderers for each screen
 189          for (unsigned j=0; j < m_numScreens; ++j )
 190          {
 191             r = new KBackgroundRenderer(eDesk, j, true, _config, _kdmMode);
 192             m_renderer[i].insert( j+2, r );
 193             connect( r, SIGNAL(imageDone(int,int)), SLOT(slotPreviewDone(int,int)) );
 194          }
 195       }
 196    }
 197    else
 198    {
 199       for (unsigned i = 0; i < m_numDesks+1; ++i )
 200       {
 201          m_renderer[i].resize(1);
 202          m_renderer[i].setAutoDelete(true);
 203       }
 204
 205       // set up the common desktop renderer
 206       KBackgroundRenderer * r = new KBackgroundRenderer(0, 0, false, _config, _kdmMode);
 207       m_renderer[0].insert(0, r);
 208       connect(r, SIGNAL(imageDone(int,int)), SLOT(slotPreviewDone(int,int)));
 209
 210       // set up all the other desktop renderers
 211       for (unsigned i = 0; i < m_numDesks; ++i)
 212       {
 213          r = new KBackgroundRenderer(i, 0, false, _config, _kdmMode);
 214          m_renderer[i+1].insert(0, r);
 215          connect(r, SIGNAL(imageDone(int,int)), SLOT(slotPreviewDone(int,int)));
 216       }
 217    }
 218
 219    // Random or InOrder
 220    m_slideShowRandom = eRenderer()->multiWallpaperMode();
 221    if (m_slideShowRandom == KBackgroundSettings::NoMultiRandom)
 222       m_slideShowRandom = KBackgroundSettings::Random;
 223    if (m_slideShowRandom == KBackgroundSettings::NoMulti)
 224       m_slideShowRandom = KBackgroundSettings::InOrder;
 225
 226    // Wallpaper Position
 227    m_wallpaperPos = eRenderer()->wallpaperMode();
 228    if (m_wallpaperPos == KBackgroundSettings::NoWallpaper)
 229       m_wallpaperPos = KBackgroundSettings::Centred; // Default
 230
 231    if (KGlobal::dirs()->isRestrictedResource("wallpaper"))
 232    {
 233       m_urlWallpaperButton->hide();
 234       m_buttonSetupWallpapers->hide();
 235       m_radioSlideShow->hide();
 236    }
 237
 238    initUI();
 239    updateUI();
 240
 241    connect( qApp->desktop(), SIGNAL( resized( int )), SLOT( desktopResized())); // RANDR support
 242 }
 243
 244 BGDialog::~BGDialog()
 245 {
 246    delete m_pGlobals;
 247 }
 248
 249 KBackgroundRenderer * BGDialog::eRenderer()
 250 {
 251    return m_renderer[m_eDesk][m_eScreen];
 252 }
 253
 254 void BGDialog::getEScreen()
 255 {
 256    if ( m_pGlobals->drawBackgroundPerScreen( m_eDesk>0 ? m_eDesk-1 : 0 ) )
 257       m_eScreen = m_pGlobals->commonScreenBackground() ? 1 : m_screen+2;
 258    else
 259       m_eScreen = 0;
 260
 261    if ( m_numScreens == 1 )
 262       m_eScreen = 0;
 263    else if ( m_eScreen > int(m_numScreens+1) )
 264       m_eScreen = m_numScreens+1;
 265 }
 266
 267 void BGDialog::makeReadOnly()
 268 {
 269     m_pMonitorArrangement->setEnabled( false );
 270     m_comboScreen->setEnabled( false );
 271     m_comboDesktop->setEnabled( false );
 272     m_colorPrimary->setEnabled( false );
 273     m_colorSecondary->setEnabled( false );
 274     m_comboPattern->setEnabled( false );
 275     m_radioNoPicture->setEnabled( false );
 276     m_radioPicture->setEnabled( false );
 277     m_radioSlideShow->setEnabled( false );
 278     m_urlWallpaperBox->setEnabled( false );
 279     m_urlWallpaperButton->setEnabled( false );
 280     m_comboWallpaperPos->setEnabled( false );
 281     m_buttonSetupWallpapers->setEnabled( false );
 282     m_comboBlend->setEnabled( false );
 283     m_sliderBlend->setEnabled( false );
 284     m_cbBlendReverse->setEnabled( false );
 285     m_buttonAdvanced->setEnabled( false );
 286     m_buttonGetNew->setEnabled( false );
 287 }
 288
 289 void BGDialog::load()
 290 {
 291    m_pGlobals->readSettings();
 292    m_eDesk = m_pGlobals->commonDeskBackground() ? 0 : m_desk;
 293    getEScreen();
 294
 295    for (int desk = 0; desk < m_renderer.size(); ++desk)
 296    {
 297       unsigned eDesk = desk>0 ? desk-1 : 0;
 298       for (unsigned screen = 0; screen < m_renderer[desk].size(); ++screen)
 299       {
 300          unsigned eScreen = screen>1 ? screen-2 : 0;
 301 //          m_renderer[desk][screen]->load( eDesk, eScreen, (screen>0) );
 302          m_renderer[desk][screen]->load( eDesk, eScreen, (screen>0), true );
 303       }
 304    }
 305
 306    m_copyAllDesktops = true;
 307    m_copyAllScreens = true;
 308
 309    // Random or InOrder
 310    m_slideShowRandom = eRenderer()->multiWallpaperMode();
 311    if (m_slideShowRandom == KBackgroundSettings::NoMultiRandom)
 312       m_slideShowRandom = KBackgroundSettings::Random;
 313    if (m_slideShowRandom == KBackgroundSettings::NoMulti)
 314       m_slideShowRandom = KBackgroundSettings::InOrder;
 315
 316    // Wallpaper Position
 317    m_wallpaperPos = eRenderer()->wallpaperMode();
 318    if (m_wallpaperPos == KBackgroundSettings::NoWallpaper)
 319       m_wallpaperPos = KBackgroundSettings::Centred; // Default
 320
 321    updateUI();
 322    emit changed(false);
 323 }
 324
 325 void BGDialog::save()
 326 {
 327    m_pGlobals->writeSettings();
 328
 329    // write out the common desktop or the "Desktop 1" settings
 330    // depending on which are the real settings
 331    // they both share Desktop[0] in the config file
 332    // similar for screen...
 333
 334    for (int desk = 0; desk < m_renderer.size(); ++desk)
 335    {
 336       if (desk == 0 && !m_pGlobals->commonDeskBackground())
 337          continue;
 338
 339       if (desk == 1 && m_pGlobals->commonDeskBackground())
 340          continue;
 341
 342       for (unsigned screen = 0; screen < m_renderer[desk].size(); ++screen)
 343       {
 344          if (screen == 1 && !m_pGlobals->commonScreenBackground())
 345             continue;
 346
 347          if (screen == 2 && m_pGlobals->commonScreenBackground())
 348             continue;
 349
 350          m_renderer[desk][screen]->writeSettings();
 351       }
 352    }
 353
 354    emit changed(false);
 355 }
 356
 357 void BGDialog::defaults()
 358 {
 359    m_pGlobals->setCommonScreenBackground(_defCommonScreen);
 360    m_pGlobals->setCommonDeskBackground(_defCommonDesk);
 361    m_pGlobals->setLimitCache(_defLimitCache);
 362    m_pGlobals->setCacheSize(_defCacheSize);
 363    m_comboWallpaperPos->setCurrentIndex( 0 );
 364
 365    m_eDesk = _defCommonDesk ? 0 : m_desk;
 366    getEScreen();
 367
 368    for ( unsigned i = 0; i < m_numDesks; ++i )
 369       m_pGlobals->setDrawBackgroundPerScreen( i, false );
 370
 371    KBackgroundRenderer *r = eRenderer();
 372
 373    if (r->isActive())
 374       r->stop();
 375
 376    if (QPixmap::defaultDepth() > 8)
 377    {
 378       r->setBackgroundMode(_defBackgroundMode);
 379    }
 380    else
 381    {
 382       r->setBackgroundMode(KBackgroundSettings::Flat);
 383    }
 384
 385    r->setColorA(_defColorA);
 386    r->setColorB(_defColorB);
 387    r->setWallpaperMode(_defWallpaperMode);
 388    r->setMultiWallpaperMode(_defMultiMode);
 389
 390    m_slideShowRandom = _defMultiMode;
 391    if (m_slideShowRandom == KBackgroundSettings::NoMultiRandom)
 392       m_slideShowRandom = KBackgroundSettings::Random;
 393    if (m_slideShowRandom == KBackgroundSettings::NoMulti)
 394       m_slideShowRandom = KBackgroundSettings::InOrder;
 395
 396    r->setBlendMode(_defBlendMode);
 397    r->setBlendBalance(_defBlendBalance);
 398    r->setReverseBlending(_defReverseBlending);
 399
 400    updateUI();
 401
 402    m_copyAllDesktops = true;
 403    m_copyAllScreens = true;
 404    emit changed(true);
 405 }
 406
 407 QString BGDialog::quickHelp() const
 408 {
 409    return i18n("<p><h1>Background</h1> This module allows you to control the"
 410       " appearance of the virtual desktops. KDE offers a variety of options"
 411       " for customization, including the ability to specify different settings"
 412       " for each virtual desktop, or a common background for all of them.</p>"
 413       " <p>The appearance of the desktop results from the combination of its"
 414       " background colors and patterns, and optionally, wallpaper, which is"
 415       " based on the image from a graphic file.</p>"
 416       " <p>The background can be made up of a single color, or a pair of colors"
 417       " which can be blended in a variety of patterns. Wallpaper is also"
 418       " customizable, with options for tiling and stretching images. The"
 419       " wallpaper can be overlaid opaquely, or blended in different ways with"
 420       " the background colors and patterns.</p>"
 421       " <p>KDE allows you to have the wallpaper change automatically at specified"
 422       " intervals of time. You can also replace the background with a program"
 423       " that updates the desktop dynamically. For example, the \"kdeworld\""
 424       " program shows a day/night map of the world which is updated periodically.</p>");
 425 }
 426
 427 void BGDialog::slotIdentifyScreens()
 428 {
 429    // Taken from PositionTab::showIdentify in kdebase/kcontrol/kicker/positiontab_impl.cpp
 430    for(unsigned s = 0; s < m_numScreens; s++)
 431    {
 432       QLabel *screenLabel = new QLabel(0, Qt::WDestructiveClose | Qt::WStyle_Customize | Qt::X11BypassWindowManagerHint);
 433       screenLabel->setObjectName("Screen Identify");
 434
 435       QFont identifyFont(KGlobalSettings::generalFont());
 436       identifyFont.setPixelSize(100);
 437       screenLabel->setFont(identifyFont);
 438
 439       screenLabel->setFrameStyle(QFrame::Panel);
 440       screenLabel->setFrameShadow(QFrame::Plain);
 441
 442       screenLabel->setAlignment(Qt::AlignCenter);
 443       screenLabel->setNum(int(s + 1));
 444         // BUGLET: we should not allow the identification to be entered again
 445         //         until the timer fires.
 446       QTimer::singleShot(1500, screenLabel, SLOT(close()));
 447
 448       QPoint screenCenter(QApplication::desktop()->screenGeometry(s).center());
 449       QRect targetGeometry(QPoint(0,0),screenLabel->sizeHint());
 450       targetGeometry.moveCenter(screenCenter);
 451
 452       screenLabel->setGeometry(targetGeometry);
 453
 454       screenLabel->show();
 455    }
 456 }
 457
 458 void BGDialog::initUI()
 459 {
 460    // Desktop names
 461    for (unsigned i = 0; i < m_numDesks; ++i)
 462       m_comboDesktop->addItem(m_pGlobals->deskName(i));
 463
 464    // Screens
 465    for (unsigned i = 0; i < m_numScreens; ++i)
 466       m_comboScreen->addItem( i18n("Screen %1", i+1) );
 467
 468    // Patterns
 469    m_comboPattern->addItem(i18n("Single Color"));
 470    m_comboPattern->addItem(i18n("Horizontal Gradient"));
 471    m_comboPattern->addItem(i18n("Vertical Gradient"));
 472    m_comboPattern->addItem(i18n("Pyramid Gradient"));
 473    m_comboPattern->addItem(i18n("Pipecross Gradient"));
 474    m_comboPattern->addItem(i18n("Elliptic Gradient"));
 475
 476    m_patterns = KBackgroundPattern::list();
 477    m_patterns.sort(); // Defined order
 478    QStringList::Iterator it;
 479    for (it=m_patterns.begin(); it != m_patterns.end(); ++it)
 480    {
 481       KBackgroundPattern pat(m_kdmMode, *it);
 482       if (pat.isAvailable())
 483          m_comboPattern->addItem(pat.comment());
 484    }
 485
 486    loadWallpaperFilesList();
 487
 488    // Wallpaper tilings: again they must match the ones from bgrender.cc
 489    m_comboWallpaperPos->addItem(i18n("Centered"));
 490    m_comboWallpaperPos->addItem(i18n("Tiled"));
 491    m_comboWallpaperPos->addItem(i18n("Center Tiled"));
 492    m_comboWallpaperPos->addItem(i18n("Centered Maxpect"));
 493    m_comboWallpaperPos->addItem(i18n("Tiled Maxpect"));
 494    m_comboWallpaperPos->addItem(i18n("Scaled"));
 495    m_comboWallpaperPos->addItem(i18n("Centered Auto Fit"));
 496    m_comboWallpaperPos->addItem(i18n("Scale & Crop"));
 497
 498    // Blend modes: make sure these match with kdesktop/bgrender.cc !!
 499    m_comboBlend->addItem(i18n("No Blending"));
 500    m_comboBlend->addItem(i18n("Flat"));
 501    m_comboBlend->addItem(i18n("Horizontal"));
 502    m_comboBlend->addItem(i18n("Vertical"));
 503    m_comboBlend->addItem(i18n("Pyramid"));
 504    m_comboBlend->addItem(i18n("Pipecross"));
 505    m_comboBlend->addItem(i18n("Elliptic"));
 506    m_comboBlend->addItem(i18n("Intensity"));
 507    m_comboBlend->addItem(i18n("Saturation"));
 508    m_comboBlend->addItem(i18n("Contrast"));
 509    m_comboBlend->addItem(i18n("Hue Shift"));
 510 }
 511
 512 void BGDialog::loadWallpaperFilesList() {
 513
 514    // Wallpapers
 515    // the following QMap is lower cased names mapped to cased names and URLs
 516    // this way we get case insensitive sorting
 517    QMap<QString, QPair<QString, QString> > papers;
 518
 519    //search for .desktop files before searching for images without .desktop files
 520    QStringList lst = m_pDirs->findAllResources("wallpaper", "*desktop", KStandardDirs::NoDuplicates);
 521    QStringList files;
 522    for (QStringList::ConstIterator it = lst.begin(); it != lst.end(); ++it)
 523    {
 524       KDesktopFile fileConfig(*it);
 525       KConfigGroup cg = fileConfig.group("Wallpaper");
 526
 527       QString imageCaption = cg.readEntry("Name");
 528       QString fileName = cg.readEntry("File");
 529
 530       if (imageCaption.isEmpty())
 531       {
 532          imageCaption = fileName;
 533          imageCaption.replace('_', ' ');
 534          imageCaption = KStringHandler::capwords(imageCaption);
 535       }
 536
 537       // avoid name collisions
 538       QString rs = imageCaption;
 539       QString lrs = rs.toLower();
 540       for (int n = 1; papers.find(lrs) != papers.end(); ++n)
 541       {
 542          rs = imageCaption + " (" + QString::number(n) + ')';
 543          lrs = rs.toLower();
 544       }
 545       int slash = (*it).lastIndexOf('/') + 1;
 546       QString directory = (*it).left(slash);
 547       if ( cg.readEntry("ImageType") == "pixmap" ) {
 548               papers[lrs] = qMakePair(rs, directory + fileName);
 549               files.append(directory + fileName);
 550       }
 551    }
 552
 553    //now find any wallpapers that don't have a .desktop file
 554    lst = m_pDirs->findAllResources("wallpaper", "*", KStandardDirs::NoDuplicates);
 555    for (QStringList::ConstIterator it = lst.begin(); it != lst.end(); ++it)
 556    {
 557       if ( !(*it).endsWith(".desktop") && files.filter(*it).empty() ) {
 558          // First try to see if we have a comment describing the image.  If we do
 559          // just use the first line of said comment.
 560          KFileMetaInfo metaInfo(*it);
 561          QString imageCaption;
 562
 563          if (metaInfo.isValid() && metaInfo.item("Comment").isValid())
 564             imageCaption = metaInfo.item("Comment").value().toString().section('\n', 0, 0);
 565
 566          if (imageCaption.isEmpty())
 567          {
 568             int slash = (*it).lastIndexOf('/') + 1;
 569             int endDot = (*it).lastIndexOf('.');
 570
 571             // strip the extension if it exists
 572             if (endDot != -1 && endDot > slash)
 573                imageCaption = (*it).mid(slash, endDot - slash);
 574             else
 575                imageCaption = (*it).mid(slash);
 576
 577             imageCaption.replace('_', ' ');
 578             imageCaption = KStringHandler::capwords(imageCaption);
 579          }
 580
 581          // avoid name collisions
 582          QString rs = imageCaption;
 583          QString lrs = rs.toLower();
 584          for (int n = 1; papers.find(lrs) != papers.end(); ++n)
 585          {
 586             rs = imageCaption + " (" + QString::number(n) + ')';
 587             lrs = rs.toLower();
 588          }
 589          papers[lrs] = qMakePair(rs, *it);
 590       }
 591    }
 592
 593    KComboBox *comboWallpaper = m_urlWallpaperBox;
 594    comboWallpaper->clear();
 595    m_wallpaper.clear();
 596    int i = 0;
 597    for (QMap<QString, QPair<QString, QString> >::Iterator it = papers.begin();
 598         it != papers.end();
 599         ++it)
 600    {
 601       comboWallpaper->addItem(it.value().first);
 602       m_wallpaper[it.value().second] = i;
 603       i++;
 604    }
 605 }
 606
 607 void BGDialog::setWallpaper(const QString &s)
 608 {
 609    KComboBox *comboWallpaper = m_urlWallpaperBox;
 610    int i = comboWallpaper->count();
 611    if( i==0)
 612      return;
 613    comboWallpaper->blockSignals(true);
 614
 615    if (m_wallpaper.find(s) == m_wallpaper.end())
 616    {
 617       QString imageCaption;
 618       int slash = s.lastIndexOf('/') + 1;
 619       int endDot = s.lastIndexOf('.');
 620
 621       // strip the extension if it exists
 622       if (endDot != -1 && endDot > slash)
 623          imageCaption = s.mid(slash, endDot - slash);
 624       else
 625          imageCaption = s.mid(slash);
 626       if (comboWallpaper->itemText(i-1) == imageCaption)
 627       {
 628          i--;
 629          comboWallpaper->removeItem(i);
 630       }
 631       comboWallpaper->addItem(imageCaption);
 632       m_wallpaper[s] = i;
 633       comboWallpaper->setCurrentIndex(i);
 634    }
 635    else
 636    {
 637       comboWallpaper->setCurrentIndex(m_wallpaper[s]);
 638    }
 639    comboWallpaper->blockSignals(false);
 640 }
 641
 642 void BGDialog::slotWallpaperSelection()
 643 {
 644    KUrl u;
 645    KFileDialog dlg( u, QString(), this);
 646
 647    KImageFilePreview* previewWidget = new KImageFilePreview(&dlg);
 648    dlg.setPreviewWidget(previewWidget);
 649
 650    QStringList mimeTypes = KImageIO::mimeTypes( KImageIO::Reading );
 651    mimeTypes += "image/svg+xml";
 652    dlg.setFilter( mimeTypes.join( " " ) );
 653    dlg.setMode( KFile::File | KFile::ExistingOnly | KFile::LocalOnly );
 654    dlg.setCaption( i18n("Select Wallpaper") );
 655
 656    int j = m_urlWallpaperBox->currentIndex();
 657    QString uri;
 658    for(QMap<QString,int>::ConstIterator it = m_wallpaper.begin();
 659        it != m_wallpaper.end();
 660        ++it)
 661    {
 662       if (it.value() == j)
 663       {
 664          uri = it.key();
 665          break;
 666       }
 667    }
 668
 669    if ( !uri.isEmpty() ) {
 670       dlg.setSelection( uri );
 671    }
 672
 673    if ( dlg.exec() == QDialog::Accepted )
 674    {
 675       setWallpaper(dlg.selectedFile());
 676
 677       int optionID = m_buttonGroupBackground->id(m_radioPicture);
 678       m_buttonGroupBackground->setButton( optionID );
 679       slotWallpaperTypeChanged( optionID );
 680
 681       emit changed(true);
 682    }
 683 }
 684
 685 void BGDialog::updateUI()
 686 {
 687    KBackgroundRenderer *r = eRenderer();
 688    m_comboDesktop->setCurrentIndex(m_eDesk);
 689    m_comboScreen->setCurrentIndex(m_eScreen);
 690
 691    m_colorPrimary->setColor(r->colorA());
 692    m_colorSecondary->setColor(r->colorB());
 693
 694    int wallpaperMode = r->wallpaperMode();
 695    int multiMode = r->multiWallpaperMode();
 696
 697    if (r->backgroundMode() == KBackgroundSettings::Program &&
 698        wallpaperMode == KBackgroundSettings::NoWallpaper)
 699       groupBox3->setEnabled( false );
 700    else
 701       groupBox3->setEnabled( true );
 702
 703    if ((multiMode == KBackgroundSettings::NoMultiRandom) ||
 704        (multiMode == KBackgroundSettings::NoMulti))
 705    {
 706       // No wallpaper
 707       if (wallpaperMode == KBackgroundSettings::NoWallpaper )
 708       {
 709          m_urlWallpaperBox->setEnabled(false);
 710          m_urlWallpaperButton->setEnabled(false);
 711          m_buttonSetupWallpapers->setEnabled(false);
 712          m_comboWallpaperPos->setEnabled(false);
 713          m_lblWallpaperPos->setEnabled(false);
 714          m_buttonGroupBackground->setButton(
 715          m_buttonGroupBackground->id(m_radioNoPicture) );
 716       }
 717
 718       // 1 Picture
 719       else
 720       {
 721          m_urlWallpaperBox->setEnabled(true);
 722          m_urlWallpaperButton->setEnabled(true);
 723          m_buttonSetupWallpapers->setEnabled(false);
 724          m_comboWallpaperPos->setEnabled(true);
 725          m_lblWallpaperPos->setEnabled(true);
 726          setWallpaper(r->wallpaper());
 727          m_buttonGroupBackground->setButton(
 728          m_buttonGroupBackground->id(m_radioPicture) );
 729       }
 730    }
 731
 732    // Slide show
 733    else
 734    {
 735       m_urlWallpaperBox->setEnabled(false);
 736       m_urlWallpaperButton->setEnabled(false);
 737       m_buttonSetupWallpapers->setEnabled(true);
 738       m_comboWallpaperPos->setEnabled(true);
 739       m_lblWallpaperPos->setEnabled(true);
 740       m_buttonGroupBackground->setButton(
 741       m_buttonGroupBackground->id(m_radioSlideShow) );
 742    }
 743
 744    m_comboWallpaperPos->setCurrentIndex(r->wallpaperMode()-1);
 745
 746    bool bSecondaryEnabled = true;
 747    m_comboPattern->blockSignals(true);
 748    switch (r->backgroundMode()) {
 749      case KBackgroundSettings::Flat:
 750         m_comboPattern->setCurrentIndex(0);
 751         bSecondaryEnabled = false;
 752         break;
 753
 754      case KBackgroundSettings::Pattern:
 755         {
 756            int i = m_patterns.indexOf(r->KBackgroundPattern::name());
 757            if (i >= 0)
 758               m_comboPattern->setCurrentIndex(NR_PREDEF_PATTERNS+i);
 759            else
 760               m_comboPattern->setCurrentIndex(0);
 761         }
 762         break;
 763
 764      case KBackgroundSettings::Program:
 765         m_comboPattern->setCurrentIndex(0);
 766         bSecondaryEnabled = false;
 767         break;
 768
 769      default: // Gradient
 770         m_comboPattern->setCurrentIndex(
 771            1 + r->backgroundMode() - KBackgroundSettings::HorizontalGradient);
 772         break;
 773     }
 774     m_comboPattern->blockSignals(false);
 775
 776     m_colorSecondary->setEnabled(bSecondaryEnabled);
 777
 778     int mode = r->blendMode();
 779
 780     m_comboBlend->blockSignals(true);
 781     m_sliderBlend->blockSignals(true);
 782
 783     m_comboBlend->setCurrentIndex(mode);
 784     m_cbBlendReverse->setChecked(r->reverseBlending());
 785     m_sliderBlend->setValue( r->blendBalance() / 10 );
 786
 787     m_comboBlend->blockSignals(false);
 788     m_sliderBlend->blockSignals(false);
 789
 790     // turn it off if there is no background picture set!
 791     setBlendingEnabled(wallpaperMode != KBackgroundSettings::NoWallpaper);
 792
 793     // Start preview renderer(s)
 794     if ( m_eScreen == 0 )
 795     {
 796        r->setPreview( m_pMonitorArrangement->combinedPreviewSize() );
 797        r->start(true);
 798     }
 799     else if ( m_eScreen == 1 )
 800     {
 801        r->setPreview( m_pMonitorArrangement->maxPreviewSize() );
 802        r->start(true);
 803     }
 804     else
 805     {
 806        for (unsigned j = 0; j < m_numScreens; ++j)
 807        {
 808           m_renderer[m_eDesk][j+2]->stop();
 809           m_renderer[m_eDesk][j+2]->setPreview( m_pMonitorArrangement->monitor(j)->size() );
 810           m_renderer[m_eDesk][j+2]->start(true);
 811        }
 812     }
 813 }
 814
 815 void BGDialog::slotPreviewDone(int desk_done, int screen_done)
 816 {
 817    int currentDesk = (m_eDesk > 0) ? m_eDesk-1 : 0;
 818
 819    if ( desk_done != currentDesk )
 820       return;
 821
 822    if (!m_previewUpdates)
 823       return;
 824
 825    KBackgroundRenderer * r = m_renderer[m_eDesk][(m_eScreen>1) ? (screen_done+2) : m_eScreen];
 826
 827    if (r->image().isNull())
 828       return;
 829
 830    r->saveCacheFile();
 831
 832    QPixmap pm = QPixmap::fromImage(r->image());
 833
 834    if ( m_eScreen == 0 )
 835    {
 836       m_pMonitorArrangement->setPixmap(pm);
 837    }
 838    else if ( m_eScreen == 1 )
 839    {
 840       for (unsigned i = 0; i < m_pMonitorArrangement->numMonitors(); ++i)
 841          m_pMonitorArrangement->monitor(i)->setPixmap(pm);
 842    }
 843    else
 844    {
 845       m_pMonitorArrangement->monitor(screen_done)->setPixmap(pm);
 846    }
 847 }
 848
 849 void BGDialog::slotImageDropped(const QString &uri)
 850 {
 851    setWallpaper(uri);
 852
 853    int optionID = m_buttonGroupBackground->id(m_radioPicture);
 854    m_buttonGroupBackground->setButton( optionID );
 855    slotWallpaperTypeChanged( optionID );
 856 }
 857
 858 void BGDialog::slotWallpaperTypeChanged(int i)
 859 {
 860    KBackgroundRenderer *r = eRenderer();
 861    r->stop();
 862
 863    // No picture
 864    if (i == m_buttonGroupBackground->id(m_radioNoPicture))  //None
 865    {
 866       m_urlWallpaperBox->setEnabled(false);
 867       m_urlWallpaperButton->setEnabled(false);
 868       m_buttonSetupWallpapers->setEnabled(false);
 869       m_comboWallpaperPos->setEnabled(false);
 870       m_lblWallpaperPos->setEnabled(false);
 871       r->setWallpaperMode(KBackgroundSettings::NoWallpaper);
 872
 873       if (m_slideShowRandom == KBackgroundSettings::InOrder)
 874          r->setMultiWallpaperMode(KBackgroundSettings::NoMulti);
 875       else
 876          r->setMultiWallpaperMode(KBackgroundSettings::NoMultiRandom);
 877
 878       setBlendingEnabled(false);
 879    }
 880
 881    // Slide show
 882    else if (i == m_buttonGroupBackground->id(m_radioSlideShow))
 883    {
 884       m_urlWallpaperBox->setEnabled(false);
 885       m_urlWallpaperButton->setEnabled(false);
 886       m_buttonSetupWallpapers->setEnabled(true);
 887       m_comboWallpaperPos->setEnabled(true);
 888       m_lblWallpaperPos->setEnabled(true);
 889       setBlendingEnabled(true);
 890
 891       m_comboWallpaperPos->blockSignals(true);
 892       m_comboWallpaperPos->setCurrentIndex(m_wallpaperPos-1);
 893       m_comboWallpaperPos->blockSignals(false);
 894
 895       if (r->wallpaperList().count() == 0)
 896          r->setWallpaperMode( KBackgroundSettings::NoWallpaper );
 897       else
 898          r->setWallpaperMode(m_wallpaperPos);
 899
 900       r->setMultiWallpaperMode(m_slideShowRandom);
 901       setWallpaper(r->wallpaper());
 902       setBlendingEnabled(true);
 903    }
 904
 905    // 1 Picture
 906    else if (i == m_buttonGroupBackground->id(m_radioPicture))
 907    {
 908       m_urlWallpaperBox->setEnabled(true);
 909       m_urlWallpaperButton->setEnabled(true);
 910       m_buttonSetupWallpapers->setEnabled(false);
 911       m_lblWallpaperPos->setEnabled(true);
 912       m_comboWallpaperPos->setEnabled(true);
 913       setBlendingEnabled(true);
 914
 915       if (m_slideShowRandom == KBackgroundSettings::InOrder)
 916          r->setMultiWallpaperMode(KBackgroundSettings::NoMulti);
 917       else
 918          r->setMultiWallpaperMode(KBackgroundSettings::NoMultiRandom);
 919
 920       int j = m_urlWallpaperBox->currentIndex();
 921       QString path;
 922       for(QMap<QString,int>::ConstIterator it = m_wallpaper.begin();
 923           it != m_wallpaper.end();
 924           ++it)
 925       {
 926          if (it.value() == j)
 927          {
 928             path = it.key();
 929             break;
 930          }
 931       }
 932
 933       KFileMetaInfo metaInfo(path);
 934       if (metaInfo.isValid() && metaInfo.item("Dimensions").isValid())
 935       {
 936          // If the image is greater than 800x600 default to using scaled mode,
 937          // otherwise default to tiled.
 938
 939          QSize s = metaInfo.item("Dimensions").value().toSize();
 940          if (s.width() >= 800 && s.height() >= 600)
 941             m_wallpaperPos = KBackgroundSettings::Scaled;
 942          else
 943             m_wallpaperPos = KBackgroundSettings::Tiled;
 944       }
 945       else if (KMimeType::findByPath(path)->is("image/svg+xml"))
 946       {
 947          m_wallpaperPos = KBackgroundSettings::Scaled;
 948       }
 949
 950       r->setWallpaperMode(m_wallpaperPos);
 951       m_comboWallpaperPos->blockSignals(true);
 952       m_comboWallpaperPos->setCurrentIndex(m_wallpaperPos-1);
 953       m_comboWallpaperPos->blockSignals(false);
 954
 955       r->setWallpaper(path);
 956    }
 957
 958    r->start(true);
 959    m_copyAllDesktops = true;
 960    m_copyAllScreens = true;
 961    emit changed(true);
 962 }
 963
 964 void BGDialog::slotWallpaper(int)
 965 {
 966    slotWallpaperTypeChanged(m_buttonGroupBackground->id(m_radioPicture));
 967    emit changed(true);
 968 }
 969
 970 void BGDialog::setBlendingEnabled(bool enable)
 971 {
 972    int mode = eRenderer()->blendMode();
 973
 974    bool b = !(mode == KBackgroundSettings::NoBlending);
 975    m_lblBlending->setEnabled(enable);
 976    m_comboBlend->setEnabled(enable);
 977    m_lblBlendBalance->setEnabled(enable && b);
 978    m_sliderBlend->setEnabled(enable && b);
 979
 980    b = !(mode < KBackgroundSettings::IntensityBlending);
 981    m_cbBlendReverse->setEnabled(enable && b);
 982 }
 983
 984 void BGDialog::slotWallpaperPos(int mode)
 985 {
 986    KBackgroundRenderer *r = eRenderer();
 987
 988    mode++;
 989    m_wallpaperPos = mode;
 990
 991    if (mode == r->wallpaperMode())
 992       return;
 993
 994    r->stop();
 995    r->setWallpaperMode(mode);
 996    r->start(true);
 997    m_copyAllDesktops = true;
 998    m_copyAllScreens = true;
 999    emit changed(true);
1000 }
1001
1002 void BGDialog::slotSetupMulti()
1003 {
1004     KBackgroundRenderer *r = eRenderer();
1005
1006     BGMultiWallpaperDialog dlg(r, window());
1007     if (dlg.exec() == QDialog::Accepted) {
1008         r->stop();
1009         m_slideShowRandom = r->multiWallpaperMode();
1010         r->setWallpaperMode(m_wallpaperPos);
1011         r->start(true);
1012         m_copyAllDesktops = true;
1013         m_copyAllScreens = true;
1014         emit changed(true);
1015     }
1016 }
1017
1018 void BGDialog::slotPrimaryColor(const QColor &color)
1019 {
1020    KBackgroundRenderer *r = eRenderer();
1021
1022    if (color == r->colorA())
1023       return;
1024
1025    r->stop();
1026    r->setColorA(color);
1027    r->start(true);
1028    m_copyAllDesktops = true;
1029    m_copyAllScreens = true;
1030    emit changed(true);
1031 }
1032
1033 void BGDialog::slotSecondaryColor(const QColor &color)
1034 {
1035    KBackgroundRenderer *r = eRenderer();
1036
1037    if (color == r->colorB())
1038       return;
1039
1040    r->stop();
1041    r->setColorB(color);
1042    r->start(true);
1043    m_copyAllDesktops = true;
1044    m_copyAllScreens = true;
1045    emit changed(true);
1046 }
1047
1048 void BGDialog::slotPattern(int pattern)
1049 {
1050    KBackgroundRenderer *r = eRenderer();
1051    r->stop();
1052    bool bSecondaryEnabled = true;
1053    if (pattern < NR_PREDEF_PATTERNS)
1054    {
1055       if (pattern == 0)
1056       {
1057         r->setBackgroundMode(KBackgroundSettings::Flat);
1058         bSecondaryEnabled = false;
1059       }
1060       else
1061       {
1062         r->setBackgroundMode(pattern - 1 + KBackgroundSettings::HorizontalGradient);
1063       }
1064    }
1065    else
1066    {
1067       r->setBackgroundMode(KBackgroundSettings::Pattern);
1068       r->setPatternName(m_patterns[pattern - NR_PREDEF_PATTERNS]);
1069    }
1070    r->start(true);
1071    m_colorSecondary->setEnabled(bSecondaryEnabled);
1072
1073    m_copyAllDesktops = true;
1074    m_copyAllScreens = true;
1075    emit changed(true);
1076 }
1077
1078 void BGDialog::slotSelectScreen(int screen)
1079 {
1080    // Copy the settings from "All screens" to all the other screens
1081    // at a suitable point
1082    if (m_pGlobals->commonScreenBackground() && (screen >1) && m_copyAllScreens)
1083    {
1084       // Copy stuff
1085       for (unsigned desk = 0; desk < m_numDesks+1; ++desk )
1086       {
1087          KBackgroundRenderer *master = m_renderer[desk][1];
1088          for (unsigned screen = 0; screen < m_numScreens; ++screen)
1089          {
1090             m_renderer[desk][screen+2]->copyConfig(master);
1091          }
1092       }
1093    }
1094
1095    if (screen == m_eScreen )
1096    {
1097       return; // Nothing to do
1098    }
1099
1100    m_copyAllScreens = false;
1101
1102    bool drawBackgroundPerScreen = screen > 0;
1103    bool commonScreenBackground = screen < 2;
1104
1105    // Update drawBackgroundPerScreen
1106    if (m_eDesk == 0)
1107    {
1108       for (unsigned desk = 0; desk < m_numDesks; ++desk )
1109          m_pGlobals->setDrawBackgroundPerScreen(desk, drawBackgroundPerScreen);
1110    }
1111    else
1112    {
1113       m_pGlobals->setDrawBackgroundPerScreen(m_eDesk-1, drawBackgroundPerScreen);
1114    }
1115
1116    m_pGlobals->setCommonScreenBackground(commonScreenBackground);
1117
1118    if (screen < 2)
1119       emit changed(true);
1120    else
1121    {
1122       for (unsigned i = 0; i < m_renderer[m_eDesk].size(); ++i)
1123       {
1124          if ( m_renderer[m_eDesk][i]->isActive() )
1125             m_renderer[m_eDesk][i]->stop();
1126       }
1127    }
1128
1129    m_eScreen = screen;
1130    updateUI();
1131 }
1132
1133 void BGDialog::slotSelectDesk(int desk)
1134 {
1135    // Copy the settings from "All desktops" to all the other desktops
1136    // at a suitable point.
1137    if (m_pGlobals->commonDeskBackground() && (desk > 0) && m_copyAllDesktops)
1138    {
1139       // Copy stuff
1140       for (unsigned screen = 0; screen < m_renderer[0].size(); ++screen )
1141       {
1142          KBackgroundRenderer *master = m_renderer[0][screen];
1143          for (unsigned desk = 0; desk < m_numDesks; ++desk )
1144          {
1145             m_renderer[desk+1][screen]->copyConfig(master);
1146          }
1147       }
1148    }
1149
1150    if (desk == m_eDesk)
1151    {
1152       return; // Nothing to do
1153    }
1154
1155    m_copyAllDesktops = false;
1156    if (desk == 0)
1157    {
1158       if (m_pGlobals->commonDeskBackground())
1159          return; // Nothing to do
1160
1161       m_pGlobals->setCommonDeskBackground(true);
1162       emit changed(true);
1163    }
1164    else
1165    {
1166       for (unsigned i = 0; i < m_renderer[m_eDesk].size(); ++i)
1167       {
1168          if ( m_renderer[m_eDesk][i]->isActive() )
1169             m_renderer[m_eDesk][i]->stop();
1170       }
1171       m_pGlobals->setCommonDeskBackground(false);
1172    }
1173
1174    m_eDesk = desk;
1175    getEScreen();
1176    updateUI();
1177 }
1178
1179 void BGDialog::slotAdvanced()
1180 {
1181     KBackgroundRenderer *r = eRenderer();
1182
1183     m_previewUpdates = false;
1184     BGAdvancedDialog dlg(r, window(), m_kdmMode);
1185
1186     if (!m_pMonitorArrangement->isEnabled()) {
1187        dlg.makeReadOnly();
1188        dlg.exec();
1189        return;
1190     }
1191
1192     dlg.setTextColor(m_pGlobals->textColor());
1193     dlg.setTextBackgroundColor(m_pGlobals->textBackgroundColor());
1194     dlg.setShadowEnabled(m_pGlobals->shadowEnabled());
1195     dlg.setTextLines(m_pGlobals->textLines());
1196     dlg.setTextWidth(m_pGlobals->textWidth());
1197
1198     if (m_pGlobals->limitCache())
1199        dlg.setCacheSize( m_pGlobals->cacheSize() );
1200     else
1201        dlg.setCacheSize( 0 );
1202
1203     if( !dlg.exec())
1204     {
1205         m_previewUpdates = true;
1206         return;
1207     }
1208     int cacheSize = dlg.cacheSize();
1209     if (cacheSize)
1210     {
1211        m_pGlobals->setCacheSize(cacheSize);
1212        m_pGlobals->setLimitCache(true);
1213     }
1214     else
1215     {
1216        m_pGlobals->setLimitCache(false);
1217     }
1218
1219     m_pGlobals->setTextColor(dlg.textColor());
1220     m_pGlobals->setTextBackgroundColor(dlg.textBackgroundColor());
1221     m_pGlobals->setShadowEnabled(dlg.shadowEnabled());
1222     m_pGlobals->setTextLines(dlg.textLines());
1223     m_pGlobals->setTextWidth(dlg.textWidth());
1224
1225     r->stop();
1226     m_previewUpdates = true;
1227     r->start(true);
1228
1229     updateUI();
1230     m_copyAllDesktops = true;
1231     emit changed(true);
1232 }
1233
1234 void BGDialog::slotGetNewStuff()
1235 {
1236    // We use the more complicated KNewStuff2 API here because these settings
1237    // might affect both kcmshell and kcontrol
1238
1239    KNS::Engine *engine = new KNS::Engine(this);
1240    engine->init("background.knsrc");
1241    //FIXME (KNS2): monday change
1242    //engine->setTitle(i18n("Get New Wallpapers"));
1243    engine->downloadDialogModal();
1244    delete engine;
1245
1246    // FIXME (KNS2): engine->download gives us meta infos, write those into
1247    // the .desktop files
1248    loadWallpaperFilesList();
1249 }
1250
1251 void BGDialog::slotBlendMode(int mode)
1252 {
1253    if (mode == eRenderer()->blendMode())
1254       return;
1255
1256    bool b = !(mode == KBackgroundSettings::NoBlending);
1257    m_sliderBlend->setEnabled( b );
1258    m_lblBlendBalance->setEnabled( b );
1259
1260    b = !(mode < KBackgroundSettings::IntensityBlending);
1261    m_cbBlendReverse->setEnabled(b);
1262    emit changed(true);
1263
1264    eRenderer()->stop();
1265    eRenderer()->setBlendMode(mode);
1266    eRenderer()->start(true);
1267 }
1268
1269 void BGDialog::slotBlendBalance(int value)
1270 {
1271    value = value*10;
1272    if (value == eRenderer()->blendBalance())
1273       return;
1274    emit changed(true);
1275
1276    eRenderer()->stop();
1277    eRenderer()->setBlendBalance(value);
1278    eRenderer()->start(true);
1279 }
1280
1281 void BGDialog::slotBlendReverse(bool b)
1282 {
1283    if (b == eRenderer()->reverseBlending())
1284       return;
1285    emit changed(true);
1286
1287    eRenderer()->stop();
1288    eRenderer()->setReverseBlending(b);
1289    eRenderer()->start(true);
1290 }
1291
1292 void BGDialog::desktopResized()
1293 {
1294    for (int i = 0; i < m_renderer.size(); ++i)
1295    {
1296       for (unsigned j = 0; j < m_renderer[i].size(); ++j )
1297       {
1298          KBackgroundRenderer * r = m_renderer[i][j];
1299          if( r->isActive())
1300              r->stop();
1301          r->desktopResized();
1302       }
1303    }
1304    eRenderer()->start(true);
1305 }
1306
1307
1308 #include "bgdialog.moc"