workspace/krunner/saverengine.cpp

   1 //===========================================================================
   2 //
   3 // This file is part of the KDE project
   4 //
   5 // Copyright 1999 Martin R. Jones <mjones@kde.org>
   6 //
   7
   8
   9 #include "saverengine.h"
  10 #include "kscreensaversettings.h"
  11 #include "screensaveradaptor.h"
  12 #include "kscreensaveradaptor.h"
  13
  14 #include <kstandarddirs.h>
  15 #include <kapplication.h>
  16 #include <kservicegroup.h>
  17 #include <krandom.h>
  18 #include <kdebug.h>
  19 #include <klocale.h>
  20 #include <QFile>
  21 #include <QX11Info>
  22 #include <QDBusConnection>
  23 #include <assert.h>
  24 #include <stdlib.h>
  25 #include <time.h>
  26
  27 #include "xautolock_c.h"
  28 extern xautolock_corner_t xautolock_corners[ 4 ];
  29
  30 //===========================================================================
  31 //
  32 // Screen saver engine. Doesn't handle the actual screensaver window,
  33 // starting screensaver hacks, or password entry. That's done by
  34 // a newly started process.
  35 //
  36 SaverEngine::SaverEngine()
  37     : QWidget()
  38 {
  39     (void) new ScreenSaverAdaptor( this );
  40     QDBusConnection::sessionBus().registerService( "org.freedesktop.ScreenSaver" ) ;
  41     (void) new KScreenSaverAdaptor( this );
  42     QDBusConnection::sessionBus().registerService( "org.kde.screensaver" ) ;
  43     QDBusConnection::sessionBus().registerObject( "/ScreenSaver", this );
  44
  45     // Save X screensaver parameters
  46     XGetScreenSaver(QX11Info::display(), &mXTimeout, &mXInterval,
  47                     &mXBlanking, &mXExposures);
  48     // ... and disable it
  49     XSetScreenSaver(QX11Info::display(), 0, mXInterval, mXBlanking, mXExposures);
  50
  51     mState = Waiting;
  52     mXAutoLock = 0;
  53
  54     m_nr_throttled = 0;
  55     m_nr_inhibited = 0;
  56     m_actived_time = -1;
  57
  58     connect(&mLockProcess, SIGNAL(processExited(K3Process *)),
  59                         SLOT(lockProcessExited()));
  60
  61     connect(QDBusConnection::sessionBus().interface(),
  62                 SIGNAL(serviceOwnerChanged(QString,QString,QString)),
  63             SLOT(serviceOwnerChanged(QString,QString,QString)));
  64
  65     // I make it a really random number to avoid
  66     // some assumptions in clients, but just increase
  67     // while gnome-ss creates a random number every time
  68     m_next_cookie = KRandom::random() % 20000;
  69     configure();
  70 }
  71
  72 //---------------------------------------------------------------------------
  73 //
  74 // Destructor - usual cleanups.
  75 //
  76 SaverEngine::~SaverEngine()
  77 {
  78     mLockProcess.detach(); // don't kill it if we crash
  79     delete mXAutoLock;
  80
  81     // Restore X screensaver parameters
  82     XSetScreenSaver(QX11Info::display(), mXTimeout, mXInterval, mXBlanking,
  83                     mXExposures);
  84 }
  85
  86 //---------------------------------------------------------------------------
  87
  88 void SaverEngine::Lock()
  89 {
  90     bool ok = true;
  91     if (mState == Waiting)
  92     {
  93         ok = startLockProcess( ForceLock );
  94 // It takes a while for krunner_lock to start and lock the screen.
  95 // Therefore delay the DBus call until it tells krunner that the locking is in effect.
  96 // This is done only for --forcelock .
  97         if( ok && calledFromDBus())
  98         {
  99             mLockTransactions.append(message().createReply());
 100             setDelayedReply(true);
 101         }
 102     }
 103     else
 104     {
 105         // XXX race condition here
 106         mLockProcess.kill( SIGHUP );
 107     }
 108 }
 109
 110 void SaverEngine::processLockTransactions()
 111 {
 112     QList<QDBusMessage>::ConstIterator it = mLockTransactions.constBegin(),
 113                                       end = mLockTransactions.constEnd();
 114     for ( ; it != end; ++it )
 115     {
 116         QDBusConnection::sessionBus().send(*it);
 117     }
 118     mLockTransactions.clear();
 119 }
 120
 121 void SaverEngine::saverLockReady()
 122 {
 123     if( mState != Preparing )
 124     {
 125         kDebug() << "Got unexpected saverLockReady()";
 126         return;
 127     }
 128     kDebug() << "Saver Lock Ready";
 129     processLockTransactions();
 130     if (m_nr_throttled)
 131         mLockProcess.suspend();
 132 }
 133
 134 void SaverEngine::SimulateUserActivity()
 135 {
 136     if ( mXAutoLock && mState == Waiting )
 137     {
 138         mXAutoLock->resetTrigger();
 139     }
 140 }
 141
 142 //---------------------------------------------------------------------------
 143 bool SaverEngine::save()
 144 {
 145     if (mState == Waiting)
 146     {
 147         return startLockProcess( DefaultLock );
 148     }
 149     return false;
 150 }
 151
 152 //---------------------------------------------------------------------------
 153 bool SaverEngine::quit()
 154 {
 155     if (mState == Saving || mState == Preparing)
 156     {
 157         stopLockProcess();
 158         return true;
 159     }
 160     return false;
 161 }
 162
 163 //---------------------------------------------------------------------------
 164 bool SaverEngine::isEnabled()
 165 {
 166     return mXAutoLock != 0;
 167 }
 168
 169 //---------------------------------------------------------------------------
 170 bool SaverEngine::enable( bool e, bool force )
 171 {
 172     if ( !force && e == isEnabled() )
 173         return true;
 174
 175     // If we aren't in a suitable state, we will not reconfigure.
 176     if (mState != Waiting)
 177         return false;
 178
 179     if (e)
 180     {
 181         if (!mXAutoLock)
 182         {
 183             mXAutoLock = new XAutoLock();
 184             connect(mXAutoLock, SIGNAL(timeout()), SLOT(idleTimeout()));
 185         }
 186
 187         int timeout = KScreenSaverSettings::timeout();
 188         mXAutoLock->setTimeout(timeout);
 189         mXAutoLock->setDPMS(true);
 190 #ifdef NOT_FREAKIN_UGLY
 191         mXAutoLock->changeCornerLockStatus( mLockCornerTopLeft, mLockCornerTopRight, mLockCornerBottomLeft, mLockCornerBottomRight);
 192 #else
 193         xautolock_corners[0] = applyManualSettings(KScreenSaverSettings::actionTopLeft());
 194         xautolock_corners[1] = applyManualSettings(KScreenSaverSettings::actionTopRight());
 195         xautolock_corners[2] = applyManualSettings(KScreenSaverSettings::actionBottomLeft());
 196         xautolock_corners[3] = applyManualSettings(KScreenSaverSettings::actionBottomRight());
 197 #endif
 198
 199         mXAutoLock->start();
 200         kDebug() << "Saver Engine started, timeout: " << timeout;
 201     }
 202     else
 203     {
 204         delete mXAutoLock;
 205         mXAutoLock = 0;
 206         kDebug() << "Saver Engine disabled";
 207     }
 208
 209     return true;
 210 }
 211
 212 //---------------------------------------------------------------------------
 213 bool SaverEngine::isBlanked()
 214 {
 215   return (mState != Waiting);
 216 }
 217
 218 //---------------------------------------------------------------------------
 219 //
 220 // Read and apply configuration.
 221 //
 222 void SaverEngine::configure()
 223 {
 224     // create a new config obj to ensure we read the latest options
 225     KScreenSaverSettings::self()->readConfig();
 226
 227     enable( KScreenSaverSettings::screenSaverEnabled(), true );
 228 }
 229
 230 //---------------------------------------------------------------------------
 231 //
 232 // Start the screen saver.
 233 //
 234 bool SaverEngine::startLockProcess( LockType lock_type )
 235 {
 236     Q_ASSERT(mState == Waiting);
 237
 238     kDebug() << "SaverEngine: starting saver";
 239
 240     QString path = KStandardDirs::findExe( "krunner_lock" );
 241     if( path.isEmpty())
 242     {
 243         kDebug() << "Can't find krunner_lock!";
 244         return false;
 245     }
 246     mLockProcess.clearArguments();
 247     mLockProcess << path;
 248     switch( lock_type )
 249     {
 250     case ForceLock:
 251         mLockProcess << QString( "--forcelock" );
 252         break;
 253     case DontLock:
 254         mLockProcess << QString( "--dontlock" );
 255         break;
 256     default:
 257         break;
 258     }
 259
 260     m_actived_time = time( 0 );
 261     if (mLockProcess.start() == false )
 262     {
 263         kDebug() << "Failed to start krunner_lock!";
 264         m_actived_time = -1;
 265         return false;
 266     }
 267
 268     if (mXAutoLock)
 269     {
 270         mXAutoLock->stop();
 271     }
 272
 273     emit ActiveChanged(true); // DBus signal
 274     mState = Preparing;
 275
 276     return true;
 277 }
 278
 279 //---------------------------------------------------------------------------
 280 //
 281 // Stop the screen saver.
 282 //
 283 void SaverEngine::stopLockProcess()
 284 {
 285     Q_ASSERT(mState != Waiting);
 286     kDebug() << "SaverEngine: stopping lock process";
 287
 288     mLockProcess.kill();
 289 }
 290
 291 void SaverEngine::lockProcessExited()
 292 {
 293     Q_ASSERT(mState != Waiting);
 294     kDebug() << "SaverEngine: lock process exited";
 295
 296     if (mXAutoLock)
 297     {
 298         mXAutoLock->start();
 299     }
 300
 301     processLockTransactions();
 302     emit ActiveChanged(false); // DBus signal
 303     m_actived_time = -1;
 304     mState = Waiting;
 305 }
 306
 307 //---------------------------------------------------------------------------
 308 //
 309 // XAutoLock has detected the required idle time.
 310 //
 311 void SaverEngine::idleTimeout()
 312 {
 313     startLockProcess( DefaultLock );
 314 }
 315
 316 xautolock_corner_t SaverEngine::applyManualSettings(int action)
 317 {
 318     if (action == 0)
 319     {
 320         kDebug() << "no lock";
 321         return ca_nothing;
 322     }
 323     else if (action == 1)
 324     {
 325         kDebug() << "lock screen";
 326         return ca_forceLock;
 327     }
 328     else if (action == 2)
 329     {
 330         kDebug() << "prevent lock";
 331         return ca_dontLock;
 332     }
 333     else
 334     {
 335         kDebug() << "no lock nothing";
 336         return ca_nothing;
 337     }
 338 }
 339
 340 uint SaverEngine::GetSessionIdleTime()
 341 {
 342     return mXAutoLock->idleTime();
 343 }
 344
 345 uint SaverEngine::GetActiveTime()
 346 {
 347     if ( m_actived_time == -1 )
 348         return 0;
 349     return time( 0 ) - m_actived_time;
 350 }
 351
 352 bool SaverEngine::GetActive()
 353 {
 354     return ( mState != Waiting );
 355 }
 356
 357 bool SaverEngine::SetActive(bool state)
 358 {
 359     if ( state )
 360         return save();
 361     else
 362         return quit();
 363 }
 364
 365 uint SaverEngine::Inhibit(const QString &/*application_name*/, const QString &/*reason*/)
 366 {
 367     ScreenSaverRequest sr;
 368 //     sr.appname = application_name;
 369 //     sr.reasongiven = reason;
 370     sr.cookie = m_next_cookie++;
 371     sr.dbusid = message().service();
 372     sr.type = ScreenSaverRequest::Inhibit;
 373     m_requests.append( sr );
 374     m_nr_inhibited++;
 375     enable( false );
 376     return sr.cookie;
 377 }
 378
 379 void SaverEngine::UnInhibit(uint cookie)
 380 {
 381     QMutableListIterator<ScreenSaverRequest> it( m_requests );
 382     while ( it.hasNext() )
 383     {
 384         if ( it.next().cookie == cookie ) {
 385             it.remove();
 386             if ( !--m_nr_inhibited )
 387                 enable( true );
 388         }
 389     }
 390 }
 391
 392 uint SaverEngine::Throttle(const QString &/*application_name*/, const QString &/*reason*/)
 393 {
 394     ScreenSaverRequest sr;
 395 //     sr.appname = application_name;
 396 //     sr.reasongiven = reason;
 397     sr.cookie = m_next_cookie++;
 398     sr.type = ScreenSaverRequest::Throttle;
 399     sr.dbusid = message().service();
 400     m_requests.append( sr );
 401     m_nr_throttled++;
 402     if (mLockProcess.isRunning())
 403         mLockProcess.suspend();
 404     return sr.cookie;
 405 }
 406
 407 void SaverEngine::UnThrottle(uint cookie)
 408 {
 409     QMutableListIterator<ScreenSaverRequest> it( m_requests );
 410     while ( it.hasNext() )
 411     {
 412         if ( it.next().cookie == cookie ) {
 413             it.remove();
 414             if ( !--m_nr_throttled )
 415                 if (mLockProcess.isRunning())
 416                     mLockProcess.resume();
 417         }
 418     }
 419 }
 420
 421 void SaverEngine::serviceOwnerChanged(const QString& name, const QString &, const QString &newOwner)
 422 {
 423     if ( !newOwner.isEmpty() ) // looking for deaths
 424         return;
 425
 426     QListIterator<ScreenSaverRequest> it( m_requests );
 427     while ( it.hasNext() )
 428     {
 429         const ScreenSaverRequest &r = it.next();
 430         if ( r.dbusid == name )
 431         {
 432             if ( r.type == ScreenSaverRequest::Throttle )
 433                 UnThrottle( r.cookie );
 434             else
 435                 UnInhibit( r.cookie );
 436         }
 437     }
 438 }
 439
 440 #include "saverengine.moc"
 441
 442