tdecore

tderootsystemdevice.cpp

00001 /* This file is part of the TDE libraries
00002    Copyright (C) 2012 Timothy Pearson <kb9vqf@pearsoncomputing.net>
00003              (C) 2013 Golubev Alexander <fatzer2@gmail.com>
00004 
00005    This library is free software; you can redistribute it and/or
00006    modify it under the terms of the GNU Library General Public
00007    License version 2 as published by the Free Software Foundation.
00008 
00009    This library is distributed in the hope that it will be useful,
00010    but WITHOUT ANY WARRANTY; without even the implied warranty of
00011    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012    Library General Public License for more details.
00013 
00014    You should have received a copy of the GNU Library General Public License
00015    along with this library; see the file COPYING.LIB.  If not, write to
00016    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00017    Boston, MA 02110-1301, USA.
00018 */
00019 
00020 #include "tderootsystemdevice.h"
00021 #include "tdestoragedevice.h"
00022 
00023 #include <unistd.h>
00024 
00025 #include <tqfile.h>
00026 
00027 #include <dcopclient.h>
00028 #include "tdeglobal.h"
00029 #include "tdeconfig.h"
00030 #include "tdeapplication.h"
00031 #include "kstandarddirs.h"
00032 
00033 #include "config.h"
00034 
00035 #if defined(WITH_TDEHWLIB_DAEMONS) || defined(WITH_UPOWER) || defined(WITH_DEVKITPOWER) || defined(WITH_HAL) || defined(WITH_CONSOLEKIT)
00036     #include <tqdbusdata.h>
00037     #include <tqdbusmessage.h>
00038     #include <tqdbusproxy.h>
00039     #include <tqdbusvariant.h>
00040     #include <tqdbusconnection.h>
00041 #endif // defined(WITH_TDEHWLIB_DAEMONS) || defined(WITH_UPOWER) || defined(WITH_DEVKITPOWER) || defined(WITH_HAL) || defined(WITH_CONSOLEKIT)
00042 
00043 TDERootSystemDevice::TDERootSystemDevice(TDEGenericDeviceType::TDEGenericDeviceType dt, TQString dn) : TDEGenericDevice(dt, dn) {
00044     m_hibernationSpace = -1;
00045 }
00046 
00047 TDERootSystemDevice::~TDERootSystemDevice() {
00048 }
00049 
00050 TDESystemFormFactor::TDESystemFormFactor TDERootSystemDevice::formFactor() {
00051     return m_formFactor;
00052 }
00053 
00054 void TDERootSystemDevice::internalSetFormFactor(TDESystemFormFactor::TDESystemFormFactor ff) {
00055     m_formFactor = ff;
00056 }
00057 
00058 TDESystemPowerStateList TDERootSystemDevice::powerStates() {
00059     return m_powerStates;
00060 }
00061 
00062 void TDERootSystemDevice::internalSetPowerStates(TDESystemPowerStateList ps) {
00063     m_powerStates = ps;
00064 }
00065 
00066 TDESystemHibernationMethodList TDERootSystemDevice::hibernationMethods() {
00067     return m_hibernationMethods;
00068 }
00069 
00070 void TDERootSystemDevice::internalSetHibernationMethods(TDESystemHibernationMethodList hm) {
00071     m_hibernationMethods = hm;
00072 }
00073 
00074 TDESystemHibernationMethod::TDESystemHibernationMethod TDERootSystemDevice::hibernationMethod() {
00075     return m_hibernationMethod;
00076 }
00077 
00078 void TDERootSystemDevice::internalSetHibernationMethod(TDESystemHibernationMethod::TDESystemHibernationMethod hm) {
00079     m_hibernationMethod = hm;
00080 }
00081 
00082 unsigned long TDERootSystemDevice::diskSpaceNeededForHibernation() {
00083     return m_hibernationSpace;
00084 }
00085 
00086 void TDERootSystemDevice::internalSetDiskSpaceNeededForHibernation(unsigned long sz) {
00087     m_hibernationSpace = sz;
00088 }
00089 
00090 bool TDERootSystemDevice::canSetHibernationMethod() {
00091     TQString hibernationnode = "/sys/power/disk";
00092     int rval = access (hibernationnode.ascii(), W_OK);
00093     if (rval == 0) {
00094         return TRUE;
00095     }
00096 
00097 #ifdef WITH_TDEHWLIB_DAEMONS
00098     {
00099         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00100         if (dbusConn.isConnected()) {
00101             // can set hibernation method?
00102             TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00103                         "org.trinitydesktop.hardwarecontrol",
00104                         "/org/trinitydesktop/hardwarecontrol",
00105                         "org.trinitydesktop.hardwarecontrol.Power",
00106                         "CanSetHibernationMethod");
00107             TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00108             if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00109                 return reply[0].toBool();
00110             }
00111         }
00112     }
00113 #endif // WITH_TDEHWLIB_DAEMONS
00114 
00115     return FALSE;
00116 }
00117 
00118 bool TDERootSystemDevice::canStandby() {
00119     TQString statenode = "/sys/power/state";
00120     int rval = access (statenode.ascii(), W_OK);
00121     if (rval == 0) {
00122         if (powerStates().contains(TDESystemPowerState::Standby)) {
00123             return TRUE;
00124         }
00125         else {
00126             return FALSE;
00127         }
00128     }
00129 
00130 #ifdef WITH_TDEHWLIB_DAEMONS
00131     {
00132         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00133         if (dbusConn.isConnected()) {
00134             // can standby?
00135             TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00136                         "org.trinitydesktop.hardwarecontrol",
00137                         "/org/trinitydesktop/hardwarecontrol",
00138                         "org.trinitydesktop.hardwarecontrol.Power",
00139                         "CanStandby");
00140             TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00141             if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00142                 return reply[0].toBool();
00143             }
00144         }
00145     }
00146 #endif // WITH_TDEHWLIB_DAEMONS
00147 
00148     return FALSE;
00149 }
00150 
00151 bool TDERootSystemDevice::canFreeze() {
00152     TQString statenode = "/sys/power/state";
00153     int rval = access (statenode.ascii(), W_OK);
00154     if (rval == 0) {
00155         if (powerStates().contains(TDESystemPowerState::Freeze)) {
00156             return TRUE;
00157         }
00158         else {
00159             return FALSE;
00160         }
00161     }
00162 
00163 #ifdef WITH_TDEHWLIB_DAEMONS
00164     {
00165         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00166         if (dbusConn.isConnected()) {
00167             // can freeze?
00168             TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00169                         "org.trinitydesktop.hardwarecontrol",
00170                         "/org/trinitydesktop/hardwarecontrol",
00171                         "org.trinitydesktop.hardwarecontrol.Power",
00172                         "CanFreeze");
00173             TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00174             if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00175                 return reply[0].toBool();
00176             }
00177         }
00178     }
00179 #endif // WITH_TDEHWLIB_DAEMONS
00180 
00181     return FALSE;
00182 }
00183 
00184 bool TDERootSystemDevice::canSuspend() {
00185     TQString statenode = "/sys/power/state";
00186     int rval = access (statenode.ascii(), W_OK);
00187     if (rval == 0) {
00188         if (powerStates().contains(TDESystemPowerState::Suspend)) {
00189             return TRUE;
00190         }
00191         else {
00192             return FALSE;
00193         }
00194     }
00195 
00196 #ifdef WITH_LOGINDPOWER
00197     {
00198         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00199         if (dbusConn.isConnected()) {
00200             // can suspend?
00201             TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00202                         "org.freedesktop.login1",
00203                         "/org/freedesktop/login1",
00204                         "org.freedesktop.login1.Manager",
00205                         "CanSuspend");
00206             TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00207             if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00208                 return (reply[0].toString() == "yes");
00209             }
00210         }
00211     }
00212 #endif // WITH_LOGINDPOWER
00213 
00214 #ifdef WITH_UPOWER
00215     {
00216         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00217         if (dbusConn.isConnected()) {
00218             TQT_DBusProxy upowerProperties("org.freedesktop.UPower", "/org/freedesktop/UPower", "org.freedesktop.DBus.Properties", dbusConn);
00219             if (upowerProperties.canSend()) {
00220                 // can suspend?
00221                 TQValueList<TQT_DBusData> params;
00222                 params << TQT_DBusData::fromString(upowerProperties.interface()) << TQT_DBusData::fromString("CanSuspend");
00223                 TQT_DBusMessage reply = upowerProperties.sendWithReply("Get", params);
00224                 if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00225                     return reply[0].toVariant().value.toBool();
00226                 }
00227             }
00228         }
00229     }
00230 #endif// WITH_UPOWER
00231 
00232 #ifdef WITH_DEVKITPOWER
00233     {
00234         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00235         if (dbusConn.isConnected()) {
00236             TQT_DBusProxy devkitpowerProperties("org.freedesktop.DeviceKit.Power", "/org/freedesktop/DeviceKit/Power", "org.freedesktop.DBus.Properties", dbusConn);
00237             if (devkitpowerProperties.canSend()) {
00238                 // can suspend?
00239                 TQValueList<TQT_DBusData> params;
00240                 params << TQT_DBusData::fromString(devkitpowerProperties.interface()) << TQT_DBusData::fromString("CanSuspend");
00241                 TQT_DBusMessage reply = devkitpowerProperties.sendWithReply("Get", params);
00242                 if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00243                     return reply[0].toVariant().value.toBool();
00244                 }
00245             }
00246         }
00247     }
00248 #endif// WITH_DEVKITPOWER
00249 
00250 #ifdef WITH_HAL
00251     {
00252         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00253         if (dbusConn.isConnected()) {
00254             TQT_DBusProxy halProperties("org.freedesktop.Hal", "/org/freedesktop/Hal/devices/computer", "org.freedesktop.Hal.Device", dbusConn);
00255             if (halProperties.canSend()) {
00256                 // can suspend?
00257                 TQValueList<TQT_DBusData> params;
00258                 TQT_DBusMessage reply;
00259                 params.clear();
00260                 params << TQT_DBusData::fromString("power_management.can_suspend");
00261                 reply = halProperties.sendWithReply("GetPropertyBoolean", params);
00262                 if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00263                     return reply[0].toBool();
00264                 }
00265                 params.clear();
00266                 params << TQT_DBusData::fromString("power_management.can_suspend_to_ram");
00267                 reply = halProperties.sendWithReply("GetPropertyBoolean", params);
00268                 if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00269                     return reply[0].toBool();
00270                 }
00271             }
00272         }
00273     }
00274 #endif // WITH_HAL
00275 
00276 #ifdef WITH_TDEHWLIB_DAEMONS
00277     {
00278         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00279         if (dbusConn.isConnected()) {
00280             // can suspend?
00281             TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00282                         "org.trinitydesktop.hardwarecontrol",
00283                         "/org/trinitydesktop/hardwarecontrol",
00284                         "org.trinitydesktop.hardwarecontrol.Power",
00285                         "CanSuspend");
00286             TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00287             if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00288                 return reply[0].toBool();
00289             }
00290         }
00291     }
00292 #endif // WITH_TDEHWLIB_DAEMONS
00293 
00294     return FALSE;
00295 }
00296 
00297 bool TDERootSystemDevice::canHibernate() {
00298     TQString statenode = "/sys/power/state";
00299     TQString disknode  = "/sys/power/disk";
00300     int state_rval = access (statenode.ascii(), W_OK);
00301     int disk_rval  = access (disknode.ascii(), W_OK);
00302     if (state_rval == 0 && disk_rval == 0) {
00303         if (powerStates().contains(TDESystemPowerState::Hibernate)) {
00304             return TRUE;
00305         }
00306         else {
00307             return FALSE;
00308         }
00309     }
00310 
00311 #ifdef WITH_LOGINDPOWER
00312     {
00313         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00314         if (dbusConn.isConnected()) {
00315             // can hibernate?
00316             TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00317                         "org.freedesktop.login1",
00318                         "/org/freedesktop/login1",
00319                         "org.freedesktop.login1.Manager",
00320                         "CanHibernate");
00321             TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00322             if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00323                 return (reply[0].toString() == "yes");
00324             }
00325         }
00326     }
00327 #endif // WITH_LOGINDPOWER
00328 
00329 #ifdef WITH_UPOWER
00330     {
00331         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00332         if (dbusConn.isConnected()) {
00333             TQT_DBusProxy upowerProperties("org.freedesktop.UPower", "/org/freedesktop/UPower", "org.freedesktop.DBus.Properties", dbusConn);
00334             if (upowerProperties.canSend()) {
00335                 // can hibernate?
00336                 TQValueList<TQT_DBusData> params;
00337                 params << TQT_DBusData::fromString(upowerProperties.interface()) << TQT_DBusData::fromString("CanHibernate");
00338                 TQT_DBusMessage reply = upowerProperties.sendWithReply("Get", params);
00339                 if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00340                     return reply[0].toVariant().value.toBool();
00341                 }
00342             }
00343         }
00344     }
00345 #endif// WITH_UPOWER
00346 
00347 #ifdef WITH_DEVKITPOWER
00348     {
00349         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00350         if (dbusConn.isConnected()) {
00351             TQT_DBusProxy devkitpowerProperties("org.freedesktop.DeviceKit.Power", "/org/freedesktop/DeviceKit/Power", "org.freedesktop.DBus.Properties", dbusConn);
00352             if (devkitpowerProperties.canSend()) {
00353                 // can hibernate?
00354                 TQValueList<TQT_DBusData> params;
00355                 params << TQT_DBusData::fromString(devkitpowerProperties.interface()) << TQT_DBusData::fromString("CanHibernate");
00356                 TQT_DBusMessage reply = devkitpowerProperties.sendWithReply("Get", params);
00357                 if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00358                     return reply[0].toVariant().value.toBool();
00359                 }
00360             }
00361         }
00362     }
00363 #endif// WITH_DEVKITPOWER
00364 
00365 #ifdef WITH_HAL
00366     {
00367         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00368         if (dbusConn.isConnected()) {
00369             TQT_DBusProxy halProperties("org.freedesktop.Hal", "/org/freedesktop/Hal/devices/computer", "org.freedesktop.Hal.Device", dbusConn);
00370             if (halProperties.canSend()) {
00371                 // can hibernate?
00372                 TQValueList<TQT_DBusData> params;
00373                 TQT_DBusMessage reply;
00374                 params.clear();
00375                 params << TQT_DBusData::fromString("power_management.can_hibernate");
00376                 reply = halProperties.sendWithReply("GetPropertyBoolean", params);
00377                 if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00378                     return reply[0].toBool();
00379                 }
00380                 params.clear();
00381                 params << TQT_DBusData::fromString("power_management.can_suspend_to_disk");
00382                 reply = halProperties.sendWithReply("GetPropertyBoolean", params);
00383                 if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00384                     return reply[0].toBool();
00385                 }
00386             }
00387         }
00388     }
00389 #endif // WITH_HAL
00390 
00391 #ifdef WITH_TDEHWLIB_DAEMONS
00392     {
00393         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00394         if (dbusConn.isConnected()) {
00395             // can hibernate?
00396             TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00397                         "org.trinitydesktop.hardwarecontrol",
00398                         "/org/trinitydesktop/hardwarecontrol",
00399                         "org.trinitydesktop.hardwarecontrol.Power",
00400                         "CanHibernate");
00401             TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00402             if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00403                 return reply[0].toBool();
00404             }
00405         }
00406     }
00407 #endif // WITH_TDEHWLIB_DAEMONS
00408 
00409     return FALSE;
00410 }
00411 
00412 bool TDERootSystemDevice::canHybridSuspend() {
00413     TQString statenode = "/sys/power/state";
00414     TQString disknode  = "/sys/power/disk";
00415     int state_rval = access (statenode.ascii(), W_OK);
00416     int disk_rval  = access (disknode.ascii(), W_OK);
00417     if (state_rval == 0 && disk_rval == 0) {
00418         if (powerStates().contains(TDESystemPowerState::HybridSuspend)) {
00419             return TRUE;
00420         }
00421         else {
00422             return FALSE;
00423         }
00424     }
00425 
00426 #ifdef WITH_LOGINDPOWER
00427     {
00428         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00429         if (dbusConn.isConnected()) {
00430             // can hybrid suspend?
00431             TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00432                         "org.freedesktop.login1",
00433                         "/org/freedesktop/login1",
00434                         "org.freedesktop.login1.Manager",
00435                         "CanHybridSleep");
00436             TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00437             if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00438                 return (reply[0].toString() == "yes");
00439             }
00440         }
00441     }
00442 #endif // WITH_LOGINDPOWER
00443 
00444     // No support "hybrid suspend" in org.freedesktop.UPower
00445     // No support "hybrid suspend" in org.freedesktop.DeviceKit.Power
00446 
00447 #ifdef WITH_HAL
00448     {
00449         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00450         if (dbusConn.isConnected()) {
00451             TQT_DBusProxy halProperties("org.freedesktop.Hal", "/org/freedesktop/Hal/devices/computer", "org.freedesktop.Hal.Device", dbusConn);
00452             if (halProperties.canSend()) {
00453                 // can hybrid suspend?
00454                 TQValueList<TQT_DBusData> params;
00455                 TQT_DBusMessage reply;
00456                 params.clear();
00457                 params << TQT_DBusData::fromString("power_management.can_suspend_hybrid");
00458                 reply = halProperties.sendWithReply("GetPropertyBoolean", params);
00459                 if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00460                     return reply[0].toBool();
00461                 }
00462             }
00463         }
00464     }
00465 #endif // WITH_HAL
00466 
00467 #ifdef WITH_TDEHWLIB_DAEMONS
00468     {
00469         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00470         if (dbusConn.isConnected()) {
00471             // can hybrid suspend?
00472             TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00473                         "org.trinitydesktop.hardwarecontrol",
00474                         "/org/trinitydesktop/hardwarecontrol",
00475                         "org.trinitydesktop.hardwarecontrol.Power",
00476                         "CanHybridSuspend");
00477             TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00478             if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00479                 return reply[0].toBool();
00480             }
00481         }
00482     }
00483 #endif // WITH_TDEHWLIB_DAEMONS
00484 
00485     return FALSE;
00486 }
00487 
00488 bool TDERootSystemDevice::canPowerOff() {
00489     TDEConfig config("ksmserverrc", true);
00490     config.setGroup("General" );
00491     if (!config.readBoolEntry( "offerShutdown", true )) {
00492         return FALSE;
00493     }
00494 
00495 #ifdef WITH_LOGINDPOWER
00496     {
00497         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00498         if (dbusConn.isConnected()) {
00499             // can power off?
00500             TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00501                         "org.freedesktop.login1",
00502                         "/org/freedesktop/login1",
00503                         "org.freedesktop.login1.Manager",
00504                         "CanPowerOff");
00505             TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00506             if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00507                 return (reply[0].toString() == "yes");
00508             }
00509         }
00510     }
00511 #endif // WITH_LOGINDPOWER
00512 
00513 #ifdef WITH_CONSOLEKIT
00514     {
00515         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00516         if (dbusConn.isConnected()) {
00517             // can power off?
00518             TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00519                         "org.freedesktop.ConsoleKit",
00520                         "/org/freedesktop/ConsoleKit/Manager",
00521                         "org.freedesktop.ConsoleKit.Manager",
00522                         "CanStop");
00523             TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00524             if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00525                 return reply[0].toBool();
00526             }
00527         }
00528     }
00529 #endif // WITH_CONSOLEKIT
00530 
00531     // FIXME
00532     // Can we power down this system?
00533     // This should probably be checked via DCOP and therefore interface with TDM
00534     // if ( DM().canShutdown() ) {
00535     //  return TRUE;
00536     // }
00537     return TRUE;
00538 }
00539 
00540 bool TDERootSystemDevice::canReboot() {
00541     TDEConfig config("ksmserverrc", true);
00542     config.setGroup("General" );
00543     if (!config.readBoolEntry( "offerShutdown", true )) {
00544         return FALSE;
00545     }
00546 
00547 #ifdef WITH_LOGINDPOWER
00548     {
00549         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00550         if (dbusConn.isConnected()) {
00551             // can reboot?
00552             TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00553                         "org.freedesktop.login1",
00554                         "/org/freedesktop/login1",
00555                         "org.freedesktop.login1.Manager",
00556                         "CanReboot");
00557             TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00558             if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00559                 return (reply[0].toString() == "yes");
00560             }
00561         }
00562     }
00563 #endif // WITH_LOGINDPOWER
00564 
00565 #ifdef WITH_CONSOLEKIT
00566     {
00567         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00568         if (dbusConn.isConnected()) {
00569             // can reboot?
00570             TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00571                         "org.freedesktop.ConsoleKit",
00572                         "/org/freedesktop/ConsoleKit/Manager",
00573                         "org.freedesktop.ConsoleKit.Manager",
00574                         "CanRestart");
00575             TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00576             if (reply.type() == TQT_DBusMessage::ReplyMessage && reply.count() == 1) {
00577                 return reply[0].toBool();
00578             }
00579         }
00580     }
00581 #endif // WITH_CONSOLEKIT
00582 
00583     // FIXME
00584     // Can we power down this system?
00585     // This should probably be checked via DCOP and therefore interface with TDM
00586     // if ( DM().canShutdown() ) {
00587     //  return TRUE;
00588     // }
00589     return TRUE;
00590 }
00591 
00592 void TDERootSystemDevice::setHibernationMethod(TDESystemHibernationMethod::TDESystemHibernationMethod hm) {
00593     TQString hibernationnode = "/sys/power/disk";
00594     TQFile file( hibernationnode );
00595     if ( file.open( IO_WriteOnly ) ) {
00596         TQString hibernationCommand;
00597         if (hm == TDESystemHibernationMethod::Platform) {
00598             hibernationCommand = "platform";
00599         }
00600         else if (hm == TDESystemHibernationMethod::Shutdown) {
00601             hibernationCommand = "shutdown";
00602         }
00603         else if (hm == TDESystemHibernationMethod::Reboot) {
00604             hibernationCommand = "reboot";
00605         }
00606         else if (hm == TDESystemHibernationMethod::TestProc) {
00607             hibernationCommand = "testproc";
00608         }
00609         else if (hm == TDESystemHibernationMethod::Test) {
00610             hibernationCommand = "test";
00611         }
00612         else if (hm == TDESystemHibernationMethod::Suspend) {
00613             hibernationCommand = "suspend";
00614         }
00615         TQTextStream stream( &file );
00616         stream << hibernationCommand;
00617         file.close();
00618         return;
00619     }
00620 
00621 #ifdef WITH_TDEHWLIB_DAEMONS
00622     {
00623         TQT_DBusConnection dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00624         if (dbusConn.isConnected()) {
00625             TQT_DBusProxy hardwareControl("org.trinitydesktop.hardwarecontrol", "/org/trinitydesktop/hardwarecontrol", "org.trinitydesktop.hardwarecontrol.Power", dbusConn);
00626             if (hardwareControl.canSend()) {
00627                 // set hibernation method
00628                 TQValueList<TQT_DBusData> params;
00629                 TQString hibernationCommand;
00630                 if (hm == TDESystemHibernationMethod::Platform) {
00631                     hibernationCommand = "platform";
00632                 }
00633                 else if (hm == TDESystemHibernationMethod::Shutdown) {
00634                     hibernationCommand = "shutdown";
00635                 }
00636                 else if (hm == TDESystemHibernationMethod::Reboot) {
00637                     hibernationCommand = "reboot";
00638                 }
00639                 else if (hm == TDESystemHibernationMethod::TestProc) {
00640                     hibernationCommand = "testproc";
00641                 }
00642                 else if (hm == TDESystemHibernationMethod::Test) {
00643                     hibernationCommand = "test";
00644                 }
00645                 else if (hm == TDESystemHibernationMethod::Suspend) {
00646                     hibernationCommand = "suspend";
00647                 }
00648                 params << TQT_DBusData::fromString(hibernationCommand);
00649                 TQT_DBusMessage reply = hardwareControl.sendWithReply("SetHibernationMethod", params);
00650                 if (reply.type() == TQT_DBusMessage::ReplyMessage) {
00651                     return;
00652                 }
00653             }
00654         }
00655     }
00656 #endif // WITH_TDEHWLIB_DAEMONS
00657 
00658 }
00659 
00660 bool TDERootSystemDevice::setPowerState(TDESystemPowerState::TDESystemPowerState ps) {
00661     if ((ps == TDESystemPowerState::Freeze)  || (ps == TDESystemPowerState::Standby)   ||  
00662         (ps == TDESystemPowerState::Suspend) || (ps == TDESystemPowerState::Hibernate) ||
00663         (ps == TDESystemPowerState::HybridSuspend)) {
00664         TQString statenode = "/sys/power/state";
00665         TQString disknode  = "/sys/power/disk";
00666         TQFile statefile( statenode );
00667         TQFile diskfile( disknode );
00668         if ( statefile.open( IO_WriteOnly ) &&
00669              ((ps != TDESystemPowerState::Hibernate && ps != TDESystemPowerState::HybridSuspend) || 
00670                diskfile.open( IO_WriteOnly )) ) {
00671             TQString powerCommand;
00672             if (ps == TDESystemPowerState::Freeze) {
00673                 powerCommand = "freeze";
00674             }
00675             else if (ps == TDESystemPowerState::Standby) {
00676                 powerCommand = "standby";
00677             }
00678             else if (ps == TDESystemPowerState::Suspend) {
00679                 powerCommand = "mem";
00680             }
00681             else if (ps == TDESystemPowerState::Hibernate) {
00682                 powerCommand = "disk";
00683                 TQTextStream diskstream( &diskfile );
00684                 diskstream << "platform";
00685                 diskfile.close();
00686             }
00687             else if (ps == TDESystemPowerState::HybridSuspend) {
00688                 powerCommand = "disk";
00689                 TQTextStream diskstream( &diskfile );
00690                 diskstream << "suspend";
00691                 diskfile.close();
00692             }
00693             TQTextStream statestream( &statefile );
00694             statestream << powerCommand;
00695             statefile.close();
00696             return true;
00697         }
00698 
00699 #ifdef WITH_LOGINDPOWER
00700         {
00701             // No support for "freeze" and "standby" in org.freedesktop.login1
00702             TQT_DBusConnection dbusConn;
00703             dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00704             if ( dbusConn.isConnected() ) {
00705                 TQT_DBusProxy logindProxy("org.freedesktop.login1", "/org/freedesktop/login1",
00706                                           "org.freedesktop.login1.Manager", dbusConn);
00707                 TQValueList<TQT_DBusData> params;
00708                 params << TQT_DBusData::fromBool(true);
00709                 if (logindProxy.canSend()) {
00710                     if (ps == TDESystemPowerState::Suspend) {
00711                         TQT_DBusMessage reply = logindProxy.sendWithReply("Suspend", params);
00712                         if (reply.type() == TQT_DBusMessage::ReplyMessage) {
00713                             return true;
00714                         }
00715                     }
00716                     else if (ps == TDESystemPowerState::Hibernate) {
00717                         TQT_DBusMessage reply = logindProxy.sendWithReply("Hibernate", params);
00718                         if (reply.type() == TQT_DBusMessage::ReplyMessage) {
00719                             return true;
00720                         }
00721                     }
00722                     else if (ps == TDESystemPowerState::HybridSuspend) {
00723                         TQT_DBusMessage reply = logindProxy.sendWithReply("HybridSleep", params);
00724                         if (reply.type() == TQT_DBusMessage::ReplyMessage) {
00725                             return true;
00726                         }
00727                     }
00728                 }
00729             }
00730         }
00731 #endif // WITH_LOGINDPOWER
00732 
00733 #ifdef WITH_UPOWER
00734         {
00735           // No support for "freeze" and "hybrid suspend" in org.freedesktop.UPower
00736             TQT_DBusConnection dbusConn;
00737             dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00738             if ( dbusConn.isConnected() ) {
00739                 if (ps == TDESystemPowerState::Suspend) {
00740                     TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00741                                 "org.freedesktop.UPower",
00742                                 "/org/freedesktop/UPower",
00743                                 "org.freedesktop.UPower",
00744                                 "Suspend");
00745                     TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00746                     if (reply.type() == TQT_DBusMessage::ReplyMessage) {
00747                         return true;
00748                     }
00749                 }
00750                 else if (ps == TDESystemPowerState::Hibernate) {
00751                     TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00752                                 "org.freedesktop.UPower",
00753                                 "/org/freedesktop/UPower",
00754                                 "org.freedesktop.UPower",
00755                                 "Hibernate");
00756                     TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00757                     if (reply.type() == TQT_DBusMessage::ReplyMessage) {
00758                         return true;
00759                     }
00760                 }
00761             }
00762         }
00763 #endif // WITH_UPOWER
00764 
00765 #ifdef WITH_DEVKITPOWER
00766         {
00767           // No support for "freeze" and "hybrid suspend" in org.freedesktop.DeviceKit.Power
00768             TQT_DBusConnection dbusConn;
00769             dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00770             if ( dbusConn.isConnected() ) {
00771                 if (ps == TDESystemPowerState::Suspend) {
00772                     TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00773                                 "org.freedesktop.DeviceKit.Power",
00774                                 "/org/freedesktop/DeviceKit/Power",
00775                                 "org.freedesktop.DeviceKit.Power",
00776                                 "Suspend");
00777                     TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00778                     if (reply.type() == TQT_DBusMessage::ReplyMessage) {
00779                         return true;
00780                     }
00781                 }
00782                 else if (ps == TDESystemPowerState::Hibernate) {
00783                     TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00784                                 "org.freedesktop.DeviceKit.Power",
00785                                 "/org/freedesktop/DeviceKit/Power",
00786                                 "org.freedesktop.DeviceKit.Power",
00787                                 "Hibernate");
00788                     TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00789                     if (reply.type() == TQT_DBusMessage::ReplyMessage) {
00790                         return true;
00791                     }
00792                 }
00793             }
00794         }
00795 #endif // WITH_DEVKITPOWER
00796 
00797 #ifdef WITH_HAL
00798         {
00799           // No support for "freeze" in org.freedesktop.Hal
00800             TQT_DBusConnection dbusConn;
00801             dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00802             if ( dbusConn.isConnected() ) {
00803                 if (ps == TDESystemPowerState::Suspend) {
00804                     TQT_DBusProxy halPowerManagement(
00805                             "org.freedesktop.Hal",
00806                             "/org/freedesktop/Hal/devices/computer",
00807                             "org.freedesktop.Hal.Device.SystemPowerManagement",
00808                             dbusConn);
00809                     TQValueList<TQT_DBusData> params;
00810                     params << TQT_DBusData::fromInt32(0);
00811                     TQT_DBusMessage reply = halPowerManagement.sendWithReply("Suspend", params);
00812                     if (reply.type() == TQT_DBusMessage::ReplyMessage) {
00813                         return true;
00814                     }
00815                 }
00816                 else if (ps == TDESystemPowerState::Hibernate) {
00817                     TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00818                                 "org.freedesktop.Hal",
00819                                 "/org/freedesktop/Hal/devices/computer",
00820                                 "org.freedesktop.Hal.Device.SystemPowerManagement",
00821                                 "Hibernate");
00822                     TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00823                     if (reply.type() == TQT_DBusMessage::ReplyMessage) {
00824                         return true;
00825                     }
00826                 }
00827                 else if (ps == TDESystemPowerState::HybridSuspend) {
00828                     TQT_DBusProxy halPowerManagement(
00829                             "org.freedesktop.Hal",
00830                             "/org/freedesktop/Hal/devices/computer",
00831                             "org.freedesktop.Hal.Device.SystemPowerManagement",
00832                             dbusConn);
00833                     TQValueList<TQT_DBusData> params;
00834                     params << TQT_DBusData::fromInt32(0);
00835                     TQT_DBusMessage reply = halPowerManagement.sendWithReply("SuspendHybrid", params);
00836                     if (reply.type() == TQT_DBusMessage::ReplyMessage) {
00837                         return true;
00838                     }
00839                 }
00840             }
00841         }
00842 #endif // WITH_HAL
00843 
00844 #ifdef WITH_TDEHWLIB_DAEMONS
00845         {
00846             TQT_DBusConnection dbusConn;
00847             dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00848             if ( dbusConn.isConnected() ) {
00849                 if (ps == TDESystemPowerState::Standby) {
00850                     TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00851                                 "org.trinitydesktop.hardwarecontrol",
00852                                 "/org/trinitydesktop/hardwarecontrol",
00853                                 "org.trinitydesktop.hardwarecontrol.Power",
00854                                 "Standby");
00855                     TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00856                     if (reply.type() == TQT_DBusMessage::ReplyMessage) {
00857                         return true;
00858                     }
00859                 }
00860                 else if (ps == TDESystemPowerState::Freeze) {
00861                     TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00862                                 "org.trinitydesktop.hardwarecontrol",
00863                                 "/org/trinitydesktop/hardwarecontrol",
00864                                 "org.trinitydesktop.hardwarecontrol.Power",
00865                                 "Freeze");
00866                     TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00867                     if (reply.type() == TQT_DBusMessage::ReplyMessage) {
00868                         return true;
00869                     }
00870                 }
00871                 else if (ps == TDESystemPowerState::Suspend) {
00872                     TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00873                                 "org.trinitydesktop.hardwarecontrol",
00874                                 "/org/trinitydesktop/hardwarecontrol",
00875                                 "org.trinitydesktop.hardwarecontrol.Power",
00876                                 "Suspend");
00877                     TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00878                     if (reply.type() == TQT_DBusMessage::ReplyMessage) {
00879                         return true;
00880                     }
00881                 }
00882                 else if (ps == TDESystemPowerState::Hibernate) {
00883                     TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00884                                 "org.trinitydesktop.hardwarecontrol",
00885                                 "/org/trinitydesktop/hardwarecontrol",
00886                                 "org.trinitydesktop.hardwarecontrol.Power",
00887                                 "Hibernate");
00888                     TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00889                     if (reply.type() == TQT_DBusMessage::ReplyMessage) {
00890                         return true;
00891                     }
00892                 }
00893                 else if (ps == TDESystemPowerState::HybridSuspend) {
00894                     TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00895                                 "org.trinitydesktop.hardwarecontrol",
00896                                 "/org/trinitydesktop/hardwarecontrol",
00897                                 "org.trinitydesktop.hardwarecontrol.Power",
00898                                 "HybridSuspend");
00899                     TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00900                     if (reply.type() == TQT_DBusMessage::ReplyMessage) {
00901                         return true;
00902                     }
00903                 }
00904             }
00905         }
00906 #endif // WITH_TDEHWLIB_DAEMONS
00907 
00908         return false;
00909     }
00910     else if (ps == TDESystemPowerState::PowerOff) {
00911         TDEConfig config("ksmserverrc", true);
00912         config.setGroup("General" );
00913         if (!config.readBoolEntry( "offerShutdown", true )) {
00914             return false;
00915         }
00916 #ifdef WITH_LOGINDPOWER
00917         {
00918             TQT_DBusConnection dbusConn;
00919             dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00920             if ( dbusConn.isConnected() ) {
00921                 TQT_DBusProxy logindProxy("org.freedesktop.login1", "/org/freedesktop/login1",
00922                                           "org.freedesktop.login1.Manager", dbusConn);
00923                 TQValueList<TQT_DBusData> params;
00924                 params << TQT_DBusData::fromBool(true);
00925                 if (logindProxy.canSend()) {
00926                     TQT_DBusMessage reply = logindProxy.sendWithReply("PowerOff", params);
00927                     if (reply.type() == TQT_DBusMessage::ReplyMessage) {
00928                         return true;
00929                     }
00930                 }
00931             }
00932         }
00933 #endif // WITH_LOGINDPOWER
00934 #ifdef WITH_CONSOLEKIT
00935         {
00936             TQT_DBusConnection dbusConn;
00937             dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00938             if ( dbusConn.isConnected() ) {
00939                 TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
00940                             "org.freedesktop.ConsoleKit",
00941                             "/org/freedesktop/ConsoleKit/Manager",
00942                             "org.freedesktop.ConsoleKit.Manager",
00943                             "Stop");
00944                 TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
00945                 if (reply.type() == TQT_DBusMessage::ReplyMessage) {
00946                     return true;
00947                 }
00948             }
00949         }
00950 #endif // WITH_CONSOLEKIT
00951         // Power down the system using a DCOP command
00952         /* As found at http://lists.kde.org/?l=kde-linux&m=115770988603387
00953         Logout parameters explanation:
00954         First parameter:    confirm
00955             Obey the user's confirmation setting:   -1
00956             Don't confirm, shutdown without asking: 0
00957             Always confirm, ask even if the user turned it off: 1
00958         Second parameter:   type
00959             Select previous action or the default if it's the first time: -1
00960             Only log out: 0
00961             Log out and reboot the machine: 1
00962             Log out and halt the machine: 2
00963         Third parameter:    mode
00964             Select previous mode or the default if it's the first time: -1
00965             Schedule a shutdown (halt or reboot) for the time all active sessions have exited: 0
00966             Shut down, if no sessions are active. Otherwise do nothing: 1
00967             Force shutdown. Kill any possibly active sessions: 2
00968             Pop up a dialog asking the user what to do if sessions are still active: 3
00969         */
00970         TQByteArray data;
00971         TQDataStream arg(data, IO_WriteOnly);
00972         arg << (int)0 << (int)2 << (int)2;
00973         if ( kapp->dcopClient()->send("ksmserver", "default", "logout(int,int,int)", data) ) {
00974             return true;
00975         }
00976         return false;
00977     }
00978     else if (ps == TDESystemPowerState::Reboot) {
00979         TDEConfig config("ksmserverrc", true);
00980         config.setGroup("General" );
00981         if (!config.readBoolEntry( "offerShutdown", true )) {
00982             return false;
00983         }
00984 #ifdef WITH_LOGINDPOWER
00985         {
00986             TQT_DBusConnection dbusConn;
00987             dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
00988             if ( dbusConn.isConnected() ) {
00989                 TQT_DBusProxy logindProxy("org.freedesktop.login1", "/org/freedesktop/login1",
00990                                           "org.freedesktop.login1.Manager", dbusConn);
00991                 TQValueList<TQT_DBusData> params;
00992                 params << TQT_DBusData::fromBool(true);
00993                 if (logindProxy.canSend()) {
00994                     TQT_DBusMessage reply = logindProxy.sendWithReply("Reboot", params);
00995                     if (reply.type() == TQT_DBusMessage::ReplyMessage) {
00996                         return true;
00997                     }
00998                 }
00999             }
01000         }
01001 #endif // WITH_LOGINDPOWER
01002 #ifdef WITH_CONSOLEKIT
01003         {
01004             TQT_DBusConnection dbusConn;
01005             dbusConn = TQT_DBusConnection::addConnection(TQT_DBusConnection::SystemBus);
01006             if ( dbusConn.isConnected() ) {
01007                 TQT_DBusMessage msg = TQT_DBusMessage::methodCall(
01008                             "org.freedesktop.ConsoleKit",
01009                             "/org/freedesktop/ConsoleKit/Manager",
01010                             "org.freedesktop.ConsoleKit.Manager",
01011                             "Restart");
01012                 TQT_DBusMessage reply = dbusConn.sendWithReply(msg);
01013                 if (reply.type() == TQT_DBusMessage::ReplyMessage) {
01014                     return true;
01015                 }
01016             }
01017         }
01018 #endif // WITH_CONSOLEKIT
01019         // Power down the system using a DCOP command
01020         // See above PowerOff section for logout() parameters explanation
01021         TQByteArray data;
01022         TQDataStream arg(data, IO_WriteOnly);
01023         arg << (int)0 << (int)1 << (int)2;
01024         if ( kapp->dcopClient()->send("ksmserver", "default", "logout(int,int,int)", data) ) {
01025             return true;
01026         }
01027         return false;
01028     }
01029     else if (ps == TDESystemPowerState::Active) {
01030         // Ummm...we're already active...
01031         return true;
01032     }
01033 
01034     return false;
01035 }
01036 
01037 #include "tderootsystemdevice.moc"