mirror of
https://github.com/arcan1s/awesome-widgets.git
synced 2025-04-24 23:47:20 +00:00
333 lines
13 KiB
Python
333 lines
13 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
############################################################################
|
|
# This file is part of pytextmonitor #
|
|
# #
|
|
# pytextmonitor 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 3 of the #
|
|
# License, or (at your option) any later version. #
|
|
# #
|
|
# pytextmonitor is distributed in the hope that it will be useful, #
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of #
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
|
|
# GNU General Public License for more details. #
|
|
# #
|
|
# You should have received a copy of the GNU General Public License #
|
|
# along with pytextmonitor. If not, see http://www.gnu.org/licenses/ #
|
|
############################################################################
|
|
|
|
from PyQt4.QtCore import *
|
|
from PyQt4.QtGui import *
|
|
from PyKDE4.kdecore import *
|
|
from PyKDE4.kdeui import *
|
|
from PyKDE4.kio import *
|
|
from PyKDE4 import plasmascript
|
|
from PyKDE4.plasma import Plasma
|
|
import commands, os, shutil, time
|
|
|
|
import configdef
|
|
import configwindow
|
|
import dataengine
|
|
import reinit
|
|
import tooltip
|
|
from util import *
|
|
|
|
|
|
|
|
class pyTextWidget(plasmascript.Applet):
|
|
def __init__(self, parent, args=None):
|
|
"""widget definition"""
|
|
plasmascript.Applet.__init__(self, parent)
|
|
|
|
|
|
def init(self):
|
|
"""function to initializate widget"""
|
|
self._name = str(self.package().metadata().pluginName())
|
|
self.layout = QGraphicsLinearLayout(Qt.Horizontal, self.applet)
|
|
|
|
self.dataengine = dataengine.DataEngine(self)
|
|
self.reinit = reinit.Reinit(self)
|
|
self.tooltipAgent = tooltip.Tooltip(self)
|
|
|
|
self.timer = QTimer()
|
|
QObject.connect(self.timer, SIGNAL("timeout()"), self.updateLabel)
|
|
|
|
self.setupVar()
|
|
self.initTooltip()
|
|
self.reinit.reinit(confAccept=False)
|
|
|
|
self.setHasConfigurationInterface(True)
|
|
# Create notifyrc file if required
|
|
kdehome = unicode(KGlobal.dirs().localkdedir())
|
|
if ((not os.path.exists(kdehome + "/share/apps/plasma_applet_pytextmonitor/plasma_applet_pytextmonitor.notifyrc")) and
|
|
(not os.path.exists("/usr" + "/share/apps/plasma_applet_pytextmonitor/plasma_applet_pytextmonitor.notifyrc"))):
|
|
self.createNotifyrc(kdehome)
|
|
|
|
|
|
def createConfigurationInterface(self, parent):
|
|
"""function to setup configuration window"""
|
|
self.configpage = configwindow.ConfigWindow(self)
|
|
self.configdef = configdef.ConfigDefinition(self, self.configpage)
|
|
self.configdef.createConfigurationInterface(parent)
|
|
|
|
|
|
def createNotifyrc(self, kdehome):
|
|
"""function to create *.notifyrc"""
|
|
if (not os.path.isdir(kdehome + "/share/apps/plasma_applet_pytextmonitor")):
|
|
os.mkdir(kdehome + "/share/apps/plasma_applet_pytextmonitor")
|
|
shutil.copy(kdehome + "/share/apps/plasma/plasmoids/py-text-monitor/contents/code/plasma_applet_pytextmonitor.notifyrc",
|
|
kdehome + "/share/apps/plasma_applet_pytextmonitor/")
|
|
|
|
|
|
def initTooltip(self):
|
|
"""function to create tooltip"""
|
|
self.tooltip = Plasma.ToolTipContent()
|
|
self.tooltip.setMainText("PyTextMonitor")
|
|
self.tooltip.setSubText('')
|
|
Plasma.ToolTipManager.self().registerWidget(self.applet)
|
|
# graphical tooltip
|
|
self.tooltip_pixmap = QPixmap()
|
|
self.tooltip_scene = QGraphicsScene()
|
|
self.tooltip_view = QGraphicsView(self.tooltip_scene)
|
|
self.tooltip_view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
|
|
self.tooltip_view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
|
|
# show tooltip
|
|
Plasma.ToolTipManager.self().setContent(self.applet, self.tooltip)
|
|
|
|
|
|
def updateTooltip(self):
|
|
"""function to update tooltip"""
|
|
self.tooltip_view.resize(100.0*(len(self.tooltipReq)-self.tooltipReq.count('up')), 100.0)
|
|
self.tooltipAgent.createGraphic(self.tooltipReq, self.tooltipColors, self.tooltipValues, self.tooltip_scene)
|
|
self.tooltip.setImage(QPixmap.grabWidget(self.tooltip_view))
|
|
Plasma.ToolTipManager.self().setContent(self.applet, self.tooltip)
|
|
|
|
|
|
def mouseDoubleClickEvent(self, event):
|
|
"""function to doubleclick event"""
|
|
os.system("ksysguard &")
|
|
|
|
|
|
def setupNetdev(self):
|
|
"""function to setup network device"""
|
|
netdev = "lo"
|
|
interfaces = QDir.entryList(QDir(self.netdir), QDir.Dirs | QDir.NoDotAndDotDot)
|
|
for device in interfaces:
|
|
if (str(device) != "lo"):
|
|
try:
|
|
with open(self.netdir+"/"+str(device)+"/operstate", "r") as stateFile:
|
|
if (stateFile.readline() == "up\n"):
|
|
netdev = str(device)
|
|
except:
|
|
pass
|
|
return netdev
|
|
|
|
|
|
def setupVar(self):
|
|
"""function to setup variables"""
|
|
self.netdev = ''
|
|
self.cpuCore = {-1:" 0.0"}
|
|
self.cpuClockCore = {-1:" 0"}
|
|
numCores = int(commands.getoutput("grep -c '^processor' /proc/cpuinfo"))
|
|
for i in range(numCores):
|
|
self.cpuCore[i] = str(" 0.0")
|
|
self.cpuClockCore[i] = str(" 0")
|
|
self.netSpeed = {"up":" 0", "down":" 0"}
|
|
self.tempNames = []
|
|
self.temp = {}
|
|
self.mountNames = []
|
|
self.mount = {}
|
|
self.hddNames = []
|
|
self.hdd = {}
|
|
self.tooltipColors = {}
|
|
self.tooltipNum = 100
|
|
self.tooltipReq = []
|
|
self.tooltipValues = {'cpu':[0.0, 0.01], 'cpuclock':[0.0, 0.01], 'mem':[0.0, 0.01],
|
|
'swap':[0.0, 0.01], 'up':[0.0, 0.01], 'down':[0.0, 0.01]}
|
|
|
|
# create dictionaries
|
|
self.dict_orders = {'6':'bat', '1':'cpu', '7':'cpuclock', 'f':'custom', '9':'gpu',
|
|
'a':'gputemp', 'b':'hdd', 'c':'hddtemp', '3':'mem', '5':'net', '4':'swap', '2':'temp',
|
|
'8':'uptime', 'd':'player', 'e':'time'}
|
|
self.dict_defFormat = {'bat':'[bat: $bat%$ac]', 'cpu':'[cpu: $cpu%]',
|
|
'cpuclock':'[mhz: $cpucl]', 'custom':'[$custom]', 'gpu':'[gpu: $gpu%]',
|
|
'gputemp':'[gpu temp: $gputemp°C]', 'hdd':'[hdd: $hdd0%]',
|
|
'hddtemp':'[hdd temp: $hddtemp0°C]', 'mem':'[mem: $mem%]',
|
|
'net':'[$netdev: $down/$upKB/s]', 'swap':'[swap: $swap%]',
|
|
'temp':'[temp: $temp0°C]', 'uptime':'[uptime: $uptime]',
|
|
'player':'[$artist - $title]', 'time':'[$time]'}
|
|
|
|
|
|
def showConfigurationInterface(self):
|
|
"""function to show configuration window"""
|
|
plasmascript.Applet.showConfigurationInterface(self)
|
|
|
|
|
|
def startPolling(self):
|
|
try:
|
|
self.timer.start()
|
|
self.updateLabel()
|
|
self.tooltip.setSubText('')
|
|
except Exception as strerror:
|
|
self.tooltip.setSubText(str(strerror))
|
|
return
|
|
|
|
|
|
def updateLabel(self):
|
|
"""function to update label"""
|
|
if (self.batBool > 0):
|
|
self.batText()
|
|
if (self.cpuBool > 0):
|
|
self.cpuText()
|
|
if (self.cpuclockBool > 0):
|
|
self.cpuclockText()
|
|
if (self.customBool > 0):
|
|
self.getCustom()
|
|
if (self.hddBool > 0):
|
|
self.mountText()
|
|
if ((self.memBool > 0) and (self.memInMb == False)):
|
|
self.memText()
|
|
if (self.netBool > 0):
|
|
self.netText()
|
|
if ((self.swapBool > 0) and (self.swapInMb == False)):
|
|
self.swapText()
|
|
if (self.tempBool > 0):
|
|
self.tempText()
|
|
self.updateTooltip()
|
|
|
|
|
|
def batText(self):
|
|
"""function to set battery text"""
|
|
line = self.batFormat
|
|
if (line.split('$bat')[0] != line):
|
|
try:
|
|
with open (self.battery_device, 'r') as bat_file:
|
|
bat = bat_file.readline().split('\n')[0]
|
|
except:
|
|
bat = 'off'
|
|
bat = "%3s" % (bat)
|
|
line = line.split('$bat')[0] + bat + line.split('$bat')[1]
|
|
if (line.split('$ac')[0] != line):
|
|
try:
|
|
with open (self.ac_device, 'r') as bat_file:
|
|
bat = bat_file.readline().split('\n')[0]
|
|
if (bat == '1'):
|
|
bat = '(*)'
|
|
else:
|
|
bat = '( )'
|
|
except:
|
|
bat = '(?)'
|
|
line = line.split('$ac')[0] + bat + line.split('$ac')[1]
|
|
text = self.formatLine.split('$LINE')[0] + line + self.formatLine.split('$LINE')[1]
|
|
self.label_bat.setText(text)
|
|
|
|
|
|
def cpuText(self):
|
|
"""function to set cpu text"""
|
|
line = self.cpuFormat
|
|
for core in self.cpuCore.keys():
|
|
if (core > -1):
|
|
if (line.split('$cpu'+str(core))[0] != line):
|
|
line = line.split('$cpu'+str(core))[0] + self.cpuCore[core] + line.split('$cpu'+str(core))[1]
|
|
if (line.split('$cpu')[0] != line):
|
|
line = line.split('$cpu')[0] + self.cpuCore[-1] + line.split('$cpu')[1]
|
|
text = self.formatLine.split('$LINE')[0] + line + self.formatLine.split('$LINE')[1]
|
|
self.label_cpu.setText(text)
|
|
|
|
|
|
def cpuclockText(self):
|
|
"""function to set cpu clock text"""
|
|
line = self.cpuclockFormat
|
|
for core in self.cpuClockCore.keys():
|
|
if (core > -1):
|
|
if (line.split('$cpucl'+str(core))[0] != line):
|
|
line = line.split('$cpucl'+str(core))[0] + self.cpuClockCore[core] + line.split('$cpucl'+str(core))[1]
|
|
if (line.split('$cpucl')[0] != line):
|
|
line = line.split('$cpucl')[0] + self.cpuClockCore[-1] + line.split('$cpucl')[1]
|
|
text = self.formatLine.split('$LINE')[0] + line + self.formatLine.split('$LINE')[1]
|
|
self.label_cpuclock.setText(text)
|
|
|
|
|
|
def memText(self):
|
|
"""function to set mem text"""
|
|
full = self.mem_uf + self.mem_free
|
|
try:
|
|
mem = 100 * self.mem_used / full
|
|
mem = "%5s" % (str(round(mem, 1)))
|
|
except:
|
|
mem = " N\\A"
|
|
if (self.memFormat.split('$mem')[0] != self.memFormat):
|
|
line = self.memFormat.split('$mem')[0] + mem + self.memFormat.split('$mem')[1]
|
|
else:
|
|
line = self.memFormat
|
|
text = self.formatLine.split('$LINE')[0] + line + self.formatLine.split('$LINE')[1]
|
|
self.label_mem.setText(text)
|
|
|
|
|
|
def mountText(self):
|
|
"""function to set mount text"""
|
|
line = self.hddFormat
|
|
for i in range(len(self.mountNames)):
|
|
if (line.split('$hdd'+str(i))[0] != line):
|
|
line = line.split('$hdd'+str(i))[0] + self.mount[self.mountNames[i]] + line.split('$hdd'+str(i))[1]
|
|
text = self.formatLine.split('$LINE')[0] + line + self.formatLine.split('$LINE')[1]
|
|
self.label_hdd.setText(text)
|
|
|
|
|
|
def netText(self):
|
|
"""function to set network text"""
|
|
line = self.netFormat
|
|
if (line.split('$up')[0] != line):
|
|
line = line.split('$up')[0] + self.netSpeed['up'] + line.split('$up')[1]
|
|
if (line.split('$down')[0] != line):
|
|
line = line.split('$down')[0] + self.netSpeed['down'] + line.split('$down')[1]
|
|
text = self.formatLine.split('$LINE')[0] + line + self.formatLine.split('$LINE')[1]
|
|
self.label_net.setText(text)
|
|
|
|
|
|
def swapText(self):
|
|
"""function to set swap text"""
|
|
full = self.swap_used + self.swap_free
|
|
try:
|
|
mem = 100 * self.swap_used / full
|
|
mem = "%5s" % (str(round(mem, 1)))
|
|
except:
|
|
mem = " N\\A"
|
|
if (self.swapFormat.split('$swap')[0] != self.swapFormat):
|
|
line = self.swapFormat.split('$swap')[0] + mem + self.swapFormat.split('$swap')[1]
|
|
else:
|
|
line = self.swapFormat
|
|
text = self.formatLine.split('$LINE')[0] + line + self.formatLine.split('$LINE')[1]
|
|
self.label_swap.setText(text)
|
|
|
|
|
|
def tempText(self):
|
|
"""function to set temperature text"""
|
|
line = self.tempFormat
|
|
for i in range(len(self.tempNames)):
|
|
if (line.split('$temp'+str(i))[0] != line):
|
|
line = line.split('$temp'+str(i))[0] + self.temp[self.tempNames[i]] + line.split('$temp'+str(i))[1]
|
|
text = self.formatLine.split('$LINE')[0] + line + self.formatLine.split('$LINE')[1]
|
|
self.label_temp.setText(text)
|
|
|
|
|
|
def getCustom(self):
|
|
"""function to get output from custom command"""
|
|
commandOut = commands.getoutput(self.custom_command)
|
|
line = self.customFormat
|
|
line = line.split('$custom')[0] + commandOut + line.split('$custom')[1]
|
|
text = self.formatLine.split('$LINE')[0] + line + self.formatLine.split('$LINE')[1]
|
|
self.label_custom.setText(text)
|
|
|
|
|
|
@pyqtSignature("dataUpdated(const QString &, const Plasma::DataEngine::Data &)")
|
|
def dataUpdated(self, sourceName, data):
|
|
"""function to update label"""
|
|
self.dataengine.dataUpdated(sourceName, data)
|
|
|
|
|
|
|
|
def CreateApplet(parent):
|
|
return pyTextWidget(parent)
|