workspace/ksmserver/shutdowndlg.cpp

   1 /*****************************************************************
   2 ksmserver - the KDE session management server
   3
   4 Copyright 2000 Matthias Ettrich <ettrich@kde.org>
   5 Copyright 2007 Urs Wolfer <uwolfer @ kde.org>
   6
   7 Permission is hereby granted, free of charge, to any person obtaining a copy
   8 of this software and associated documentation files (the "Software"), to deal
   9 in the Software without restriction, including without limitation the rights
  10 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11 copies of the Software, and to permit persons to whom the Software is
  12 furnished to do so, subject to the following conditions:
  13
  14 The above copyright notice and this permission notice shall be included in
  15 all copies or substantial portions of the Software.
  16
  17 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  20 AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23
  24 ******************************************************************/
  25
  26 #include "shutdowndlg.h"
  27 #include "plasma/framesvg.h"
  28 #include "plasma/theme.h"
  29
  30 #include <QBitmap>
  31 #include <QDesktopWidget>
  32 #include <QLabel>
  33 #include <QPainter>
  34 #include <QMenu>
  35 #include <QTimer>
  36 #include <QTimeLine>
  37 #include <QPaintEvent>
  38 #include <QVBoxLayout>
  39 #include <QHBoxLayout>
  40
  41 #include <KApplication>
  42 #include <kdialog.h>
  43 #include <kiconloader.h>
  44 #include <klocale.h>
  45 #include <kuser.h>
  46 #include <solid/control/powermanager.h>
  47 #include <kwindowsystem.h>
  48 #include <netwm.h>
  49
  50 #include <stdio.h>
  51 #include <kxerrorhandler.h>
  52
  53 #include <kdisplaymanager.h>
  54
  55 #include <config-workspace.h>
  56
  57 #include "logouteffect.h"
  58 #include "shutdowndlg.moc"
  59
  60 #include <kjob.h>
  61
  62 #define FONTCOLOR "#bfbfbf"
  63
  64 KSMShutdownFeedback * KSMShutdownFeedback::s_pSelf = 0L;
  65
  66 KSMShutdownFeedback::KSMShutdownFeedback()
  67  : QWidget( 0L, Qt::Popup ),
  68     m_currentY( 0 ), initialized( false )
  69 {
  70     setObjectName( "feedbackwidget" );
  71     setAttribute( Qt::WA_NoSystemBackground );
  72     setAttribute( Qt::WA_PaintOnScreen );
  73     setGeometry( QApplication::desktop()->geometry() );
  74     m_pixmap = QPixmap( size() );
  75     QTimer::singleShot( 10, this, SLOT( slotPaintEffect() ) );
  76 }
  77
  78
  79 void KSMShutdownFeedback::paintEvent( QPaintEvent* )
  80 {
  81     if ( !initialized )
  82         return;
  83
  84     QPainter painter( this );
  85     painter.setCompositionMode( QPainter::CompositionMode_Source );
  86     painter.drawPixmap( 0, 0, m_pixmap );
  87 }
  88
  89 void KSMShutdownFeedback::slotPaintEffect()
  90 {
  91     effect = LogoutEffect::create(this, &m_pixmap);
  92     connect(effect, SIGNAL(initialized()),
  93             this,   SLOT  (slotPaintEffectInitialized()));
  94
  95     effect->start();
  96 }
  97
  98 void KSMShutdownFeedback::slotPaintEffectInitialized()
  99 {
 100     initialized = true;
 101 }
 102
 103 void KSMShutdownFeedback::start()
 104 {
 105     if( KWindowSystem::compositingActive()) {
 106         // HACK do properly
 107         Display* dpy = QX11Info::display();
 108         char net_wm_cm_name[ 100 ];
 109         sprintf( net_wm_cm_name, "_NET_WM_CM_S%d", DefaultScreen( dpy ));
 110         Atom net_wm_cm = XInternAtom( dpy, net_wm_cm_name, False );
 111         Window sel = XGetSelectionOwner( dpy, net_wm_cm );
 112         Atom hack = XInternAtom( dpy, "_KWIN_LOGOUT_EFFECT", False );
 113         bool wmsupport = false;
 114         if( sel != None ) {
 115             KXErrorHandler handler;
 116             int cnt;
 117             Atom* props = XListProperties( dpy, sel, &cnt );
 118             if( !handler.error( false ) && props != NULL && qFind( props, props + cnt, hack ) != props + cnt )
 119                 wmsupport = true;
 120             if( props != NULL )
 121                 XFree( props );
 122         }
 123         if( wmsupport )
 124             return;
 125     }
 126     s_pSelf = new KSMShutdownFeedback();
 127     s_pSelf->show();
 128 }
 129
 130 void KSMShutdownFeedback::stop()
 131 {
 132     delete s_pSelf;
 133     s_pSelf = NULL;
 134 }
 135
 136 ////////////
 137
 138 KSMPushButton::KSMPushButton( const QString &text, QWidget *parent, bool smallButton )
 139  : QPushButton( text, parent ),  m_highlight( false ), m_text( text ), m_popupMenu(0), m_popupTimer(0),
 140    m_glowOpacity( 0.0 ), m_smallButton( smallButton )
 141 {
 142     setAttribute(Qt::WA_Hover, true);
 143     m_text = text;
 144     init();
 145 }
 146
 147 void KSMPushButton::init()
 148 {
 149     if (m_smallButton) {
 150         setMinimumSize(88, 22);
 151         setFixedHeight(22); // workaround: force correct height
 152     } else {
 153         setMinimumSize(165, 38);
 154         setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
 155     }
 156
 157     connect( this, SIGNAL(pressed()), SLOT(slotPressed()) );
 158     connect( this, SIGNAL(released()), SLOT(slotReleased()) );
 159
 160     m_glowSvg = new Plasma::Svg(this);
 161     m_glowSvg->setImagePath("dialogs/shutdowndialog");
 162     connect( m_glowSvg, SIGNAL(repaintNeeded()), this, SLOT(update()) );
 163
 164     m_glowTimeLine = new QTimeLine( 150, this );
 165     connect( m_glowTimeLine, SIGNAL(valueChanged(qreal)),
 166             this, SLOT(animateGlow(qreal)) );
 167
 168     QFont fnt;
 169     fnt.setPixelSize(12);
 170
 171     // Calculate the width of the text when splitted on two lines and
 172     // properly resize the button.
 173     if (QFontMetrics(fnt).width(m_text) > width() - 4 - (m_smallButton ? 16 : 32) ||
 174         (2 * QFontMetrics(fnt).lineSpacing() > height() && !m_smallButton) ) {
 175         int w, h;
 176         int i = m_text.length()/2;
 177         int fac = 1;
 178         int diff = 1;
 179         while( i && i < m_text.length() && m_text[i] != ' ' ) {
 180             i = i + (diff * fac);
 181             fac *= -1;
 182             ++diff;
 183         }
 184         QString upper = m_text.left( i );
 185         QString lower = m_text.right( m_text.length() - i );
 186
 187         w = qMax(QFontMetrics(fnt).width(upper) + 18 + (m_smallButton ? 16 : 32),
 188                  QFontMetrics(fnt).width(lower) + 18 + (m_smallButton ? 16 : 32));
 189         w = qMax(w, width());
 190         h = qMax(height(), ((upper.isEmpty() || lower.isEmpty()) ? 1 : 2) * QFontMetrics(fnt).lineSpacing());
 191         if (w > width() || h > height()) {
 192             setMinimumSize(w, h);
 193             if (m_smallButton)
 194                 setFixedHeight(h);
 195             updateGeometry();
 196         }
 197     }
 198 }
 199
 200 void KSMPushButton::paintEvent( QPaintEvent * e )
 201 {
 202     QPainter p( this );
 203     p.setClipRect( e->rect() );
 204     p.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing);
 205     QPen pen;
 206     QFont fnt;
 207     QColor fntColor = Plasma::Theme::defaultTheme()->color(Plasma::Theme::TextColor);
 208     fnt.setPixelSize(12);
 209     p.setFont( fnt );
 210     p.setCompositionMode(QPainter::CompositionMode_SourceOver);
 211
 212     p.save();
 213
 214     if (m_glowOpacity > 0) {
 215         p.setOpacity(m_glowOpacity); // fade in
 216         m_glowSvg->paint(&p, QRect(0, 0, width(), height()), m_smallButton ? "button-small-hover" : "button-hover");
 217         p.setOpacity(1.0 - m_glowOpacity); // fade normal background out
 218         m_glowSvg->paint(&p, QRect(0, 0, width(), height()), m_smallButton ? "button-small-normal" : "button-normal");
 219         p.setOpacity(1.0);
 220     } else {
 221         m_glowSvg->resize();
 222         m_glowSvg->paint(&p, QRect(0, 0, width(), height()), m_smallButton ? "button-small-normal" : "button-normal");
 223     }
 224
 225     p.restore();
 226
 227     p.setRenderHints( QPainter::Antialiasing, false);
 228     p.drawPixmap(width() - (m_smallButton ? 16 : 32) - 4, height() / 2 - (m_smallButton ? 8 : 16), m_pixmap);
 229
 230     p.save();
 231     p.setPen(fntColor);
 232     p.drawText(10, 0, width() - (m_smallButton ? 16 : 32) - 8, height(),
 233                Qt::AlignVCenter | Qt::AlignLeft | Qt::TextWordWrap | Qt::TextShowMnemonic, m_text);
 234     p.restore();
 235
 236     if( m_popupMenu ) {
 237         p.save();
 238         p.setBrush(fntColor);
 239         pen.setColor(QColor(fntColor));
 240         p.setPen( pen );
 241         QPoint points[3] = {
 242             QPoint(width() - 10 - 34, height() - 7),
 243             QPoint(width() - 4 - 34, height() - 7),
 244             QPoint(width() - 7 - 34, height() - 4) };
 245         p.drawPolygon(points, 3); // TODO: use QStyle
 246         p.restore();
 247     }
 248 }
 249
 250 void KSMPushButton::resizeEvent(QResizeEvent *e)
 251 {
 252     m_glowSvg->resize( e->size() );
 253     QPushButton::resizeEvent( e );
 254 }
 255
 256 void KSMPushButton::animateGlow( qreal value )
 257 {
 258     m_glowOpacity = value;
 259     update();
 260 }
 261
 262 void KSMPushButton::setPixmap( const QPixmap &p )
 263 {
 264     m_pixmap = p;
 265     int size = m_smallButton ? 16 : 32;
 266     if (m_pixmap.size().width() != size || m_pixmap.size().height() != size)
 267         m_pixmap = m_pixmap.scaled(size, size);
 268     update();
 269 }
 270
 271 void KSMPushButton::setPopupMenu( QMenu *m )
 272 {
 273     m_popupMenu = m;
 274     if( !m_popupTimer ) {
 275         m_popupTimer = new QTimer( this );
 276         connect( m_popupTimer, SIGNAL(timeout()), this, SLOT(slotTimeout()));
 277     }
 278 }
 279
 280 void KSMPushButton::slotPressed()
 281 {
 282     if( m_popupTimer )
 283         m_popupTimer->start( QApplication::startDragTime() );
 284 }
 285
 286 void KSMPushButton::slotReleased()
 287 {
 288     if( m_popupTimer )
 289         m_popupTimer->stop();
 290 }
 291
 292 void KSMPushButton::slotTimeout()
 293 {
 294     m_popupTimer->stop();
 295     if( m_popupMenu ) {
 296         m_popupMenu->popup( mapToGlobal(rect().bottomLeft()) );
 297         m_highlight = false;
 298         update();
 299     }
 300 }
 301
 302 bool KSMPushButton::event( QEvent *e )
 303 {
 304     if (e->type() == QEvent::HoverEnter || e->type() == QEvent::FocusIn)
 305     {
 306         if (m_glowOpacity > 0) // already hovered
 307             return true;
 308         m_highlight = true;
 309         m_glowTimeLine->setDirection( QTimeLine::Forward );
 310         if (m_glowTimeLine->state() == QTimeLine::Running)
 311             m_glowTimeLine->stop();
 312         m_glowTimeLine->start();
 313         update();
 314         return true;
 315     }
 316     else if (e->type() == QEvent::HoverLeave || e->type() == QEvent::FocusOut)
 317     {
 318         if (hasFocus())
 319             return true;
 320         m_highlight = false;
 321         m_glowTimeLine->setDirection( QTimeLine::Backward );
 322         if (m_glowTimeLine->state() == QTimeLine::Running)
 323             m_glowTimeLine->stop();
 324         m_glowTimeLine->start();
 325         update();
 326         return true;
 327     }
 328     else
 329         return QPushButton::event( e );
 330 }
 331
 332 //////
 333
 334 Q_DECLARE_METATYPE(Solid::Control::PowerManager::SuspendMethod)
 335
 336 KSMShutdownDlg::KSMShutdownDlg( QWidget* parent,
 337                                 bool maysd, KWorkSpace::ShutdownType sdtype )
 338   : QDialog( parent, Qt::Popup ), //krazy:exclude=qclasses
 339     m_btnLogout(0),
 340     m_btnHalt(0),
 341     m_btnReboot(0),
 342     m_automaticallyDoSeconds(30),
 343     m_pictureWidth(0)
 344     // this is a WType_Popup on purpose. Do not change that! Not
 345     // having a popup here has severe side effects.
 346 {
 347     winId(); // workaround for Qt4.3 setWindowRole() assert
 348     setWindowRole( "logoutdialog" );
 349 //#if !(QT_VERSION >= QT_VERSION_CHECK(4, 3, 3) || defined(QT_KDE_QT_COPY))
 350 // Qt doesn't set this on unmanaged windows
 351     QByteArray appName = qAppName().toLatin1();
 352     XClassHint class_hint;
 353     class_hint.res_name = appName.data(); // application name
 354     class_hint.res_class = const_cast<char *>(QX11Info::appClass());   // application class
 355     XSetWMProperties( QX11Info::display(), winId(), NULL, NULL, NULL, NULL, NULL, NULL, &class_hint );
 356     XChangeProperty( QX11Info::display(), winId(),
 357         XInternAtom( QX11Info::display(), "WM_WINDOW_ROLE", False ), XA_STRING, 8, PropModeReplace,
 358         (unsigned char *)"logoutdialog", strlen( "logoutdialog" ));
 359
 360 //#endif
 361     m_svg = new Plasma::FrameSvg(this);
 362     m_svg->setImagePath("dialogs/shutdowndialog");
 363     connect( m_svg, SIGNAL(repaintNeeded()), this, SLOT(update()) );
 364     setModal( true );
 365
 366     QVBoxLayout *mainLayout = new QVBoxLayout();
 367
 368     mainLayout->setContentsMargins(12, 9, 12, 7);
 369
 370     QVBoxLayout *buttonLayout = new QVBoxLayout();
 371     QHBoxLayout *buttonMainLayout = new QHBoxLayout();
 372
 373     m_automaticallyDoLabel = new QLabel(this);
 374     mainLayout->addWidget(m_automaticallyDoLabel, 0, Qt::AlignRight);
 375
 376     buttonMainLayout->addLayout(buttonLayout);
 377
 378     QHBoxLayout *bottomLayout = new QHBoxLayout();
 379
 380     QFont fnt;
 381     fnt.setPixelSize(16);
 382     QColor fntColor = Plasma::Theme::defaultTheme()->color(Plasma::Theme::TextColor);
 383     QPalette palette;
 384     palette.setColor(QPalette::WindowText, fntColor);
 385
 386     m_btnLogout = new KSMPushButton( i18n("&Logout"), this );
 387     m_btnLogout->setPixmap(KIconLoader::global()->loadIcon("system-log-out", KIconLoader::NoGroup, 32));
 388     if ( sdtype == KWorkSpace::ShutdownTypeLogout )
 389         m_btnLogout->setFocus();
 390     connect(m_btnLogout, SIGNAL(clicked()), SLOT(slotLogout()));
 391     buttonLayout->addWidget(m_btnLogout, Qt::AlignRight | Qt::AlignTop);
 392
 393     if (maysd) {
 394         // Shutdown
 395         m_btnHalt = new KSMPushButton( i18n("&Turn Off Computer"), this );
 396         m_btnHalt->setPixmap(KIconLoader::global()->loadIcon("system-shutdown", KIconLoader::NoGroup, 32));
 397         buttonLayout->addWidget(m_btnHalt, Qt::AlignTop | Qt::AlignRight);
 398         connect(m_btnHalt, SIGNAL(clicked()), SLOT(slotHalt()));
 399         if ( sdtype == KWorkSpace::ShutdownTypeHalt )
 400             m_btnHalt->setFocus();
 401
 402         QMenu *shutdownMenu = new QMenu( m_btnHalt );
 403         QActionGroup* spdActionGroup = new QActionGroup(shutdownMenu);
 404         connect( spdActionGroup, SIGNAL(triggered(QAction*)), SLOT(slotSuspend(QAction*)) );
 405         m_btnHalt->setPopupMenu( shutdownMenu );
 406         Solid::Control::PowerManager::SuspendMethods spdMethods = Solid::Control::PowerManager::supportedSuspendMethods();
 407         if( spdMethods & Solid::Control::PowerManager::Standby ) {
 408             QAction* action = new QAction(i18n("&Standby"), spdActionGroup);
 409             action->setData(QVariant::fromValue(Solid::Control::PowerManager::Standby));
 410         }
 411         if( spdMethods & Solid::Control::PowerManager::ToRam ) {
 412             QAction* action = new QAction(i18n("Suspend to &RAM"), spdActionGroup);
 413             action->setData(QVariant::fromValue(Solid::Control::PowerManager::ToRam));
 414         }
 415         if( spdMethods & Solid::Control::PowerManager::ToDisk ) {
 416             QAction* action = new QAction(i18n("Suspend to &Disk"), spdActionGroup);
 417             action->setData(QVariant::fromValue(Solid::Control::PowerManager::ToDisk));
 418         }
 419         shutdownMenu->addActions(spdActionGroup->actions());
 420
 421         // Reboot
 422         m_btnReboot = new KSMPushButton( i18n("&Restart Computer"), this );
 423         m_btnReboot->setPixmap(KIconLoader::global()->loadIcon("system-restart", KIconLoader::NoGroup, 32));
 424         connect(m_btnReboot, SIGNAL(clicked()), SLOT(slotReboot()));
 425         buttonLayout->addWidget(m_btnReboot, Qt::AlignTop | Qt::AlignRight);
 426         if ( sdtype == KWorkSpace::ShutdownTypeReboot )
 427             m_btnReboot->setFocus();
 428
 429         int def, cur;
 430         if ( KDisplayManager().bootOptions( rebootOptions, def, cur ) ) {
 431             if ( cur == -1 )
 432                 cur = def;
 433
 434             QMenu *rebootMenu = new QMenu( m_btnReboot );
 435             QActionGroup* rebootActionGroup = new QActionGroup(rebootMenu);
 436             connect( rebootActionGroup, SIGNAL(triggered(QAction*)), SLOT(slotReboot(QAction*)) );
 437             m_btnReboot->setPopupMenu( rebootMenu );
 438
 439             int index = 0;
 440             for (QStringList::ConstIterator it = rebootOptions.constBegin(); it != rebootOptions.constEnd(); ++it, ++index) {
 441                 QString label = (*it);
 442                 label=label.replace('&',"&&");
 443                 QAction* action = new QAction(label, rebootActionGroup);
 444                 action->setData(index);
 445                 if (index == cur) {
 446                     action->setText( label + i18nc("current option in boot loader", " (current)") );
 447                 }
 448             }
 449             rebootMenu->addActions(rebootActionGroup->actions());
 450         }
 451     }
 452
 453     if ( sdtype == KWorkSpace::ShutdownTypeLogout ) {
 454         m_btnReboot->setHidden(true);
 455         m_btnHalt->setHidden(true);
 456     }
 457     else if ( sdtype == KWorkSpace::ShutdownTypeHalt ) {
 458         m_btnReboot->setHidden(true);
 459         m_btnLogout->setHidden(true);
 460     }
 461     else if ( sdtype == KWorkSpace::ShutdownTypeReboot ) {
 462         m_btnHalt->setHidden(true);
 463         m_btnLogout->setHidden(true);
 464     }
 465
 466     btnBack = new KSMPushButton(i18n("&Cancel"), this, true);
 467     btnBack->setPixmap(KIconLoader::global()->loadIcon( "dialog-cancel", KIconLoader::NoGroup, 16));
 468
 469     m_automaticallyDoLabel->setPalette(palette);
 470     fnt.setPixelSize(11);
 471     m_automaticallyDoLabel->setFont(fnt);
 472     automaticallyDoTimeout();
 473
 474     QTimer *automaticallyDoTimer = new QTimer(this);
 475     connect(automaticallyDoTimer, SIGNAL(timeout()), this, SLOT(automaticallyDoTimeout()));
 476     automaticallyDoTimer->start(1000);
 477
 478     bottomLayout->addStretch();
 479     bottomLayout->addWidget(btnBack);
 480     connect(btnBack, SIGNAL(clicked()), SLOT(reject()));
 481
 482     mainLayout->addLayout(buttonMainLayout);
 483     mainLayout->addSpacing(9);
 484     mainLayout->addLayout(bottomLayout);
 485
 486     setLayout(mainLayout);
 487     adjustSize();
 488     if (m_svg->hasElement("picture")) {
 489         QRect pictRect = m_svg->elementRect("picture").toRect();
 490
 491         if (pictRect.height() < 1 || pictRect.width() < 1) {
 492             m_pictureWidth = 0;
 493         } else if (height() > width()) {
 494             m_pictureWidth = width();
 495         } else {
 496             m_svg->isValid();
 497             m_pictureWidth = mainLayout->sizeHint().height() * (pictRect.width() / pictRect.height());
 498             //kDebug() << "blurk!" << buttonMainLayout->sizeHint().height() << pictRect;
 499         }
 500
 501         //kDebug() << width() << m_pictureWidth;
 502         //FIXME: this spaces will be taken from framesvg borders
 503         if (m_pictureWidth > 0) {
 504             const int extraSpace = 18;
 505             buttonMainLayout->insertSpacing(0, m_pictureWidth + extraSpace);
 506         }
 507         //resize(width() + m_pictureWidth, height());
 508         //kDebug() << width();
 509     } else {
 510         m_pictureWidth = 0;
 511     }
 512
 513     KDialog::centerOnScreen(this);
 514 }
 515
 516 void KSMShutdownDlg::automaticallyDoTimeout()
 517 {
 518     QPushButton *focusedButton = qobject_cast<QPushButton *>(focusWidget());
 519     if (focusedButton) {
 520         if (m_automaticallyDoSeconds <= 0) { // timeout is at 0, do selected action
 521                 focusedButton->click();
 522         // following code is required to provide a clean way to translate strings
 523         } else if (focusedButton == m_btnLogout) {
 524             m_automaticallyDoLabel->setText(i18np("Logging out in 1 second.",
 525                                             "Logging out in %1 seconds.", m_automaticallyDoSeconds));
 526         } else if (focusedButton == m_btnHalt) {
 527                 m_automaticallyDoLabel->setText(i18np("Turning off computer in 1 second.",
 528                                                       "Turning off computer in %1 seconds.", m_automaticallyDoSeconds));
 529         } else if (focusedButton == m_btnReboot) {
 530                 m_automaticallyDoLabel->setText(i18np("Restarting computer in 1 second.",
 531                                                       "Restarting computer in %1 seconds.", m_automaticallyDoSeconds));
 532         } else {
 533             m_automaticallyDoLabel->setText(QString());
 534         }
 535
 536         if (m_automaticallyDoLabel > 0) {
 537             --m_automaticallyDoSeconds;
 538         }
 539     }
 540 }
 541
 542 void KSMShutdownDlg::paintEvent(QPaintEvent *e)
 543 {
 544     Q_UNUSED(e);
 545     QPainter p(this);
 546     p.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
 547     p.setCompositionMode( QPainter::CompositionMode_Source );
 548     p.setClipRect(e->rect());
 549
 550     p.fillRect(QRect(0, 0, width(), height()), Qt::transparent);
 551
 552     if (m_svg->hasElement("center")) {
 553         m_svg->resizeFrame(size());
 554         m_svg->paintFrame(&p);
 555     } else {
 556         m_svg->paint(&p, QRect(0, 0, width(), height()), "background");
 557     }
 558
 559     if (m_pictureWidth > 0) { // implies hasElement("picture")
 560         QRect r = layout()->geometry();
 561         r.setWidth(m_pictureWidth);
 562
 563         m_svg->resize(m_svg->elementRect("picture").size());
 564         QPixmap picture = m_svg->pixmap("picture");
 565         m_svg->resize();
 566
 567         //kDebug() << 1 << r << picture.size();
 568         if (r.width() < picture.width()) {
 569             picture = picture.scaledToWidth(r.width(), Qt::SmoothTransformation);
 570         }
 571
 572         if (r.height() < picture.height()) {
 573             picture = picture.scaledToHeight(r.height(), Qt::SmoothTransformation);
 574         }
 575
 576
 577         int left = (r.height() - picture.height())/2;
 578         if (QApplication::isLeftToRight()) {
 579             r.moveLeft(left);
 580         } else {
 581             r.moveRight(layout()->geometry().width() - left);
 582         }
 583
 584         //kDebug() << 2 << r << picture.size();
 585         QRect dest = picture.rect();
 586         dest.moveCenter(r.center());
 587         p.setCompositionMode( QPainter::CompositionMode_SourceOver );
 588         p.drawPixmap(dest, picture, picture.rect());
 589     }
 590 }
 591
 592 void KSMShutdownDlg::resizeEvent(QResizeEvent *e)
 593 {
 594     QDialog::resizeEvent( e );
 595
 596     if( KWindowSystem::compositingActive()) {
 597         clearMask();
 598     } else {
 599         QBitmap mask(size());
 600         mask.fill(Qt::color0);
 601
 602         QPainter p(&mask);
 603         m_svg->resize(size());
 604         m_svg->paint(&p, QRect(0, 0, width(), height()), "background");
 605         setMask(mask);
 606     }
 607 }
 608
 609 void KSMShutdownDlg::slotLogout()
 610 {
 611     m_shutdownType = KWorkSpace::ShutdownTypeNone;
 612     accept();
 613 }
 614
 615 void KSMShutdownDlg::slotReboot()
 616 {
 617     // no boot option selected -> current
 618     m_bootOption.clear();
 619     m_shutdownType = KWorkSpace::ShutdownTypeReboot;
 620     accept();
 621 }
 622
 623 void KSMShutdownDlg::slotReboot(QAction* action)
 624 {
 625     int opt = action->data().toInt();
 626     if (int(rebootOptions.size()) > opt)
 627         m_bootOption = rebootOptions[opt];
 628     m_shutdownType = KWorkSpace::ShutdownTypeReboot;
 629     accept();
 630 }
 631
 632
 633 void KSMShutdownDlg::slotHalt()
 634 {
 635     m_bootOption.clear();
 636     m_shutdownType = KWorkSpace::ShutdownTypeHalt;
 637     accept();
 638 }
 639
 640
 641 void KSMShutdownDlg::slotSuspend(QAction* action)
 642 {
 643     m_bootOption.clear();
 644     Solid::Control::PowerManager::SuspendMethod spdMethod = action->data().value<Solid::Control::PowerManager::SuspendMethod>();
 645     KJob *job = Solid::Control::PowerManager::suspend( spdMethod );
 646     if (job != 0)
 647        job->start();
 648     reject();
 649 }
 650
 651 bool KSMShutdownDlg::confirmShutdown( bool maysd, KWorkSpace::ShutdownType& sdtype, QString& bootOption )
 652 {
 653     KSMShutdownDlg* l = new KSMShutdownDlg( 0,
 654                                             //KSMShutdownFeedback::self(),
 655                                             maysd, sdtype );
 656     XClassHint classHint;
 657     classHint.res_name = const_cast<char*>("ksmserver");
 658     classHint.res_class = const_cast<char*>("ksmserver");
 659
 660     XSetClassHint(QX11Info::display(), l->winId(), &classHint);
 661     bool result = l->exec();
 662     sdtype = l->m_shutdownType;
 663     bootOption = l->m_bootOption;
 664
 665     delete l;
 666
 667     return result;
 668 }