KUtils

kidletime.cpp

00001 /* This file is part of the KDE libraries
00002    Copyright (C) 2009 Dario Freddi <drf at kde.org>
00003 
00004    This library is free software; you can redistribute it and/or
00005    modify it under the terms of the GNU Library General Public
00006    License version 2 as published by the Free Software Foundation.
00007 
00008    This library is distributed in the hope that it will be useful,
00009    but WITHOUT ANY WARRANTY; without even the implied warranty of
00010    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00011    Library General Public License for more details.
00012 
00013    You should have received a copy of the GNU Library General Public License
00014    along with this library; see the file COPYING.LIB.  If not, write to
00015    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00016    Boston, MA 02110-1301, USA.
00017 */
00018 
00019 #include "kidletime.h"
00020 
00021 #include <config-kidletime.h>
00022 
00023 #ifdef Q_WS_X11
00024 #ifdef HAVE_XSCREENSAVER
00025 #include "xscreensaverbasedpoller.h"
00026 #endif
00027 #ifdef HAVE_XSYNC
00028 #include "xsyncbasedpoller.h"
00029 #endif
00030 #else
00031 #ifdef Q_WS_MAC
00032 #include "macpoller.h"
00033 #else
00034 #include "windowspoller.h"
00035 #endif
00036 #endif
00037 
00038 #include <kglobal.h>
00039 #include <QPointer>
00040 
00041 class KIdleTimeHelper
00042 {
00043 public:
00044     KIdleTimeHelper() : q(0) {}
00045     ~KIdleTimeHelper() {
00046         delete q;
00047     }
00048     KIdleTime *q;
00049 };
00050 
00051 K_GLOBAL_STATIC(KIdleTimeHelper, s_globalKIdleTime)
00052 
00053 KIdleTime *KIdleTime::instance()
00054 {
00055     if (!s_globalKIdleTime->q) {
00056         new KIdleTime;
00057     }
00058 
00059     return s_globalKIdleTime->q;
00060 }
00061 
00062 class KIdleTimePrivate
00063 {
00064 public:
00065     KIdleTimePrivate() : catchResume(false), currentId(0) {}
00066 
00067     Q_DECLARE_PUBLIC(KIdleTime)
00068     KIdleTime *q_ptr;
00069 
00070     void loadSystem();
00071     void unloadCurrentSystem();
00072     void _k_resumingFromIdle();
00073     void _k_timeoutReached(int msec);
00074 
00075     QPointer<AbstractSystemPoller> poller;
00076     bool catchResume;
00077 
00078     int currentId;
00079     QHash<int, int> associations;
00080 };
00081 
00082 KIdleTime::KIdleTime()
00083         : QObject(0)
00084         , d_ptr(new KIdleTimePrivate())
00085 {
00086     Q_ASSERT(!s_globalKIdleTime->q);
00087     s_globalKIdleTime->q = this;
00088 
00089     d_ptr->q_ptr = this;
00090     d_ptr->loadSystem();
00091 
00092     connect(d_ptr->poller, SIGNAL(resumingFromIdle()), this, SLOT(_k_resumingFromIdle()));
00093     connect(d_ptr->poller, SIGNAL(timeoutReached(int)), this, SLOT(_k_timeoutReached(int)));
00094 }
00095 
00096 KIdleTime::~KIdleTime()
00097 {
00098     Q_D(KIdleTime);
00099     d->unloadCurrentSystem();
00100 }
00101 
00102 void KIdleTime::catchNextResumeEvent()
00103 {
00104     Q_D(KIdleTime);
00105 
00106     if (!d->catchResume) {
00107         d->catchResume = true;
00108         d->poller->catchIdleEvent();
00109     }
00110 }
00111 
00112 void KIdleTime::stopCatchingResumeEvent()
00113 {
00114     Q_D(KIdleTime);
00115 
00116     if (d->catchResume) {
00117         d->catchResume = false;
00118         d->poller->stopCatchingIdleEvents();
00119     }
00120 }
00121 
00122 int KIdleTime::addIdleTimeout(int msec)
00123 {
00124     Q_D(KIdleTime);
00125 
00126     d->poller->addTimeout(msec);
00127 
00128     ++d->currentId;
00129     d->associations[d->currentId] = msec;
00130 
00131     return d->currentId;
00132 }
00133 
00134 void KIdleTime::removeIdleTimeout(int identifier)
00135 {
00136     Q_D(KIdleTime);
00137 
00138     if (!d->associations.contains(identifier)) {
00139         return;
00140     }
00141 
00142     int msec = d->associations[identifier];
00143 
00144     d->associations.remove(identifier);
00145 
00146     if (!d->associations.values().contains(msec)) {
00147         d->poller->removeTimeout(msec);
00148     }
00149 }
00150 
00151 void KIdleTime::removeAllIdleTimeouts()
00152 {
00153     Q_D(KIdleTime);
00154 
00155     foreach(int i, d->poller->timeouts()) {
00156         removeIdleTimeout(i);
00157     }
00158 }
00159 
00160 void KIdleTimePrivate::loadSystem()
00161 {
00162     if (poller) {
00163         unloadCurrentSystem();
00164     }
00165 
00166     // Priority order
00167 
00168 #ifdef Q_WS_X11
00169 #ifdef HAVE_XSYNC
00170 #ifdef HAVE_XSCREENSAVER
00171     if (XSyncBasedPoller::instance()->isAvailable()) {
00172         XSyncBasedPoller::instance()->setUpPoller();
00173         poller = XSyncBasedPoller::instance();
00174     } else {
00175         poller = new XScreensaverBasedPoller();
00176         poller->setUpPoller();
00177     }
00178 #else
00179     XSyncBasedPoller::instance()->setUpPoller();
00180     poller = XSyncBasedPoller::instance();
00181 #endif
00182 #else
00183 #ifdef HAVE_XSCREENSAVER
00184     poller = new XScreensaverBasedPoller();
00185     poller->setUpPoller();
00186 #endif
00187 #endif
00188 #else
00189 #ifdef Q_WS_MAC
00190     poller = new MacPoller();
00191     poller->setUpPoller();
00192 #else
00193     poller = new WindowsPoller();
00194     poller->setUpPoller();
00195 #endif
00196 #endif
00197 }
00198 
00199 void KIdleTimePrivate::unloadCurrentSystem()
00200 {
00201     if (poller) {
00202         poller->unloadPoller();
00203 #ifdef Q_WS_X11
00204         if (qobject_cast<XSyncBasedPoller*>(poller) == 0) {
00205 #endif
00206             poller->deleteLater();
00207 #ifdef Q_WS_X11
00208         }
00209 #endif
00210     }
00211 }
00212 
00213 void KIdleTimePrivate::_k_resumingFromIdle()
00214 {
00215     Q_Q(KIdleTime);
00216 
00217     if (catchResume) {
00218         emit q->resumingFromIdle();
00219         catchResume = false;
00220     }
00221 }
00222 
00223 void KIdleTimePrivate::_k_timeoutReached(int msec)
00224 {
00225     Q_Q(KIdleTime);
00226 
00227     if (associations.values().contains(msec)) {
00228         foreach (int key, associations.keys(msec)) {
00229             emit q->timeoutReached(key);
00230             emit q->timeoutReached(key, msec);
00231         }
00232     }
00233 }
00234 
00235 void KIdleTime::simulateUserActivity()
00236 {
00237     Q_D(KIdleTime);
00238 
00239     d->poller->simulateUserActivity();
00240 }
00241 
00242 int KIdleTime::idleTime() const
00243 {
00244     Q_D(const KIdleTime);
00245 
00246     return d->poller->forcePollRequest();
00247 }
00248 
00249 QHash<int, int> KIdleTime::idleTimeouts() const
00250 {
00251     Q_D(const KIdleTime);
00252 
00253     return d->associations;
00254 }
00255 
00256 #include "kidletime.moc"
KUtils

kidletime.cpp

KUtils

kdelibs
