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