diff options
Diffstat (limited to 'powermanager/guidance-power-manager.py')
| -rwxr-xr-x | powermanager/guidance-power-manager.py | 1134 |
1 files changed, 1134 insertions, 0 deletions
diff --git a/powermanager/guidance-power-manager.py b/powermanager/guidance-power-manager.py new file mode 100755 index 0000000..41df5e8 --- /dev/null +++ b/powermanager/guidance-power-manager.py @@ -0,0 +1,1134 @@ +#!/usr/bin/python +# -*- coding: UTF-8 -*- +""" +Copyright 2006-2007 Sebastian Kügler, Canonical Ltd, Luka Renko + +Authors: + Sebastian Kügler <sebas@kde.org> + Jonathan Riddell <jriddell@ubuntu.com> + Luka Renko <lure@kubuntu.org> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +""" + +""" +A frontend to HAL's power features for KDE. +Supports screen brightness, battery level, plugged/unplugged notices, laptop lid closing actions +Specification at https://wiki.kubuntu.org/KubuntuPowerManagement + +Issues: + - We have to keep polling HAL rather than listening for signals because the Python DBUS bindings + don't have Qt mainloop integration + - Written in Python so will be slow to load up, will probably port to C++ Qt 4.2 in future + - Should also handle UPS and bluetooth batteries + - systray applet should be hidden if no battery, but then how do you suspend if no battery? + (ksmserver integration please) + - Needs lots more testing + - Use KUniqueApplication again as soon as dcop problem is sorted outc + - dcop calls need patch to dcopexport.py, already submitted upstream +""" + +import os +import sys +import subprocess +import dbus + +from qt import * +from kdecore import * +from kdeui import * + +from dcopext import DCOPClient, DCOPApp # used to lock the screen +from dcopexport import DCOPExObj + +from guidance_power_manager_ui import PowerManagerUI +from notify import NotifyWidget +from tooltip import ToolTip + +from powermanage import * + +POLL_INTERVAL = 5000 # in milliseconds + +class Notify(NotifyWidget): + """ Pop up a passive notication windows. """ + + def __init__(self,parent,msg,icon,caption=None): + NotifyWidget.__init__(self,parent,"notify") + self.setIcon(icon) + self.setText(msg) + if caption: + self.Caption(caption) + + def setIcon(self,pixmap): + """ Set an icon to be displayed in the notification. """ + if pixmap: + self.Icon.setPixmap(pixmap) + + def setCaption(self,caption): + """ Text to show in bold letters. """ + self.Caption.setText(QString("<b>")+caption+QString("</b>")) + + def setText(self,msg): + """" Set actual notification message. """ + self.Text.setText(msg) + + +class PowerManager(PowerManagerUI): + """ Our configuration dialog. """ + + def __init__ (self, parent, name): + PowerManagerUI.__init__(self, parent, name) + KGlobal.iconLoader().addAppDir("guidance") + + # The systray icon should show and hide the KDialogBase, not only this widget, + # therefore, it gets our parent as parent. + self.systray = KSystemTray(parent) + self.icon = "battery-charging-100" + self.systray.setPixmap(QPixmap(UserIcon(self.icon))) + self.connect(self.systray, SIGNAL("quitSelected()"), self.quit) + + # Configuration filename + self.config = KConfig("power-managerrc") + + self.powermanager = PowerManage() + + def prepare(self): + """ Prepare UI. """ + self._initBrightness() + self._initLid() + self._initBattery() + self.lastidlesec = 0 + + self._initConfigKeywords() + + self._initUI(self.parent()) + + self.configToUi() + + # Polling: evil. can't receive signals in python-dbus unless we have a glib mainloop, + # so we need to poll + self.pollTimer = QTimer(self) + self.connect(self.pollTimer, SIGNAL("timeout()"), self.poll) + self.pollTimer.start(POLL_INTERVAL) # 5 second poll, maybe make this configurable + self.poll(False) + + # check CPU freq policy and notify if it was changed + msg = self.checkCpuFreq() + if msg != "": + self.notify(msg) + + self.systray.show() + + def _initBrightness(self): + """ Check for brightness support and disable widgets if it's not there. """ + if not self.powermanager.hasBrightness: + self.PoweredBrightnessLabel.hide() + self.PoweredBrightnessSlider.hide() + self.BatteryBrightnessLabel.hide() + self.BatteryBrightnessSlider.hide() + + def _initLid(self): + """ Check for lid support and disable widgets if it's not there. """ + if not self.powermanager.hasLid: + self.LaptopLidRadios.setEnabled(False) + + def _initCB(self, combo, options, values): + """ Initialize QComboBox with proper values from provided options. """ + combo.clear() + for option in options: + combo.insertItem(values[option]) + + def _getCB(self, combo, options): + """ Get current item from QComboBox from config file (string) value. """ + try: + return options[combo.currentItem()] + except IndexError: + return "" + + def _setCB(self, combo, options, default, value): + """ Set current item in QComboBox from string value. """ + try: + num = options.index(value) + except ValueError: + num = default + pass + combo.setCurrentItem(num) + + def _getRB(self, radios, options): + """ Get current item from QRadioButton from config file (string) value. """ + try: + return options[radios.selectedId()] + except IndexError: + return "" + + def _setRB(self, radios, options, default, value): + """ Set current item in QRadioButton from string value. """ + try: + num = options.index(value) + except ValueError: + num = default + pass + radios.setButton(num) + + def _checkOldConfig(self, value, blank): + """ Convert old numerical values to keywords. """ + try: + num_val = int(value) + except ValueError: + return value + if blank: + if num_val == 0: return 'nothing' + if num_val == 1: return 'blank' + if num_val == 2: return 'suspend' + if num_val == 3: return 'hibernate' + if num_val == 4: return 'shutdown' + else: + if num_val == 0: return 'nothing' + if num_val == 1: return 'suspend' + if num_val == 2: return 'hibernate' + if num_val == 3: return 'shutdown' + return value + + + def _initConfigKeywords(self): + """ Define helper maps used with config file keywords. """ + # map action keyword to displayed name (l10n) + self.act_name = {} + self.act_name['nothing'] = i18n("Do nothing") + self.act_name['blank'] = i18n("Blank screen") + self.act_name['suspend'] = i18n("Suspend") + self.act_name['hibernate'] = i18n("Hibernate") + self.act_name['shutdown'] = i18n("Shutdown") + + # map action keyword to action methods + self.act_call = {} + self.act_call['nothing'] = None + self.act_call['blank'] = self.blankScreen + self.act_call['suspend'] = self.suspend + self.act_call['hibernate'] = self.hibernate + self.act_call['shutdown'] = self.shutdown + + # map action keyword to notification description (l10n) + self.act_notify = {} + self.act_notify['nothing'] = i18n("doing nothing") + self.act_notify['blank'] = i18n("blanking screen") + self.act_notify['suspend'] = i18n("suspending") + self.act_notify['hibernate'] = i18n("hibernating") + self.act_notify['shutdown'] = i18n("shutting down") + + # map action keyword to action icon used in notification window + self.act_icon = {} + self.act_icon['nothing'] = None + self.act_icon['blank'] = None + self.act_icon['suspend'] = SmallIcon("suspend") + self.act_icon['hibernate'] = SmallIcon("hibernate") + self.act_icon['shutdown'] = SmallIcon("exit") + + # map policy keyword to displayed name (l10n) + self.freq_name = {} + self.freq_name['dynamic'] = i18n("Dynamic") + self.freq_name['powersave'] = i18n("Powersave") + self.freq_name['performance'] = i18n("Performance") + + # map policy keyword to policy change methods + self.freq_call = {} + self.freq_call['dynamic'] = self.setCpuPolicyDynamic + self.freq_call['powersave'] = self.setCpuPolicyPowersave + self.freq_call['performance'] = self.setCpuPolicyPerformance + + + def _initUI(self, parent): + """ Build dynamic parts of the UI: context menu and tooltip. """ + self.canSuspend = self.powermanager.canSuspend and not self.config.readBoolEntry("disableSuspend", False) + self.canHibernate = self.powermanager.canHibernate and not self.config.readBoolEntry("disableHibernate", False) + + # Connect some signals. Updates in the dialogue apply instantly + self.connect(self.PoweredBrightnessSlider, SIGNAL("valueChanged(int)"), self.changePoweredBrightness) + self.connect(self.BatteryBrightnessSlider, SIGNAL("valueChanged(int)"), self.changeBatteryBrightness) + + #Add a blank tooltip, the tooltipgroup signals are then used for our KPassivePopup + toolTipGroup = QToolTipGroup(self.systray) + QToolTip.add(self.systray, "", toolTipGroup, "blah") + self.connect(toolTipGroup, SIGNAL("showTip(const QString&)"), self.showTip) + self.connect(toolTipGroup, SIGNAL("removeTip()"), self.hideTip) + + # Popup tooltip showing battery level + self.popup = KPassivePopup(self.systray) + + self.tooltip = ToolTip(self.popup) + + self._addBatteryWidgets() + + self._addCpuWidgets() + self.popup.setView(self.tooltip) + + # fill actions for LID + self.lid_act = ['nothing', 'blank', 'suspend', 'hibernate', 'shutdown'] + self.lid_act_def = 0 + # hide LID close actions that are not supported + if not self.canSuspend: + self.laptopClosedSuspend.hide() + if not self.canHibernate: + self.laptopClosedHibernate.hide() + + # fill in only CPU policies that are supported by HW + self.cb_freq = [] # list of supported cpu freq policies + self.cb_freq_def = 0 # always use first policy as default + if self.powermanager.hasCpuFreqGovernors: + self.cb_freq = self.powermanager.getSupportedCpuPolicies() + if len(self.cb_freq) > 0: + self._initCB(self.PoweredFreqCombo, self.cb_freq, self.freq_name) + self._initCB(self.BatteryFreqCombo, self.cb_freq, self.freq_name) + else: + self.PoweredFreqLabel.hide() + self.PoweredFreqCombo.hide() + self.BatteryFreqLabel.hide() + self.BatteryFreqCombo.hide() + + # fill actions in Idle/Critical battery combo boxes + self.cb_act = ['nothing'] # list of supported actions (keywords) + self.cb_act_def_critical = 0 # default action when critical battery + if self.canSuspend: + self.cb_act.append('suspend') + if self.canHibernate: + self.cb_act.append('hibernate') + self.cb_act_def_critical = len(self.cb_act) - 1 # hibernate + self.cb_act.append('shutdown') + if self.cb_act_def_critical == 0: + self.cb_act_def_critical = len(self.cb_act) - 1 # shutdown + self._initCB(self.PoweredIdleCombo, self.cb_act, self.act_name) + self._initCB(self.BatteryIdleCombo, self.cb_act, self.act_name) + self._initCB(self.BatteryCriticalCombo, self.cb_act, self.act_name) + + self.connect(self.PoweredIdleCombo,SIGNAL("activated(int)"),self.slotPoweredIdleActivated) + self.connect(self.BatteryIdleCombo,SIGNAL("activated(int)"),self.slotBatteryIdleActivated) + self.connect(self.BatteryCriticalCombo,SIGNAL("activated(int)"),self.slotBatteryCriticalActivated) + + # add suspend/hibernate to tray's context menu + menu = self.systray.contextMenu() + if self.canSuspend: + action = KAction( i18n("Suspend"), KShortcut(), self.suspend, + self.systray.actionCollection(), "suspend") + action.setIcon("suspend") + action.plug(menu) + if self.canHibernate: + action = KAction( i18n("Hibernate"), KShortcut(), self.hibernate, + self.systray.actionCollection(), "hibernate") + action.setIcon("hibernate") + action.plug(menu) + + # add list of governators + if self.powermanager.hasCpuFreqGovernors and len(self.cb_freq) > 0: + submenu = KPopupMenu(menu) + for policy in self.cb_freq: + action = KRadioAction(self.freq_name[policy], KShortcut(), + self.freq_call[policy], + self.systray.actionCollection(), policy) + action.setExclusiveGroup("freqs") + action.plug(submenu) + + policy = self.powermanager.getCpuPolicy() + if policy in self.cb_freq: + self.systray.actionCollection().action(policy).setChecked(True); + menu.insertItem(i18n("CPU policy"), submenu) + + + # KGlobalAccel crashes the application in pykde + # see http://mats.gmd.de/pipermail/pykde/2006-May/013224.html + #self.globalActions = KGlobalAccel(self) + #self.suspendShortcut = KShortcut("XF86Sleep") + #self.hibernateShortcut = KShortcut("XF86Standby") + #self.hshutdownShortcut = KShortcut("XF86PowerOff") + #self.globalActions.insert("suspend", i18n("Suspend"), i18n("what's this?"), self.suspendShortcut, #self.suspendShortcut, self.suspend) + #self.globalActions.updateConnections() + + def _initBattery(self): + """ Remove non-battery-related widgets if there's no battery bay. """ + if not self.powermanager.hasBattery: + # Disable the Batterybox in the config dialogue, + self.BatteryBox.setEnabled(False) + # And change the icon in the systray, remove the restore option + # This way, we're basically becoming a systray applet, you can + # hibernate and suspend from + self.systray.setPixmap(QPixmap(UserIcon(self.icon))) + if self.powermanager.hasAC: + self.wasOnBattery = self.powermanager.onBattery() + + def configToUi(self): + """ Setup the the values from the config file in the UI.""" + # brightness. + if self.powermanager.hasBrightness: + brightness_high = self.powermanager.brightness_levels + self.BatteryBrightnessSlider.setMaxValue(self.powermanager.brightness_levels-1) + self.PoweredBrightnessSlider.setMaxValue(self.powermanager.brightness_levels-1) + self.BatteryBrightnessSlider.setValue(self.config.readNumEntry("batteryBrightness", int(brightness_high/2))) #default middle + self.PoweredBrightnessSlider.setValue(self.config.readNumEntry("poweredBrightness", brightness_high)) #default highest + + tt_text = "Every step increases or decreases the brightness by %i%%" % int(100/brightness_high) + QToolTip.add(self.BatteryBrightnessSlider, tt_text) + QToolTip.add(self.PoweredBrightnessSlider, tt_text) + + self.lockScreenOnResume.setChecked(self.config.readBoolEntry("lockOnResume", True)) + + # Idletime-related configuration + self._setCB(self.PoweredIdleCombo, self.cb_act, 0, str(self.config.readEntry("poweredIdleAction"))) + self.PoweredIdleTime.setValue(self.config.readNumEntry("poweredIdleTime", 60)) + self._setCB(self.BatteryIdleCombo, self.cb_act, 0, str(self.config.readEntry("batteryIdleAction"))) + self.BatteryIdleTime.setValue(self.config.readNumEntry("batteryIdleTime", 10)) + + self._setCB(self.PoweredFreqCombo, self.cb_freq, self.cb_freq_def, str(self.config.readEntry("poweredFreqPolicy"))) + self._setCB(self.BatteryFreqCombo, self.cb_freq, self.cb_freq_def, str(self.config.readEntry("batteryFreqPolicy"))) + + self.BatteryIdleTime.setValue(self.config.readNumEntry("batteryIdleTime", 10)) # default Do nothing + # battery critical and lid actions. + self._setCB(self.BatteryCriticalCombo, self.cb_act, self.cb_act_def_critical, self._checkOldConfig(self.config.readEntry("batteryCriticalAction", ""), False)) + self._setRB(self.LaptopLidRadios, self.lid_act, self.lid_act_def, self._checkOldConfig(self.config.readEntry("laptopLidAction", ""), True)) + self.CriticalRemainTime.setValue(self.config.readNumEntry("criticalRemainTime", BATTERY_CRITICAL_MINUTES)) + self.criticalLevel = self.CriticalRemainTime.value() + + # Call some slots to disable various spinboxes if necessary + self.slotBatteryCriticalActivated() + self.slotPoweredIdleActivated() + self.slotBatteryIdleActivated() + + + def uiToConfig(self): + """ Read all values from the UI and write them to the config file. """ + self.config.writeEntry("poweredBrightness", self.PoweredBrightnessSlider.value()) + self.config.writeEntry("batteryBrightness", self.BatteryBrightnessSlider.value()) + + self.config.writeEntry("poweredIdleTime", self.PoweredIdleTime.value()) + self.config.writeEntry("poweredIdleAction", self._getCB(self.PoweredIdleCombo, self.cb_act)) + self.config.writeEntry("batteryIdleTime", self.BatteryIdleTime.value()) + self.config.writeEntry("batteryIdleAction", self._getCB(self.BatteryIdleCombo, self.cb_act)) + self.config.writeEntry("poweredFreqPolicy", self._getCB(self.PoweredFreqCombo, self.cb_freq)) + self.config.writeEntry("batteryFreqPolicy", self._getCB(self.BatteryFreqCombo, self.cb_freq)) + + self.config.writeEntry("batteryCriticalAction", self._getCB(self.BatteryCriticalCombo, self.cb_act)) + self.config.writeEntry("criticalRemainTime", self.CriticalRemainTime.value()) + + self.config.writeEntry("laptopLidAction", self._getRB(self.LaptopLidRadios, self.lid_act)) + self.config.writeEntry("lockOnResume", self.lockScreenOnResume.isChecked()) + + self.criticalLevel = self.CriticalRemainTime.value() + + self.config.sync() + + def quit(self): + """ Quit application. """ + kapp.quit() + + def showTip(self, text=""): + """ Pop up the tooltip showing battery data and CPU frequencies. """ + self.popup.show() + + + def showBrightnessPopup(self): + if self.powermanager.onBattery(): + value=self.BatteryBrightnessSlider.value()*100/self.BatteryBrightnessSlider.maxValue() + else: + value=self.PoweredBrightnessSlider.value()*100/self.PoweredBrightnessSlider.maxValue() + self.brightnessPopup = KPassivePopup.message('<b>Brightness:</b> '+str(value)+'%', self.systray) + """pop.setTimeout(3000)""" + self.brightnessPopup.show() + + def setBrightnessUp(self): + """Increments slider value by 10%""" + if self.powermanager.onBattery(): + self.BatteryBrightnessSlider.setValue(float(self.BatteryBrightnessSlider.value())+max(float(self.BatteryBrightnessSlider.maxValue())/float(10),1)) + else: + self.PoweredBrightnessSlider.setValue(float(self.PoweredBrightnessSlider.value())+max(float(self.PoweredBrightnessSlider.maxValue())/float(10),1)) + self.showBrightnessPopup() + + def setBrightnessDown(self): + """Decrements slider value by 10%""" + if self.powermanager.onBattery(): + self.BatteryBrightnessSlider.setValue(float(self.BatteryBrightnessSlider.value())-max(float(self.BatteryBrightnessSlider.maxValue())/float(10),1)) + else: + self.PoweredBrightnessSlider.setValue(float(self.PoweredBrightnessSlider.value())-max(float(self.PoweredBrightnessSlider.maxValue())/float(10),1)) + self.showBrightnessPopup() + + def getBrightness(self): + """Work with percentages - it's a bit nicer""" + if self.powermanager.onBattery(): + value=self.BatteryBrightnessSlider.value()*100/self.BatteryBrightnessSlider.maxValue() + else: + value=self.PoweredBrightnessSlider.value()*100/self.PoweredBrightnessSlider.maxValue() + return QString(str(value)) + + def hideTip(self): + """ Hide the tooltip.""" + self.popup.hide() + + def lockScreen(self): + """ locks the screen using kdesktop """ + # create a new DCOP-Client: + client = DCOPClient() + # connect the client to the local DCOP-server: + client.attach() + # create a DCOP-Application-Object to talk to kdesktop: + kdesktop = DCOPApp('kdesktop', client) + # call a DCOP-function: + try: + ok, foo = kdesktop.KScreensaverIface.lock() + except: + print "Unable to lock the screen. The KDE Screensaver does not seem to be running." + def suspend(self): + """ Lock the screen and initiate a suspend to RAM (S3). """ + if self.config.readBoolEntry("lockOnResume", True): + self.lockScreen() + try: + self.warningPopup.hide() + except AttributeError: + pass # No warningpopup, that's OK. + self.powermanager.suspend() + self.powermanager.resetIdleSeconds() + + def hibernate(self): + """ Lock the screen and initiate a suspend to disk (S4). """ + if self.config.readBoolEntry("lockOnResume", True): + self.lockScreen() + try: + self.warningPopup.hide() + except AttributeError: + pass # No warningpopup, that's OK. + self.powermanager.hibernate() + self.powermanager.resetIdleSeconds() + + def shutdown(self): + """ Perform system shutdown. """ + self.powermanager.shutdown() + + def setCpuPolicyDynamic(self): + """Change frequ for all cpu""" + self.powermanager.setCpuPolicy('dynamic') + self.notify(i18n("CPU frequency policy changed to %1.").arg(self.freq_name['dynamic'])) + + def setCpuPolicyPerformance(self): + """Change frequ for all cpu""" + self.powermanager.setCpuPolicy('performance') + self.notify(i18n("CPU frequency policy changed to %1.").arg(self.freq_name['performance'])) + + def setCpuPolicyPowersave(self): + """Change frequ for all cpu""" + self.powermanager.setCpuPolicy('powersave') + self.notify(i18n("CPU frequency policy changed to %1.").arg(self.freq_name['powersave'])) + + def trySuspend(self): + """ If supported, lock the screen and initiate a suspend to RAM (S3). """ + if self.canSuspend: + self.suspend() + else: + print "Warning: DCOP suspend() called, but not supported." + + def tryHibernate(self): + """ If supported, lock the screen and initiate a suspend to disk (S4). """ + if self.canHibernate: + self.hibernate() + else: + print "Warning: DCOP hibernate() called, but not supported." + + def blankScreen(self): + """ Lock and blank screen. """ + if self.config.readBoolEntry("lockOnResume", True): + self.lockScreen() + self.powermanager.blankScreen() + + def _getIcon(self): + """ Set systray icon depending on battery status/level. """ + if self.powermanager.hasBattery: + if self.batt_state == "not present": + self.icon = "ac-adapter" + if self.batt_state == "charged": + self.icon = "battery-charging-100" + elif self.batt_state == "discharging": + if self.batt_level >= 95: + self.icon = "battery-discharging-100" + elif self.batt_level < 95 and self.batt_level >= 85: + self.icon = "battery-discharging-090" + elif self.batt_level < 85 and self.batt_level >= 75: + self.icon = "battery-discharging-070" + elif self.batt_level < 75 and self.batt_level >= 60: + self.icon = "battery-discharging-060" + elif self.batt_level < 65 and self.batt_level >= 45: + self.icon = "battery-discharging-050" + elif self.batt_level < 45 and self.batt_level >= 30: + self.icon = "battery-discharging-040" + elif self.batt_level < 30 and self.batt_level >= 20: + self.icon = "battery-discharging-030" + elif self.batt_level < 20 and self.batt_level >= 10: + self.icon = "battery-discharging-020" + elif self.batt_level < 10 and self.batt_level >= 5: + self.icon = "battery-discharging-010" + else: + self.icon = "battery-discharging-000" + elif self.batt_state == "charging": + if self.batt_level >= 95: + self.icon = "battery-charging-100" + elif self.batt_level < 95 and self.batt_level >= 85: + self.icon = "battery-charging-090" + elif self.batt_level < 85 and self.batt_level >= 75: + self.icon = "battery-charging-070" + elif self.batt_level < 75 and self.batt_level >= 60: + self.icon = "battery-charging-060" + elif self.batt_level < 65 and self.batt_level >= 45: + self.icon = "battery-charging-050" + elif self.batt_level < 45 and self.batt_level >= 30: + self.icon = "battery-charging-040" + elif self.batt_level < 30 and self.batt_level >= 20: + self.icon = "battery-charging-030" + elif self.batt_level < 20 and self.batt_level >= 10: + self.icon = "battery-charging-020" + elif self.batt_level < 10 and self.batt_level >= 5: + self.icon = "battery-charging-010" + else: + self.icon = "battery-charging-000" + else: + self.icon = "ac-adapter" + return self.icon + + def getIcon(self): + """ Return current icon.""" + return UserIcon(self.icon) + + def setIcon(self): + """ Change the systray/tooltip icon.""" + oldIcon = self.icon + self.icon = self._getIcon() + if self.icon != oldIcon: + self.systray.setPixmap(QPixmap(UserIcon(self.icon))) + self.BattPixmap.setPixmap(QPixmap(UserIcon(self.icon))) + + def notify(self, msg, icon=None): + """ Send a notification popup. """ + if icon: + icon = QPixmap(icon) + else: + icon = QPixmap(SmallIcon("messagebox_info")) + try: + del self.warningPopup + except: + pass + self.warningPopup = KPassivePopup(self.systray) + label = Notify(self.warningPopup, msg, icon) + self.warningPopup.setView(label) + position = QPoint(5,5) + self.warningPopup.show(position) + + def poll(self,notify=True): + """ Check for changes in plugged in status, battery status and laptop lid closed status. """ + debug( "------------ POLL ---------------") + + self.powermanager.checkHAL() + # Battery stuff: + # check for last state, and run plugged / unplugged message if the state changed. + if self.powermanager.hasBattery: + plugged_num = 0 + self.batt_state = "not present" # unknown yet + self.batt_level = self.batt_remain = 0 + self.batt_rate = self.batt_charge = self.batt_full = 0 + for batt in self.powermanager.batteries: + state, level, remain, rate, current, full = self.powermanager.getBatteryState(batt) + self._updateBatteryWidget(batt, state, level, remain, rate) + + ## notify plugged/unplugged batteries + if state == "not present": + if self.powermanager.batteryIsPresent[batt]: + self.notify(i18n("The battery has been removed.")) + self.powermanager.batteryIsPresent[batt] = False + else: # battery present + if not self.powermanager.batteryIsPresent[batt]: + self.notify(i18n("The battery has been inserted.")) + self.powermanager.batteryIsPresent[batt] = True + + ## get cumulative charge levels/rate + self.batt_rate += rate + self.batt_charge += current + self.batt_full += full + + ## calculate overall level (average of present batteries) + self.batt_remain += remain + self.batt_level += level + plugged_num += 1 + + ## calculate overall state (charging/discharging/charged) + if state in ("charging","discharging"): + self.batt_state = state + elif not self.batt_state in ("charging, discharging"): + self.batt_state = state + + # if we know charge and full -> recalculate overall level + if self.batt_full > 0 and self.batt_charge > 0: + self.batt_level = 100 * self.batt_charge / self.batt_full + else: + # if more than one battery present, we need to calculate average level + if plugged_num > 1: + self.batt_level /= plugged_num + + # if rate is reported, calculate remaining time on our own + if self.batt_rate > 0: + if self.batt_state == "charging": + self.batt_remain = 3600 * (float(self.batt_full - self.batt_charge) / self.batt_rate) + if self.batt_state == "discharging": + self.batt_remain = 3600 * (float(self.batt_charge) / self.batt_rate) + + remain_h = self.batt_remain/3600 + remain_m = (self.batt_remain/60)%60 + + blabel = i18n("<b>Battery:</b>") + if self.batt_state == "charged": + blabel += i18n(" fully charged") + elif self.batt_state == "charging": + blabel += i18n(" %i:%02ih to charge" % (remain_h,remain_m)) + elif self.batt_state == "discharging": + blabel += i18n(" %i:%02ih remaining" % (remain_h,remain_m)) + self.BattMainLabel.setText(blabel) + + # update tray icon if needed + self.setIcon() + + # check battery state + self.checkBatteryCritical() + + # check Idletime + self.checkIdletime() + + # CPU stuff + self._updateCpuWidgets() + + if self.powermanager.hasBattery: + on_battery = self.powermanager.onBattery() + if self.powermanager.wasOnBattery != on_battery: + self.powermanager.wasOnBattery = on_battery + debug("poll: states differ") + if not on_battery: + debug("poll: Now on AC") + if notify: + self.powerHasBeenPlugged() + else: + debug("poll: Now on battery") + if notify: + self.powerHasBeenUnplugged() + else: + debug("poll: state is the same") + + # Lid stuff + if self.powermanager.hasLid: + if self.powermanager.getLidClosedState(): + if not self.powermanager.lidClosedState: + self.powermanager.lidClosedState = True + + action = self._getRB(self.LaptopLidRadios, self.lid_act) + if not self.act_name.has_key(action): + action = self.act_name[self.lid_act_def] + + if self.act_call[action] != None: + note = i18n("Laptop lid is closed, %1 now.").arg(self.act_notify[action]) + self.notify(note, self.act_icon[action]) + QTimer.singleShot(2000, self.act_call[action]) + else: + self.powermanager.lidClosedState = False + + def _addBatteryWidgets(self): + """ Adds progressbars to show battery status to the tooltip.""" + BattLayout = QHBoxLayout(None,0,6,"BattLayout") + + self.BattPixmap = QLabel(self.tooltip,"BattLabLayout") + self.BattPixmap.setSizePolicy(QSizePolicy(QSizePolicy.Fixed,QSizePolicy.Fixed,0,0,self.BattPixmap.sizePolicy().hasHeightForWidth())) + self.BattPixmap.setPixmap(QPixmap(UserIcon(self.icon))) + self.BattPixmap.setScaledContents(1) + BattLayout.addWidget(self.BattPixmap) + self.BattMainLabel = QLabel(self.tooltip,"BattMainLabel") + self.BattMainLabel.setText(i18n("<b>Battery:</b>")) + BattLayout.addWidget(self.BattMainLabel) + + # Add to tooltip + self.tooltip.layout().addLayout(BattLayout) + + # Create a progressbar and a label for every battery found, and add it to tooltip + self.BattLabel = {} + self.BattLayout = {} + self.BattProgress = {} + i = 1 + for batt in self.powermanager.batteries: + self.BattLayout[batt] = QHBoxLayout(None,0,6,"BattBarLayout") + self.BattLabel[batt] = QLabel(self.tooltip,"BattLabel") + if len(self.powermanager.batteries) > 1: + self.BattLabel[batt].setText(i18n("Battery %i" % i)) + self.BattLayout[batt].addWidget(self.BattLabel[batt]) + self.BattProgress[batt] = KProgress(self.tooltip,"BattProgress") + self.BattProgress[batt].setMinimumSize(QSize(200,0)) + self.BattLayout[batt].addWidget(self.BattProgress[batt]) + self.tooltip.layout().addLayout(self.BattLayout[batt]) + i += 1 + + + def _updateBatteryWidget(self, batt, state, level, remain, rate): + """ Retrieve battery information and update the related widgets accordingly. """ + self.BattProgress[batt].setEnabled(True) + self.BattProgress[batt].setTotalSteps(100) + self.BattProgress[batt].setProgress(level) + if state == "not present": + self.BattProgress[batt].setFormat(i18n("not present")) + elif state == "charging": + self.BattProgress[batt].setFormat(i18n("Charging (%p%)")) + elif state == "discharging": + if rate > 0: + showrate = rate/1000 + self.BattProgress[batt].setFormat(i18n("Discharging (%p%)") + " - %.d W" % showrate) + else: + self.BattProgress[batt].setFormat(i18n("Discharging (%p%)")) + else: + self.BattProgress[batt].setFormat("%p%") + + def _addCpuWidgets(self): + """ Adds progressbars to show CPU frequencies to the tooltip.""" + if not SHOW_CPUFREQ: + return + if len(self.powermanager.cpus) == 0: + return + + LabelLayout = QHBoxLayout(None,0,6,"layout5") + + self.CpuPixmap = QLabel(self.tooltip,"CpuPixmap") + self.CpuPixmap.setSizePolicy(QSizePolicy(QSizePolicy.Fixed,QSizePolicy.Fixed,0,0,self.CpuPixmap.sizePolicy().hasHeightForWidth())) + self.CpuPixmap.setPixmap(QPixmap(UserIcon("processor"))) + self.CpuPixmap.setScaledContents(1) + LabelLayout.addWidget(self.CpuPixmap) + self.CpuMainLabel = QLabel(self.tooltip,"CpuMainLabel") + self.CpuMainLabel.setText(i18n("<b>CPU Frequency:</b>")) + LabelLayout.addWidget(self.CpuMainLabel) + + # Add to tooltip + self.tooltip.layout().addLayout(LabelLayout) + + # Create a progressbar and a label for every CPU found, and add it to tooltip + self.CpuLabel = {} + self.CpuLayout = {} + self.CpuProgress = {} + i = 1 + for cpu in self.powermanager.cpus: + self.CpuLayout[cpu] = QHBoxLayout(None,0,6,"layout2") + self.CpuLabel[cpu] = QLabel(self.tooltip,"CpuLabel") + if len(self.powermanager.cpus) > 1: + self.CpuLabel[cpu].setText(i18n("Processor %i" % i)) + self.CpuLayout[cpu].addWidget(self.CpuLabel[cpu]) + self.CpuProgress[cpu] = KProgress(self.tooltip,"CpuProgress") + self.CpuProgress[cpu].setFormat("%v MHz") + self.CpuLayout[cpu].addWidget(self.CpuProgress[cpu]) + self.tooltip.layout().addLayout(self.CpuLayout[cpu]) + i += 1 + + def slotPoweredIdleActivated(self, index=False): + """ Signal slot for activated powered idle action. """ + if not index: + index = self.PoweredIdleCombo.currentItem() + self.PoweredIdleTime.setEnabled(index != 0) + + def slotBatteryIdleActivated(self, index=False): + """ Signal slot for activated battery idle action. """ + if not index: + index = self.BatteryIdleCombo.currentItem() + self.BatteryIdleTime.setEnabled(index != 0) + + def slotBatteryCriticalActivated(self, index=False): + """ Signal slot for activated battery critical action. """ + if not index: + index = self.BatteryCriticalCombo.currentItem() + self.CriticalRemainTime.setEnabled(index != 0) + + def _updateCpuWidgets(self): + """ Retrieve CPU freq information and update the related widgets accordingly. """ + if not SHOW_CPUFREQ: + return + if len(self.powermanager.cpus) == 0: + return + + clabel = i18n("<b>CPU Frequency:</b>") + " " + policy = self.powermanager.getCpuPolicy() + if self.freq_name.has_key(policy): + clabel += self.freq_name[policy] # get l10n name + else: + clabel += policy + self.CpuMainLabel.setText(clabel) + + for cpu in self.powermanager.cpus: + cpustate = self.powermanager.getCpuState(cpu) + if not cpustate['online']: + self.CpuProgress[cpu].setEnabled(False) + else: + self.CpuProgress[cpu].setEnabled(True) + self.CpuProgress[cpu].setTotalSteps(cpustate['max']) + self.CpuProgress[cpu].setProgress(cpustate['cur']) + if policy != "": + self.systray.actionCollection().action(policy).setChecked(True) + if policy in self.cb_freq: + self.systray.actionCollection().action(policy).setChecked(True) + + def changePoweredBrightness(self, level=None): + """ Mains-powered brigthness slider has been moved. """ + # Check if the state applies and adjust brightness immediately. + if not self.powermanager.onBattery() and self.powermanager.hasBrightness: + if not level: + level = self.PoweredBrightnessSlider.value() + self.powermanager.adjustBrightness(level) + + def changeBatteryBrightness(self, level=None): + """ Battery-powered brigthness slider has been moved. """ + # Check if the state applies and adjust brightness immediately. + if self.powermanager.onBattery() and self.powermanager.hasBrightness: + if not level: + level = self.BatteryBrightnessSlider.value() + self.powermanager.adjustBrightness(level) + + + + + def checkCpuFreq(self): + """ Adjust CPU frequency policy according to current state """ + if not self.powermanager.hasCpuFreqGovernors: + return "" + + if self.powermanager.onBattery(): + policy = str(self.config.readEntry("batteryFreqPolicy")) + else: + policy = str(self.config.readEntry("poweredFreqPolicy")) + if policy == "": + policy = 'dynamic' + + # check if specified policy is supported by HW + if not policy in self.cb_freq: + print "Warning: policy from config file not supported: ", policy + return "" + + current_policy = self.powermanager.getCpuPolicy() + if current_policy != policy: + debug("Switching CPU policy from %s to %s." % (current_policy, policy)) + self.powermanager.setCpuPolicy(policy) + return i18n("CPU frequency policy changed to %1.").arg(self.freq_name[policy]) + elif current_policy == 'dynamic': + debug("Dynamic policy -> update policy (conservative/ondemand)") + self.powermanager.setCpuPolicy(policy) + + debug("CPU policy will stay %s" % current_policy) + return "" + + def powerHasBeenUnplugged(self): + """ Actions to perform when the plug has been pulled.""" + if self.powermanager.hasBrightness: + self.powermanager.adjustBrightness(self.BatteryBrightnessSlider.value()) + self.powermanager.setPowerSave(True) + self.checkBatteryCritical() + self.changeBatteryBrightness() + self.powermanager.setScreensaverBlankOnly(True) + self.powermanager.resetIdleSeconds() + msg = self.checkCpuFreq() + if self.powermanager.hasAC: + self.notify(i18n("The AC adapter has been unplugged, switching to battery mode.")+"\n"+msg, self.getIcon()) + + def powerHasBeenPlugged(self): + """ Actions to perform when AC adapter has been plugged in. """ + if self.powermanager.hasBrightness: + self.powermanager.adjustBrightness(self.PoweredBrightnessSlider.value()) + self.powermanager.setPowerSave(False) + self.changePoweredBrightness() + self.powermanager.setScreensaverBlankOnly(False) + msg = self.checkCpuFreq() + self.powermanager.resetIdleSeconds() + self.notify(i18n("The AC adapter has been plugged in, switching to AC mode.")+"\n"+msg, self.getIcon()) + + def checkBatteryCritical(self): + """ Check for warning and critical battery label and notify-warn or + initiate the configured action. """ + + if not self.powermanager.hasBattery: + return + + if self.batt_state == "discharging": + currentLevel = int(self.batt_remain/60) + + warningLevel = self.criticalLevel + 5 # warn five minutes before critical + criticalLevel = self.criticalLevel + + debug("CurrentBat: %i, WarningBat: %i, CriticalBat: %i" % (currentLevel, warningLevel, criticalLevel)) + # We only want to suspend if the chargelevel is above a certain threshold, + # it sometimes takes some time for HAL to report remaining time correctly + if currentLevel <= criticalLevel and self.batt_level < CHARGE_LEVEL_THRESHOLD: + if not self.powermanager.criticalBatteryState and self.powermanager.onBattery(): + self.powermanager.criticalBatteryState = True + + action = str(self.config.readEntry("batteryCriticalAction")) + if not self.act_name.has_key(action): + action = self.act_name[self.cb_act_def_critical] + + note = i18n("You are about to run out of battery power, %1 now.").arg(self.act_notify[action]) + self.notify(note, self.act_icon[action]) + if self.act_call[action] != None: + QTimer.singleShot(2000, self.act_call[action]) + else: + self.powermanager.criticalBatteryState = False + if currentLevel <= warningLevel and self.batt_level < CHARGE_LEVEL_THRESHOLD: + if not self.powermanager.warningBatteryState: + self.powermanager.warningBatteryState = True + self.notify(i18n("You are low on battery power."), self.getIcon()) + else: + self.powermanager.warningBatteryState = False + + def checkIdletime(self): + """ Reads the idle time and does some action. """ + idlesec = round(self.powermanager.getIdleSeconds()/60, 2) + if self.powermanager.onBattery(): + idleTime = self.config.readNumEntry("batteryIdleTime", 10) + action = str(self.config.readEntry("batteryIdleAction")) + else: + idleTime = self.config.readNumEntry("poweredIdleTime", 60) + action = str(self.config.readEntry("poweredIdleAction")) + if not self.act_name.has_key(action): + action = 'nothing' + + if idlesec - self.lastidlesec > 100: + debug("last: %u" % (idlesec - self.lastidlesec)) + return # probably bogus idleseconds right after suspend + self.lastidlesec = idlesec + if self.act_call[action] == None: + return # doing nothing anyway + if idlesec > idleTime: + note = i18n("System idle for at least %1 minutes, %2 now.").arg(idleTime).arg(self.act_notify[action]) + self.notify(note, self.act_icon[action]) + QTimer.singleShot(2000, self.act_call[action]) + + + +def doDcop(kapp): + """ Register kvandale in dcop, so it can be controlled from outside. """ + my_dcop = kapp.dcopClient() + #my_dcop.attach() + #my_dcop.registerAs("power-manager") + + +class DcopIface (DCOPExObj): + """ Add some interface so we can use powermanager from the outside. """ + def __init__ (self, app, id='power-manager'): + DCOPExObj.__init__ (self, id) + # addMethod (<signature>, <Python method>) + #self.addMethod ('QString getQuery()', gvd.getZoekbegrip) + + # PM related. + self.addMethod ('void suspend ()', app.trySuspend) + self.addMethod ('void hibernate ()', app.tryHibernate) + self.addMethod ('void shutdown ()', app.shutdown) + + # UI related. + self.addMethod ('void showTip ()', app.showTip) + #self.addMethod ('void show ()', app.parent().show) + #self.addMethod ('void hide ()', app.parent().hide) + + #self.addMethod ('void plugged ()', app.powerHasBeenPlugged) + #self.addMethod ('void unplugged ()', app.powerHasBeenUnplugged) + self.addMethod ('bool onBattery ()', app.powermanager.onBattery) + + self.addMethod('void brightnessUp ()', app.setBrightnessUp) + self.addMethod('void brightnessDown ()', app.setBrightnessDown) + self.addMethod('QString getBrightness ()', app.getBrightness) + + #self.addMethod ('QString getCurrentResult()', gvd.getRawResult) + + +class PowermanagerApp(KDialogBase): + """ The KDialog providing the OK, Apply and Cancel buttons.""" + + def __init__(self,parent=None,name=None): + """ Initialise dialog and set mainwidget. """ + KGlobal.locale().insertCatalogue("guidance") + KGlobal.iconLoader().addAppDir("guidance") + + # We would like to use a KUniqueApplication, but that breaks dcop due to some + # strange bug. The following line is the revenge code for this bug, it is + # intentionally ugly. + if len(os.popen("dcop |grep guidance-").readlines()) > 1: + print "There is already an instance of power manager running. Exiting." + sys.exit(0) + + # Which buttons do we want? + KDialogBase.__init__(self,KJanusWidget.Swallow,i18n("Power Manager"), + KDialogBase.Ok|KDialogBase.Apply|KDialogBase.Cancel|KDialogBase.User1, KDialogBase.Close) + self.pmwidget = PowerManager(self,name) + self.setButtonText(KDialogBase.User1, i18n("About")) + + if not self.pmwidget.powermanager.isLaptop(): + print "This is not a laptop, quitting ... " + sys.exit(1) + + self.pmwidget.prepare() + + self.setMainWidget(self.pmwidget) + self.aboutus = KAboutApplication(self) + + def slotOk(self): + """ The OK button has been pressed, save configuration and pass on do whatever + needs to be done by KDialog. """ + self.pmwidget.uiToConfig() + self.pmwidget.checkCpuFreq() + KDialogBase.slotOk(self) + + def slotApply(self): + """ The Apply button has been pressed, save configuration and pass on do whatever + needs to be done by KDialog. """ + self.pmwidget.uiToConfig() + self.pmwidget.checkCpuFreq() + KDialogBase.slotApply(self) + + def slotCancel(self): + """ The Cancel button has been pressed, reset some values and hide dialogue. """ + # In case brightness has changed, we reset it to the configured value. + if self.pmwidget.powermanager.hasBrightness: + brightness_high = self.pmwidget.powermanager.brightness_levels + if not self.pmwidget.powermanager.onBattery(): + level = self.pmwidget.config.readNumEntry("poweredBrightness", brightness_high) + else: + level = self.pmwidget.config.readNumEntry("batteryBrightness", int(brightness_high/2)) + self.pmwidget.powermanager.adjustBrightness(level) + self.pmwidget.configToUi() + KDialogBase.slotCancel(self) + + def slotUser1(self): + self.aboutus.show() + +# There's a bug in KUniqueApplication that shows the pid in the dcop name, +# this fugly hack works around it. +class PMApp(KApplication): + + def name(self): + return "power-manager" + + +if __name__ == "__main__": + aboutdata = KAboutData("guidance", "Power Manager", "0.8.0", + "Handles battery, display and suspend modes for your computer.", KAboutData.License_GPL, + "(C) 2006-2007 Sebastian Kügler, Canonical Ltd, Luka Renko", + None, None, "jriddell@ubuntu.com") + aboutdata.addAuthor("Sebastian Kügler", "Developer", "sebas@kde.org","http://vizZzion.org") + aboutdata.addAuthor("Jonathan Riddell", "Developer", "jriddell@ubuntu.com") + aboutdata.addAuthor("Luka Renko", "Developer", "lure@kubuntu.org") + aboutdata.setProgramLogo(QImage("power-manager.png")) + KCmdLineArgs.init(sys.argv, aboutdata) + #kapp = KUniqueApplication(True, True, False) + #kapp = KApplication() + kapp = PMApp(True, True) + mainWindow = PowermanagerApp(None, "main window") + doDcop(kapp) + dcop_iface = DcopIface(mainWindow.pmwidget) + """Start helper module / button listener""" + try: + helperPid = os.spawnl(os.P_NOWAIT, os.path.dirname(__file__)+'/gpmhelper.py', 'gpmhelper.py') + except: + """Non-fatal if this fails""" + print "Unable to start button-listener" + + kapp.exec_loop() + + """Kill helper module / button listener""" + os.system('kill '+str(helperPid)) |