class hwTempApp(plasmascript.Applet):
def __init__(self, parent, args=None):
plasmascript.Applet.__init__(self, parent)
def init(self):
self.setHasConfigurationInterface(False)
self.setAspectRatioMode(Plasma.Square)
self.setTheme()
self.setLayout()
self.startTimer(10000)
self.resize(100, 50)
def timerEvent(self, evt):
setLabel()
def setTheme(self):
self.theme = Plasma.Svg(self)
self.theme.setImagePath("widgets/background")
self.setBackgroundHints(Plasma.Applet.DefaultBackground)
def setLayout(self):
global label
self.layout = QGraphicsLinearLayout(Qt.Vertical, self.applet)
label = Plasma.Label(self.applet)
setLabel()
self.layout.addItem(label)
self.applet.setLayout(self.layout)
class PythonShellApplet(plasmascript.Applet):
def __init__(self,parent,args=None):
plasmascript.Applet.__init__(self,parent)
def init(self):
logger.debug("Starting qidle...")
event_loop = QEventLoop()
self.factory = InsulatedFactory(event_loop = event_loop)
self.factory.start()
self.factory.start_event_loop()
self.setHasConfigurationInterface(False)
self.setAspectRatioMode(Plasma.IgnoreAspectRatio)
self.theme = Plasma.Svg(self)
self.theme.setImagePath("widgets/background")
self.setBackgroundHints(Plasma.Applet.DefaultBackground)
self.layout = QGraphicsLinearLayout(Qt.Vertical, self.applet)
self.editorWidget = Plasma.TextEdit(self.applet)
self.shell_widget = ShellWidget(self.factory,self.editorWidget.nativeWidget())
self.shell_widget._disable_completion()
self.editorWidget.nativeWidget().setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.editorWidget.keyPressEvent = self.shell_widget.console_widget.keyPressEvent
self.layout.addItem(self.editorWidget)
self.resize(600,500)
def __del__(self):
self.shell_widget.quit()
self.factory.terminate()
class NetMonitor(plasmascript.Applet):
def __init__(self, parent, args=None):
plasmascript.Applet.__init__(self, parent)
def init(self):
self.setHasConfigurationInterface(False)
self.setAspectRatioMode(Plasma.Square)
self.theme = Plasma.Svg(self)
self.theme.setImagePath("widgets/background")
self.setBackgroundHints(Plasma.Applet.DefaultBackground)
self.layout = QGraphicsLinearLayout(Qt.Horizontal, self.applet)
self.monitoring = {}
self.widgets = {}
for source in self.connectToEngine():
label = Plasma.Label(self.applet)
label.setText("%s:" % source)
self.layout.addItem(label)
self.widgets[str(source)] = label
self.monitoring[str(source)] = {"in": 0, "out": 0}
self.applet.setLayout(self.layout)
def connectToEngine(self):
self.engine = self.dataEngine("net_monitor_data")
self.sources = self.engine.sources()
for source in self.sources:
self.engine.connectSource(source, self, 1000)
return self.sources
@pyqtSignature(
"dataUpdated(const QString &, const Plasma::DataEngine::Data &)")
def dataUpdated(self, sourceName, data):
"""Got something from data source"""
iface = str(sourceName)
if iface not in self.widgets:
print "Error: data for %s not available yet" % iface
return
widget = self.widgets[iface]
data_in = int(data[QString("data_in")])
data_out = int(data[QString("data_out")])
old_data_in = self.monitoring[iface]["in"]
old_data_out = self.monitoring[iface]["out"]
if old_data_in == -1:
speed_in = 0
else:
speed_in = data_in - old_data_in
if old_data_out == -1:
speed_out = 0
else:
speed_out = data_out - old_data_out
self.monitoring[iface]["in"] = data_in
self.monitoring[iface]["out"] = data_out
widget.setText("%s\n\/: %d\n/\: %d" %
(sourceName, speed_in, speed_out))
def paintInterface(self, painter, option, rect):
painter.save()
painter.restore()
def __init__(self, pixmap, title="", parentItem=None, **kwargs):
super().__init__(parentItem, **kwargs)
self.setFocusPolicy(Qt.StrongFocus)
self._title = None
self._size = QSizeF()
layout = QGraphicsLinearLayout(Qt.Vertical, self)
layout.setSpacing(2)
layout.setContentsMargins(5, 5, 5, 5)
self.setContentsMargins(0, 0, 0, 0)
self.pixmapWidget = GraphicsPixmapWidget(pixmap, self)
self.labelWidget = GraphicsTextWidget(title, self)
layout.addItem(self.pixmapWidget)
layout.addItem(self.labelWidget)
layout.addStretch()
layout.setAlignment(self.pixmapWidget, Qt.AlignCenter)
layout.setAlignment(self.labelWidget, Qt.AlignHCenter | Qt.AlignBottom)
self.setLayout(layout)
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.setFlag(QGraphicsItem.ItemIsSelectable, True)
self.setTitle(title)
self.setTitleWidth(100)
def __init__(self, pixmap, title="", parent=None):
QGraphicsWidget.__init__(self, parent)
self._title = None
self._size = QSizeF()
layout = QGraphicsLinearLayout(Qt.Vertical, self)
layout.setSpacing(2)
layout.setContentsMargins(5, 5, 5, 5)
self.setContentsMargins(0, 0, 0, 0)
self.pixmapWidget = GraphicsPixmapWidget(pixmap, self)
self.labelWidget = GraphicsTextWidget(title, self)
layout.addItem(self.pixmapWidget)
layout.addItem(self.labelWidget)
layout.setAlignment(self.pixmapWidget, Qt.AlignCenter)
layout.setAlignment(self.labelWidget, Qt.AlignHCenter | Qt.AlignBottom)
self.setLayout(layout)
self.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.setFlag(QGraphicsItem.ItemIsSelectable, True)
self.setTitle(title)
self.setTitleWidth(100)
def __init__(self, pixmap, title="", parent=None):
QGraphicsWidget.__init__(self, parent)
self._title = None
self._size = QSizeF()
layout = QGraphicsLinearLayout(Qt.Vertical, self)
layout.setSpacing(2)
layout.setContentsMargins(5, 5, 5, 5)
self.setContentsMargins(0, 0, 0, 0)
self.pixmapWidget = GraphicsPixmapWidget(pixmap, self)
self.labelWidget = GraphicsTextWidget(title, self)
layout.addItem(self.pixmapWidget)
layout.addItem(self.labelWidget)
layout.setAlignment(self.pixmapWidget, Qt.AlignCenter)
layout.setAlignment(self.labelWidget, Qt.AlignHCenter | Qt.AlignBottom)
self.setLayout(layout)
self.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.setFlag(QGraphicsItem.ItemIsSelectable, True)
self.setTitle(title)
self.setTitleWidth(100)
class hwTempApp(plasmascript.Applet):
def __init__(self,parent,args=None):
plasmascript.Applet.__init__(self,parent)
def init(self):
self.setHasConfigurationInterface(False)
self.setAspectRatioMode(Plasma.Square)
self.setTheme()
self.setLayout()
self.startTimer(10000)
self.resize(100,50)
def timerEvent(self,evt):
setLabel()
def setTheme(self):
self.theme = Plasma.Svg(self)
self.theme.setImagePath("widgets/background")
self.setBackgroundHints(Plasma.Applet.DefaultBackground)
def setLayout(self):
global label
self.layout = QGraphicsLinearLayout(Qt.Vertical, self.applet)
label = Plasma.Label(self.applet)
setLabel()
self.layout.addItem(label)
self.applet.setLayout(self.layout)
class JBApplet(plasmascript.Applet):
def __init__(self,parent,args=None):
plasmascript.Applet.__init__(self,parent)
def init(self):
self.setHasConfigurationInterface(True)
self.setAspectRatioMode(Plasma.Rectangle)
self.theme = Plasma.Svg(self)
self.theme.setImagePath("widgets/background")
self.setBackgroundHints(Plasma.Applet.DefaultBackground)
self.layout = QGraphicsLinearLayout(Qt.Horizontal, self.applet)
label= Plasma.Label(self.applet)
label.setText("Jupiter Broadcasting")
self.layout.addItem(label)
self.applet.setLayout(self.layout)
self.resize(640, 480)
app = QApplication(sys.argv)
web = QWebView()
web.load(QUrl("http://jb.cdn.scaleengine.net/jw/jwplayer.swf"))
web.show()
def CreateApplet(parent):
return JBApplet(parent)
def layout_widgets(self):
# Layout
if self.grid_layout <> None:
del self.grid_layout
self.grid_layout = QGraphicsGridLayout()
header_layout = QGraphicsLinearLayout()
header_layout.addItem(self.invert_button)
header_layout.addItem(self.title_label)
self.grid_layout.addItem(header_layout, 0, 0, 1, 2)
#self.grid_layout.addItem(self.collapse_button, 0, 0)
#self.grid_layout.addItem(self.title_label, 0, 1)
self.grid_layout.addItem(self.from_label, 1, 0)
self.grid_layout.addItem(self.currency_from, 1, 1)
self.grid_layout.addItem(self.to_label, 2, 0)
self.grid_layout.addItem(self.currency_to, 2, 1)
self.grid_layout.addItem(self.amount_label, 3, 0)
self.amount_layout = QGraphicsLinearLayout()
self.amount_layout.addItem(self.amount)
self.amount_layout.addItem(self.from_amount_label)
self.amount_layout.addItem(self.equal_label)
self.amount_layout.addItem(self.conversion_result)
self.amount_layout.addItem(self.to_amount_label)
self.grid_layout.addItem(self.amount_layout, 3, 1)
self.grid_layout.addItem(self.credits_label, 4, 0, 1, 2)
self.setLayout(self.grid_layout)
class TurnOffScreen(plasmascript.Applet):
def __init__(self, parent, args = None):
plasmascript.Applet.__init__(self, parent)
def init(self):
#TODO: have a configuration interface to set keybroad shortcut
#self.setHasConfigurationInterface(True)
self.setAspectRatioMode(Plasma.ConstrainedSquare)
self.setBackgroundHints(self.NoBackground)
self.sessionBus = dbus.SessionBus()
self.powerdevil = self.sessionBus.get_object('org.freedesktop.PowerManagement',
'/modules/powerdevil')
self.icon= Plasma.IconWidget(KIcon('preferences-desktop-screensaver'), '', self.applet)
if KGlobalSettings.singleClick():
self.connect(self.icon, SIGNAL('clicked()'), self.turn_off_screen)
else:
self.connect(self.icon, SIGNAL('doubleClicked()'), self.turn_off_screen)
self.connect(self, SIGNAL('active()'), self.turn_off_screen)
self.layout = QGraphicsLinearLayout(self.applet)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.setSpacing(0)
self.layout.addItem(self.icon)
self.setLayout(self.layout)
self.resize(25, 25)
#def showConfigurationInterface(self):
# self.con_short = KShortcutWidget(None)
# self.con_short.show()
def turn_off_screen(self):
self.powerdevil.turnOffScreen(dbus_interface='org.kde.PowerDevil')
class MPDClient(plasmascript.Applet):
def __init__(self, parent, args=None):
plasmascript.Applet.__init__(self, parent)
def init(self):
self.setHasConfigurationInterface(False)
self.setAspectRatioMode(Plasma.IgnoreAspectRatio)
self.layout = QGraphicsLinearLayout(Qt.Vertical, self.applet)
self.label = Plasma.Label(self.applet)
self.label.setWordWrap(False)
self.layout.addItem(self.label)
self.mpd = mpd.MPDClient()
try:
self.mpd.connect(HOST, PORT)
except:
pass
self.timer = QTimer()
self.timer.connect(self.timer, SIGNAL("timeout()"), self.timeout)
self.timer.start(1000)
self.timeout()
def timeout(self):
status = ""
try:
status = self.mpd.status()["state"]
except:
try:
self.mpd = mpd.MPDClient()
self.mpd.connect(HOST, PORT)
except:
pass
if status != "play":
self.label.setText("Music stopped")
return
currentSong = self.mpd.currentsong()
title = album = artist = ""
longstr = "<b>"
str = ""
try:
title = currentSong["title"]
except:
title = currentSong["file"].split("/")[-1]
try:
str = str + currentSong["artist"] + " - " + title
except:
str = str + title
try:
album = currentSong["album"]
except:
pass
self.label.setText(str.decode("utf-8")[0:50])
class NetMonitor(plasmascript.Applet):
def __init__(self,parent,args=None):
plasmascript.Applet.__init__(self,parent)
def init(self):
self.setHasConfigurationInterface(False)
self.setAspectRatioMode(Plasma.Square)
self.theme = Plasma.Svg(self)
self.theme.setImagePath("widgets/background")
self.setBackgroundHints(Plasma.Applet.DefaultBackground)
self.layout = QGraphicsLinearLayout(Qt.Horizontal, self.applet)
self.monitoring = {}
self.widgets = {}
for source in self.connectToEngine():
label = Plasma.Label(self.applet)
label.setText("%s:" % source)
self.layout.addItem(label)
self.widgets[str(source)] = label
self.monitoring[str(source)] = {"in": 0, "out": 0}
self.applet.setLayout(self.layout)
def connectToEngine(self):
self.engine = self.dataEngine("net_monitor_data")
self.sources = self.engine.sources()
for source in self.sources:
self.engine.connectSource(source, self, 1000)
return self.sources
@pyqtSignature("dataUpdated(const QString &, const Plasma::DataEngine::Data &)")
def dataUpdated(self, sourceName, data):
"""Got something from data source"""
iface = str(sourceName)
if iface not in self.widgets:
print "Error: data for %s not available yet" % iface
return
widget = self.widgets[iface]
data_in = int(data[QString("data_in")])
data_out = int(data[QString("data_out")])
old_data_in = self.monitoring[iface]["in"]
old_data_out = self.monitoring[iface]["out"]
if old_data_in == -1:
speed_in = 0
else:
speed_in = data_in - old_data_in
if old_data_out == -1:
speed_out = 0
else:
speed_out = data_out - old_data_out
self.monitoring[iface]["in"] = data_in
self.monitoring[iface]["out"] = data_out
widget.setText("%s\n\/: %d\n/\: %d" % (sourceName, speed_in, speed_out))
def paintInterface(self, painter, option, rect):
painter.save()
painter.restore()
class Kountdown(plasmascript.Applet):
def __init__(self,parent,args=None):
plasmascript.Applet.__init__(self,parent)
def init(self):
self.setHasConfigurationInterface(True)
self.model = KountdownModel(self.configScheme())
if self.model.needsConfiguration:
self.setConfigurationRequired(True)
else:
self.setupMainUI()
self.resize(300,125)
def setupMainUI(self):
print 'setup'
self.setAspectRatioMode(Plasma.IgnoreAspectRatio)
self.setBackgroundHints(Plasma.Applet.TranslucentBackground)
self.layout = QGraphicsLinearLayout(Qt.Vertical,self.applet)
self.label = Plasma.Label(self.applet)
self.label.setText(self.model.message)
self.label.setStyleSheet('''font-size: 18pt;''')
self.label.setAlignment(Qt.AlignCenter | Qt.AlignVCenter)
self.layout.addItem(self.label)
self.applet.setLayout(self.layout)
self.connectToEngine()
self.model.messageChanged.connect(self.handleMessageChanged)
def configChanged(self):
'''handle changes in configuration'''
plasmascript.Applet.configChanged(self)
self.updatedConfig()
def updatedConfig(self):
config = self.config()
if self.configurationRequired() and not self.model.needsConfiguration:
self.setConfigurationRequired(False)
self.setupMainUI()
def connectToEngine(self):
self.timeEngine = self.dataEngine("time")
self.model.connectToEngine(self.timeEngine)
def handleMessageChanged(self, newMessage):
'''Update the view when the message changes.'''
self.label.setText(newMessage)
self.update()
class Kountdown(plasmascript.Applet):
def __init__(self, parent, args=None):
plasmascript.Applet.__init__(self, parent)
def init(self):
self.setHasConfigurationInterface(True)
self.model = KountdownModel(self.configScheme())
if self.model.needsConfiguration:
self.setConfigurationRequired(True)
else:
self.setupMainUI()
self.resize(300, 125)
def setupMainUI(self):
print 'setup'
self.setAspectRatioMode(Plasma.IgnoreAspectRatio)
self.setBackgroundHints(Plasma.Applet.TranslucentBackground)
self.layout = QGraphicsLinearLayout(Qt.Vertical, self.applet)
self.label = Plasma.Label(self.applet)
self.label.setText(self.model.message)
self.label.setStyleSheet('''font-size: 18pt;''')
self.label.setAlignment(Qt.AlignCenter | Qt.AlignVCenter)
self.layout.addItem(self.label)
self.applet.setLayout(self.layout)
self.connectToEngine()
self.model.messageChanged.connect(self.handleMessageChanged)
def configChanged(self):
'''handle changes in configuration'''
plasmascript.Applet.configChanged(self)
self.updatedConfig()
def updatedConfig(self):
config = self.config()
if self.configurationRequired() and not self.model.needsConfiguration:
self.setConfigurationRequired(False)
self.setupMainUI()
def connectToEngine(self):
self.timeEngine = self.dataEngine("time")
self.model.connectToEngine(self.timeEngine)
def handleMessageChanged(self, newMessage):
'''Update the view when the message changes.'''
self.label.setText(newMessage)
self.update()
class rssWidget(plasmascript.Applet):
def __init__(self, parent, args=None):
plasmascript.Applet.__init__(self, parent)
def init(self):
self.setLayout()
self.startTimer(10000)
def timerEvent(self, evt):
setLabels(self.applet)
def setLayout(self):
global labels
self.layout = QGraphicsLinearLayout(Qt.Vertical, self.applet)
setLabels(self.applet)
for label in labels:
self.layout.addItem(label)
self.applet.setLayout(self.layout)
class weatherApplet(plasmascript.Applet):
def __init__(self,parent,args=None):
plasmascript.Applet.__init__(self,parent)
def init(self):
self.setHasConfigurationInterface(False)
self.setAspectRatioMode(Plasma.Square)
self.theme = Plasma.Svg(self)
self.theme.setImagePath("widgets/background")
self.setBackgroundHints(Plasma.Applet.DefaultBackground)
self.layout = QGraphicsLinearLayout(Qt.Horizontal, self.applet)
label = Plasma.Label(self.applet)
label.setText("Hello world!")
self.layout.addItem(label)
self.applet.setLayout(self.layout)
self.resize(125,125)
def showModalWidget(self,mainWidget):
#mainWidget.widgetClose.connect(self.destroyMessageOverlay)
if self.messageOverlay:
return
if self.messageDialog:
return
corona = self.scene()
mainWidget.adjustSize()
hint = mainWidget.preferredSize()
if (hint.height() > self.widget.size().height()) or (hint.width() > self.widget.size().width()):
## either a collapsed popup in h/v form factor or just too small,
## so show it in a dialog associated with ourselves
#pass
if (corona):
corona.addOffscreenWidget(mainWidget)
if (self.messageDialog):
pass
else:
self.messageDialog = Plasma.Dialog()
self.messageDialog.setGraphicsWidget(mainWidget)
mainWidget.setParentItem(self.messageDialog.graphicsWidget ())
else:
self.messageOverlay = self.createMessageOverlay()
self.formatOverlay()
self.messageOverlay.opacity = 0.8
mainWidget.setParentItem(self.messageOverlay)
l = QGraphicsLinearLayout(self.messageOverlay)
l.addItem(mainWidget)
if self.messageDialog:
pos = self.geometry().topLeft().toPoint()
if (corona):
pos = corona.popupPosition(self.applet, self.messageDialog.size())
self.messageDialog.move(pos)
#self.locationToDirection(self.location())
self.messageDialog.animatedShow(Plasma.Direction(0))
self.hidePopup()
else:
self.messageOverlay.show()
class CommandesApplet(plasmascript.Applet):
def __init__(self,parent,args=None):
plasmascript.Applet.__init__(self,parent)
def init(self):
self.setHasConfigurationInterface(False) #interface de configuration
self.setAspectRatioMode(Plasma.IgnoreAspectRatio) #Possibilité de redimensionner / Plasma.IgnoreAspectRatio
self.layout = QGraphicsLinearLayout(Qt.Horizontal, self.applet) #Création du layout
self.label = Plasma.Label(self.applet) #Création du label
self.layout.addItem(self.label) #Ajout du label au layout
#self.setMinimumWidth(1000) #Largeur minimum
#self.setMaximumHeight(900) #Hauteur maximum
self.startTimer(1000)
def timerEvent(self, event):
text = "%s" % os.popen(str('who')).read()
self.label.setText(text)
self.update()
class XMonadLogPlasmoid(plasmascript.Applet):
label_signal = QtCore.pyqtSignal(str)
session_bus = None
def __init__(self, parent, args=None):
plasmascript.Applet.__init__(self, parent)
def init(self):
global label
self.setHasConfigurationInterface(False)
self.setAspectRatioMode(Plasma.IgnoreAspectRatio)
self.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding))
self.setMinimumWidth(425)
self.layout = QGraphicsLinearLayout(Qt.Horizontal, self.applet)
label = Plasma.Label(self.applet)
label.setText("Waiting for XMonad...")
self.layout.addItem(label)
self.applet.setLayout(self.layout)
self.setup_dbus()
self.label_signal.connect(update_label)
def setup_dbus(self):
self.session_bus = dbus.SessionBus()
proxy = self.session_bus.get_object(
bus_name='org.xmonad.Log',
object_path='/org/xmonad/Log')
self.session_bus.add_signal_receiver(
handler_function=self.msg_receive,
signal_name='Update',
dbus_interface='org.xmonad.Log')
def msg_receive(self, msg):
self.label_signal.emit(msg)
class hwTempApp(plasmascript.Applet):
def __init__(self,parent,args=None):
plasmascript.Applet.__init__(self,parent)
def init(self):
global labels
self.setHasConfigurationInterface(False)
self.setAspectRatioMode(Plasma.Square)
self.theme = Plasma.Svg(self)
self.theme.setImagePath("widgets/background")
self.setBackgroundHints(Plasma.Applet.DefaultBackground)
self.layout = QGraphicsLinearLayout(Qt.Vertical, self.applet)
makeLabels(self.applet)
for label in labels:
self.layout.addItem(label)
self.applet.setLayout(self.layout)
self.startTimer(8000)
self.resize(400,200)
def timerEvent(self,evt):
strings = getStrings()
updateLabels(strings)
class XMonadLogPlasmoid(plasmascript.Applet):
label_signal = QtCore.pyqtSignal(str)
session_bus = None
def __init__(self, parent, args=None):
plasmascript.Applet.__init__(self, parent)
def init(self):
global label
self.setHasConfigurationInterface(False)
self.setAspectRatioMode(Plasma.IgnoreAspectRatio)
self.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding))
self.setMinimumWidth(425)
self.layout = QGraphicsLinearLayout(Qt.Horizontal, self.applet)
label = Plasma.Label(self.applet)
label.setText("Waiting for XMonad...")
self.layout.addItem(label)
self.applet.setLayout(self.layout)
self.setup_dbus()
self.label_signal.connect(update_label)
def setup_dbus(self):
self.session_bus = dbus.SessionBus()
proxy = self.session_bus.get_object(bus_name='org.xmonad.Log',
object_path='/org/xmonad/Log')
self.session_bus.add_signal_receiver(handler_function=self.msg_receive,
signal_name='Update',
dbus_interface='org.xmonad.Log')
def msg_receive(self, msg):
self.label_signal.emit(msg)
class hwTempApp(plasmascript.Applet):
def __init__(self, parent, args=None):
plasmascript.Applet.__init__(self, parent)
def init(self):
global labels
self.setHasConfigurationInterface(False)
self.setAspectRatioMode(Plasma.Square)
self.theme = Plasma.Svg(self)
self.theme.setImagePath("widgets/background")
self.setBackgroundHints(Plasma.Applet.DefaultBackground)
self.layout = QGraphicsLinearLayout(Qt.Vertical, self.applet)
makeLabels(self.applet)
for label in labels:
self.layout.addItem(label)
self.applet.setLayout(self.layout)
self.startTimer(8000)
self.resize(400, 200)
def timerEvent(self, evt):
strings = getStrings()
updateLabels(strings)
def init(self):
# Fill space if in a horizontal panel.
self.setSizePolicy(QSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Preferred))
layout = QGraphicsLinearLayout(Qt.Horizontal, self.applet)
layout.setContentsMargins(0, 0, 0, 0)
self.applet.setLayout(layout)
self.icon = Plasma.IconWidget(self.applet)
self.label = Plasma.Label(self.applet)
# TODO: Improve handling of very long window titles.
self.label.setWordWrap(False)
layout.addItem(self.icon)
layout.addItem(self.label)
layout.setStretchFactor(self.label, 1)
# Reasonable default size -- can be resized later by user.
self.resize(500, 30)
self.refreshTimer = QTimer()
self.refreshTimer.setInterval(I3STATUS_REFRESH_INTERVAL)
self.refreshTimer.timeout.connect(self.reloadI3statusText)
self.statusIterator = execute(["i3status"])
self.refreshTimer.start()
self.windowChangeTimer = QTimer()
self.windowChangeTimer.setSingleShot(True)
self.windowChangeTimer.setInterval(TITLE_DISPLAY_TIMEOUT)
self.windowChangeTimer.timeout.connect(self.hideTitleText)
KWindowSystem.self().windowRemoved.connect(self.windowRemoved)
KWindowSystem.self().windowChanged.connect(self.windowChanged)
KWindowSystem.self().activeWindowChanged.connect(
self.activeWindowChanged)
class TurnOffScreen(plasmascript.Applet):
def __init__(self, parent, args=None):
plasmascript.Applet.__init__(self, parent)
def init(self):
#TODO: have a configuration interface to set keybroad shortcut
#self.setHasConfigurationInterface(True)
self.setAspectRatioMode(Plasma.ConstrainedSquare)
self.setBackgroundHints(self.NoBackground)
self.sessionBus = dbus.SessionBus()
self.powerdevil = self.sessionBus.get_object(
'org.freedesktop.PowerManagement', '/modules/powerdevil')
self.icon = Plasma.IconWidget(KIcon('preferences-desktop-screensaver'),
'', self.applet)
if KGlobalSettings.singleClick():
self.connect(self.icon, SIGNAL('clicked()'), self.turn_off_screen)
else:
self.connect(self.icon, SIGNAL('doubleClicked()'),
self.turn_off_screen)
self.connect(self, SIGNAL('active()'), self.turn_off_screen)
self.layout = QGraphicsLinearLayout(self.applet)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.setSpacing(0)
self.layout.addItem(self.icon)
self.setLayout(self.layout)
self.resize(25, 25)
#def showConfigurationInterface(self):
# self.con_short = KShortcutWidget(None)
# self.con_short.show()
def turn_off_screen(self):
self.powerdevil.turnOffScreen(dbus_interface='org.kde.PowerDevil')
class Karmack4(plasmascript.Applet):
def __init__(self, parent, args=None):
plasmascript.Applet.__init__(self, parent)
def init(self):
self.applet.resize(480.0, 300.0)
qmlView = Plasma.DeclarativeWidget()
qmlView.setQmlPath("karmack4/contents/ui/main.qml")
self.layout = QGraphicsLinearLayout(self.applet)
self.layout.setOrientation(Qt.Vertical)
self.layout.addItem(qmlView)
helloLabel = Plasma.Label(self.applet)
helloLabel.setText(PYQT_VERSION_STR)
self.layout.addItem(helloLabel)
buttonek = Plasma.PushButton(self.applet)
buttonek.setText("Klikni a uvidis!")
self.layout.addItem(buttonek)
self.qmlRootObject = qmlView.rootObject()
self.connect(buttonek, SIGNAL("clicked()"), self.buttonClicked)
self.connect(KWindowSystem.self(), SIGNAL("windowAdded(WId)"), self.onWokynkoNove)
self.connect(KWindowSystem.self(), SIGNAL("windowRemoved(WId)"), self.onWokynkoFuc)
def buttonClicked(self):
#print dir(self.qmlRootObject)
self.qmlRootObject.updateQml()
def onWokynkoNove(self):
self.qmlRootObject.windowAdded()
def onWokynkoFuc(self):
self.qmlRootObject.windowRemoved()
class PylouWidget(QGraphicsWidget):
"""Main Widget for Pylou."""
def __init__(self, parent):
"""Init class."""
QGraphicsWidget.__init__(self)
self.applet = parent
def init(self):
"""Start Pylou Widget."""
self.layou = QGraphicsLinearLayout(self)
self.stringlist = QStringList()
self.model = QStringListModel(self.applet)
self.model.setStringList(self.stringlist)
self.treeview = MyTreeView(self)
self.treeview.setModel(self.model)
self.lineEdit, self.label = MyLineEdit(self), Plasma.Label(self)
self.label.setText("Search")
self.layou.setOrientation(0x2) # Qt.Vertical
self.layou.addItem(self.treeview)
self.layou.addItem(self.label)
self.layou.addItem(self.lineEdit)
self.setLayout(self.layou)
self.lineEdit.returnPressed.connect(self.addItem)
self.setMinimumSize(200, 99)
self.setMaximumSize(666, 666)
# custom user choosed fonts
user_font_family = QVariant(self.applet.configurations.readEntry(
"TextFont", QVariant(QFont())))
self.treeview.nativeWidget().setFont(QFont(user_font_family))
# custom user choosed styles
user_style_sheet = "color:{};alternate-background-color:{}".format(
self.applet.configurations.readEntry("TextColor"),
self.applet.configurations.readEntry("AlternateBColor"))
self.treeview.nativeWidget().setStyleSheet(user_style_sheet)
# Qt connecting people
Applet.connect(
self.lineEdit, SIGNAL("keyUPPressed"), self.prevHistoryItem)
Applet.connect(
self.lineEdit, SIGNAL("keyDownPressed"), self.nextHistoryItem)
Applet.connect(self.treeview, SIGNAL("DblClick"), self.openFile)
Applet.connect(self.treeview, SIGNAL("Click"), self.openDirectory)
self.applet.appletDestroyed.connect(self.saveHistory)
# History file
self.histfile = HISTORY_FILE_PATH
with open(self.histfile, 'r') as history_file:
self.history = history_file.readlines()
self.historyCurrentItem = 0
self.treeview.nativeWidget().hide()
self.resize(self.minimumSize())
def saveHistory(self):
"""Write History to History file."""
with open(self.histfile, 'w') as history_file:
history_file.writelines(self.history)
def prevHistoryItem(self):
"""Navigate the History 1 Item Backwards."""
if self.historyCurrentItem < len(self.history):
self.historyCurrentItem = self.historyCurrentItem + 1
try:
self.lineEdit.setText(str(self.history[-self.historyCurrentItem]))
except IndexError as error:
print(error)
self.label.setText("ERROR: History Empty.")
def nextHistoryItem(self):
"""Navigate the History 1 Item Forwards."""
if self.historyCurrentItem > 1:
self.historyCurrentItem = self.historyCurrentItem - 1
try:
self.lineEdit.setText(str(self.history[-self.historyCurrentItem]))
except IndexError as error:
print(error)
self.label.setText("ERROR: History Empty.")
def addItem(self):
"""Add Items from Locate command."""
start_time = datetime.now().second
self.stringlist.clear()
lineText = self.lineEdit.text()
if len(lineText) and str(lineText).strip() not in self.history:
self.history.append(lineText + "\n")
self.historyCurrentItem = 1
self.saveHistory()
self.historyCurrentItem = self.historyCurrentItem - 1
command = "ionice --ignore --class 3 chrt --idle 0 " # Nice CPU / IO
command += "locate --ignore-case --existing --quiet --limit 9999 {}"
condition = str(self.applet.configurations.readEntry("Home")) == "true"
if len(str(lineText).strip()) and condition:
command_to_run = command.format( # Only Search inside Home folders
path.join(path.expanduser("~"), "*{}*".format(lineText)))
else:
command_to_run = command.format(lineText)
locate_output = Popen(command_to_run, shell=True, stdout=PIPE).stdout
results = tuple(locate_output.readlines())
banned = self.applet.configurations.readEntry("Banned")
banned_regex_pattern = str(banned).strip().lower().replace(" ", "|")
for item in results:
if not search(banned_regex_pattern, str(item)): # banned words
self.stringlist.append(item[:-1])
purge() # Purge RegEX Cache
self.model.setStringList(self.stringlist)
self.treeview.nativeWidget().resizeColumnToContents(0)
number_of_results = len(results)
if number_of_results: # if tems found Focus on item list
self.lineEdit.nativeWidget().clear()
self.label.setText("Found {} results on {} seconds !".format(
number_of_results, abs(datetime.now().second - start_time)))
self.resize(500, 12 * number_of_results)
self.treeview.nativeWidget().show()
self.treeview.nativeWidget().setFocus()
else: # if no items found Focus on LineEdit
self.label.setText("Search")
self.resize(self.minimumSize())
self.treeview.nativeWidget().hide()
self.lineEdit.nativeWidget().selectAll()
self.lineEdit.nativeWidget().setFocus()
def openDirectory(self, index):
"""Take a model index and find the folder name then open the folder."""
item_to_open = path.dirname(str(self.model.data(index, 0).toString()))
Popen("xdg-open '{}'".format(item_to_open), shell=True)
def openFile(self, index):
"""Take a model index and find the filename then open the file."""
item_to_open = self.model.data(index, 0).toString()
Popen("xdg-open '{}'".format(item_to_open), shell=True)
class Channel(QGraphicsWidget):
def __init__(self , parent):
QGraphicsWidget.__init__(self)
self.veromix = parent
self.index = -1
self.pa = parent.getPulseAudio()
self.set_name("")
self.deleted = True
self.pa_sink = None
self.extended_panel_shown = False
self.extended_panel= None
self.show_meter = True
self.expander = None
self.popup_menu = None
self.card_settings = None
self.menus = None
self.port_actions = None
self.double_click_filter = ChannelEventFilter(self)
self.installEventFilter(self.double_click_filter)
self.init()
self.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed,True))
def init(self):
self.layout = QGraphicsLinearLayout(Qt.Vertical)
self.layout.setContentsMargins(2,2,2,0)
self.setLayout(self.layout)
self.initArrangement()
self.composeArrangement()
self.setAcceptDrops(True)
self._on_upate_expander_enabled()
def initArrangement(self):
self.create_frame()
self.create_panel()
self.createMute()
self.createMiddle()
self.create_expander()
def composeArrangement(self):
self.layout.addItem(self.frame)
self.frame_layout.addItem(self.panel)
self.panel_layout.addItem(self.mute)
self.panel_layout.addItem(self.middle)
def create_frame(self):
self.frame = Plasma.Frame()
self.frame_layout = QGraphicsLinearLayout(Qt.Vertical)
self.frame.setEnabledBorders (Plasma.FrameSvg.NoBorder)
self.frame.setFrameShadow(Plasma.Frame.Plain)
self.frame_layout.setContentsMargins(0,0,0,0)
self.frame.setLayout(self.frame_layout)
def create_panel(self):
self.panel = QGraphicsWidget()
self.panel_layout = QGraphicsLinearLayout(Qt.Horizontal)
self.panel_layout.setContentsMargins(6,8,10,6)
self.panel.setLayout(self.panel_layout)
def createMute(self):
self.mute = MuteButton(self)
self.connect(self.mute, SIGNAL("clicked()"), self.on_mute_cb)
def createMiddle(self):
self.middle = QGraphicsWidget()
self.middle_layout = QGraphicsLinearLayout(Qt.Vertical)
#self.middle_layout.setContentsMargins(6,8,6,0)
self.middle_layout.setContentsMargins(0,0,0,0)
self.middle.setLayout(self.middle_layout)
self.middle.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum))
self.createSlider()
self.middle_layout.addItem(self.slider)
def createSlider(self):
self.slider = MeterSlider(None, self.veromix.is_slider_unit_value_visible())
self.slider.installEventFilter(self.double_click_filter)
self.slider.set_meter_visible(self.veromix.is_meter_visible())
self.slider.setOrientation(Qt.Horizontal)
self.slider.setMaximum(self.veromix.get_max_volume_value())
self.slider.setMinimum(0)
self.slider.volumeChanged.connect( self.on_slider_cb)
def create_expander(self):
self.expander = Plasma.IconWidget(self.panel)
self.expander.setZValue(10)
self.connect(self, SIGNAL("geometryChanged()"), self._resize_widgets)
self.expander.setSizePolicy(QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed))
self.expander.clicked.connect(self.on_expander_clicked)
self.expander.setSvg("widgets/arrows", "left-arrow")
def create_context_menu(self, event):
self.popup_menu = QMenu()
self.popup_menu.triggered.connect(self.on_contextmenu_clicked)
self.context_menu_create_custom()
self.context_menu_create_mute()
self.context_menu_create_meter()
self.context_menu_create_unlock_channels()
self.context_menu_create_effects()
self.create_menu_kill_sink()
self.context_menu_create_settings()
if event:
self.popup_menu.exec_(event.screenPos())
else:
self.popup_menu.exec_(QCursor.pos())
def context_menu_create_mute(self):
action_mute = QAction(i18n("Muted"), self.popup_menu)
self.popup_menu.addAction(action_mute)
action_mute.setCheckable(True)
action_mute.setChecked(self.isMuted())
action_mute.triggered.connect(self.on_mute_cb)
def context_menu_create_meter(self):
action_meter = QAction(i18n("Volume meter"), self.popup_menu)
self.popup_menu.addAction(action_meter)
action_meter.setCheckable(True)
action_meter.setChecked(self.pa_sink.has_monitor())
action_meter.triggered.connect(self.on_meter_cb)
def context_menu_create_unlock_channels(self):
action_unlock = QAction(i18n("Unlock channels"), self.popup_menu)
self.popup_menu.addAction(action_unlock)
action_unlock.setCheckable(True)
action_unlock.setChecked(self.extended_panel_shown)
action_unlock.triggered.connect(self.toggle_channel_lock)
def context_menu_create_ports(self):
self.port_actions = {}
if len(self.pa_sink.ports.keys()) > 1:
ports_menu = QMenu(i18n("Ports"), self.popup_menu)
ports = self.pa_sink.ports
for port in ports.keys():
action = QAction(in_unicode(ports[port]), self.popup_menu)
self.port_actions[action]=port
if port == self.pa_sink.active_port:
action.setCheckable(True)
action.setChecked(True)
else:
action.setChecked(False)
action.setCheckable(False)
ports_menu.addAction(action)
self.popup_menu.addMenu(ports_menu)
def create_menu_kill_sink(self):
pass
def context_menu_create_sounddevices(self):
self.card_settings = {}
self.menus = []
for card in self.veromix.card_infos.values():
current = self.veromix.get_card_info_for(self)
if current != None and current.get_description() == card.get_description():
card_menu = QMenu(i18n("Profile"), self.popup_menu)
self.popup_menu.addMenu(card_menu)
else:
card_menu = QMenu(card.get_description(), self.popup_menu)
self.menus.append(card_menu)
active_profile_name = card.get_active_profile_name()
self.profiles = card.get_profiles()
for profile in self.profiles:
action = QAction(in_unicode(profile.description), card_menu)
self.card_settings[action] = card
if profile.name == active_profile_name:
action.setCheckable(True)
action.setChecked(True)
card_menu.addAction(action)
def context_menu_create_sounddevices_other(self):
if len(self.menus) > 0:
self.popup_menu.addSeparator()
for each in self.menus:
self.popup_menu.addMenu(each)
def context_menu_create_custom(self):
pass
def context_menu_create_effects(self):
pass
def context_menu_create_settings(self):
self.popup_menu.addSeparator()
action_settings = QAction(i18n("Veromix Settings"), self.popup_menu)
self.popup_menu.addAction(action_settings)
action_settings.triggered.connect(self.veromix.applet.showConfigurationInterface)
def _resize_widgets(self):
self.expander.setPos(int(self.panel.size().width() - self.expander.size().width()) ,0)
def on_double_clicked(self):
self.slider.toggle_meter()
self.pa_sink.toggle_monitor()
self.slider.set_meter_value(0)
def on_step_volume(self, up):
vol = self.pa_sink.get_volume()
STEP = 5
if up:
vol = vol + STEP
else:
vol = vol - STEP
if vol < 0:
vol = 0
if vol > self.veromix.get_max_volume_value():
vol = self.veromix.get_max_volume_value()
self.setVolume(vol)
def setVolume(self, value):
vol = self.pa_sink.volumeDiffFor(value)
if self.veromix.get_auto_mute():
for c in vol:
if c <= 0:
## FIXME HACK for MurzNN this should be conditional
self.pa.set_sink_mute(self.index, True)
self.automatically_muted = True
return
if self.automatically_muted :
self.automatically_muted = False
self.pa.set_sink_mute(self.index, False)
self.set_channel_volumes(vol)
def get_volume(self):
if self.pa_sink:
return self.pa_sink.get_volume()
return [0]
def on_expander_clicked(self):
self.contextMenuEvent(None)
def toggle_channel_lock(self):
self.middle_layout.removeItem(self.slider)
self.slider = None
if (self.extended_panel_shown):
self.extended_panel_shown = False
self.expander.setSvg("widgets/arrows", "left-arrow")
self.createSlider()
self.middle_layout.addItem(self.slider)
else:
self.extended_panel_shown = True
self.expander.setSvg("widgets/arrows", "down-arrow")
self.slider = SinkChannelWidget(self.veromix, self)
self.slider.installEventFilter(self.double_click_filter)
self.middle_layout.addItem(self.slider)
self.middle_layout.setContentsMargins(0,0,0,0)
self.middle.setContentsMargins(0,0,0,0)
self.update_with_info(self.pa_sink)
self.veromix.check_geometries()
def on_update_configuration(self):
self.slider.set_meter_visible(self.veromix.is_meter_visible())
self.slider.setMaximum(self.veromix.get_max_volume_value())
self.slider.set_unit_value_visible(self.veromix.is_slider_unit_value_visible())
self._on_upate_expander_enabled()
def _on_upate_expander_enabled(self):
if self.veromix.is_expander_enabled():
self.expander.show()
else:
self.expander.hide()
def on_contextmenu_clicked(self, action):
if action in self.card_settings.keys():
card = self.card_settings[action]
for profile in card.get_profiles():
if action.text() == profile.description:
self.veromix.pa.set_card_profile(card.index, profile.name)
if action in self.port_actions.keys():
self.pa_sink.set_port(self.port_actions[action])
def contextMenuEvent(self,event):
self.create_context_menu(event)
def on_mute_cb(self):
self.pa_sink.toggle_mute()
def on_meter_cb(self):
self.on_double_clicked()
def sink_input_kill(self):
self.pa_sink.kill()
def set_channel_volumes(self, values):
self.pa_sink.set_volume(values)
def on_update_meter(self, index, value, number_of_sinks):
if self.index == index:
self.slider.set_meter_value(int(value))
def update_with_info(self,info):
self.pa_sink = info
self.index = info.index
self.update_label()
self.updateIcon()
if self.slider:
self.slider.update_with_info(info)
if self.extended_panel:
self.extended_panel.update_with_info(info)
self.update()
def update_label(self):
if self.pa_sink:
self.set_name(self.pa_sink.name)
def getOutputIndex(self):
return self.index
def sinkIndexFor( self, index):
return (index * 100000) + 100000
def updateIcon(self):
pass
def on_slider_cb(self, value):
self.setVolume(value)
def isDefaultSink(self):
if self.pa_sink and "isdefault" in self.pa_sink.props:
return self.pa_sink.props["isdefault"] == "True"
return False
def startDrag(self,event):
pass
def removeSlider(self):
# if a slider is not visible, plasmoidviewer crashes if the slider is not removed.. (dont ask me)
if self.slider:
self.middle_layout.removeItem(self.slider)
self.slider = None
def isMuted(self):
if self.pa_sink:
return self.pa_sink.isMuted()
return False
def isSinkOutput(self):
if self.pa_sink:
return self.pa_sink.is_sinkoutput()
return False
def isSinkInput(self):
if self.pa_sink:
return self.pa_sink.is_sinkinput()
return False
def isSink(self):
if self.pa_sink:
return self.pa_sink.is_sink()
return False
def isNowplaying(self):
return False
def isSourceOutput(self):
if self.pa_sink:
return self.pa_sink.is_sourceoutput()
return False
def wheelEvent(self, event):
if self.slider:
self.slider.wheelEvent(event)
def set_name(self, string):
self._name = in_unicode(string)
def name(self):
return self._name
def update_module_info(self, index, name, argument, n_used, auto_unload):
pass
def get_ladspa_type(self):
return str(type(self))
def get_pasink_name(self):
return self.pa_sink.name
## LADSPA helpers
def populate_presets_menu(self, target_menu, checked_item, add_actions):
effect_menu = QMenu(i18n("Presets"), target_menu)
if add_actions:
self.action_save_preset = QAction(i18n("Save"),effect_menu)
effect_menu.addAction(self.action_save_preset)
if not self.is_preset():
self.action_save_preset.setEnabled(False)
self.action_save_as_preset = QAction(i18n("Save As..."),effect_menu)
effect_menu.addAction(self.action_save_as_preset)
effect_menu.addSeparator()
for preset in LADSPAPresetLoader().presets():
action = QAction(preset["preset_name"],effect_menu)
effect_menu.addAction(action)
if checked_item == preset["preset_name"]:
action.setCheckable(True)
action.setChecked(True)
action.setEnabled(False)
target_menu.addMenu(effect_menu)
def populate_switch_effect_menu(self, target_menu, checked_item):
effect_menu = QMenu(i18n("Effect"), target_menu)
for preset in LADSPAEffects().effects():
action = QAction(preset["preset_name"],effect_menu)
effect_menu.addAction(action)
if checked_item == preset["label"]:
action.setCheckable(True)
action.setChecked(True)
action.setEnabled(False)
target_menu.addMenu(effect_menu)
def on_set_ladspa_effect(self, value, master):
parameters = ""
preset = None
for p in LADSPAEffects().effects():
if p["preset_name"] == value:
parameters = "sink_name=" + urllib.quote(p["name"])
preset = p
for p in LADSPAPresetLoader().presets():
if p["preset_name"] == value:
parameters = "sink_name=" + urllib.quote(p["preset_name"])
preset = p
parameters = parameters + " master=" + master + " "
parameters = parameters + " plugin=" + preset["plugin"]
parameters = parameters + " label=" + preset["label"]
parameters = parameters + " control=" + preset["control"]
self.pa_sink.set_ladspa_sink(parameters)
def next_focus(self, forward=True):
channels = self.veromix.get_visible_channels()
if len(channels) > 0:
index = 0
if self in channels:
index = channels.index(self)
if forward:
index = index + 1
if index >= len(channels):
index = 0
else:
index = index - 1
if index < 0:
index = len(channels) - 1
channels[index].set_focus()
def set_focus(self):
self.slider.set_focus()
def pa_sink_proxy(self):
return self.pa_sink
class ForecastModule:
def __init__(self):
self.name = "Napoved"
self.updateTimer = QTimer()
self.updateTimer.timeout.connect(self.update)
def makeLayout(self):
self.layout = QGraphicsLinearLayout(Qt.Vertical)
self.forecastTopLayout = QGraphicsLinearLayout(Qt.Horizontal)
#Forecast Layout
self.forecastIcons = [QGraphicsWebView() for i in range(4)]
[v.setEnabled(False) for v in self.forecastIcons]
[v.setMaximumSize(40,40) for v in self.forecastIcons]
[v.setMinimumSize(40,40) for v in self.forecastIcons]
[v.page().mainFrame().setScrollBarPolicy(Qt.Horizontal, Qt.ScrollBarAlwaysOff) for v in self.forecastIcons]
[v.page().mainFrame().setScrollBarPolicy(Qt.Vertical, Qt.ScrollBarAlwaysOff) for v in self.forecastIcons]
self.forecastDays = [Plasma.Label() for i in range(4)]
[l.setAlignment(Qt.AlignCenter) for l in self.forecastDays]
self.forecastTemperatures = [Plasma.Label() for i in range(4)]
[l.setAlignment(Qt.AlignCenter) for l in self.forecastTemperatures]
self.forecastIconFrames = [QGraphicsLinearLayout(Qt.Horizontal) for i in range(4)]
[self.forecastIconFrames[i].addStretch() for i in range(4)]
[self.forecastIconFrames[i].addItem(self.forecastIcons[i]) for i in range(4)]
[self.forecastIconFrames[i].addStretch() for i in range(4)]
self.forecastFrames = [QGraphicsLinearLayout(Qt.Vertical) for i in range(4)]
[self.forecastFrames[i].addStretch() for i in range(4)]
[self.forecastFrames[i].addItem(self.forecastDays[i]) for i in range(4)]
[self.forecastFrames[i].addItem(self.forecastIconFrames[i]) for i in range(4)]
[self.forecastFrames[i].addItem(self.forecastTemperatures[i]) for i in range(4)]
[self.forecastFrames[i].addStretch() for i in range(4)]
self.forecastTopFrame = QGraphicsLinearLayout(Qt.Horizontal)
self.forecastTopFrame.addStretch()
self.forecastTopFrame.addItem(self.forecastFrames[0])
self.forecastTopFrame.addStretch()
self.forecastBottomFrames = QGraphicsLinearLayout(Qt.Horizontal)
self.forecastBottomFrames.addStretch()
[self.forecastBottomFrames.addItem(self.forecastFrames[i]) for i in range(1,4)]
self.forecastBottomFrames.addStretch()
self.forecastRefreshButton = Plasma.IconWidget()
self.forecastRefreshButton.setIcon("view-refresh")
self.forecastRefreshButton.clicked.connect(self.update)
self.forecastStatusLabel = Plasma.Label()
self.forecastTopLayout.addItem(self.forecastStatusLabel)
self.forecastTopLayout.addItem(self.forecastRefreshButton)
self.forecastTopLayout.setMaximumHeight(32)
self.forecastUpdateTimeSelector = UpdateTimeSelector()
self.forecastUpdateTimeSelector.setDefaultTime(4)
self.forecastUpdateTimeSelector.setDefaultInterval('h')
self.forecastUpdateTimeSelector.updateTimeSpin.valueChanged.connect(self.forecastTimeChanged)
self.forecastUpdateTimeSelector.updateCheckBox.toggled.connect(self.forecastTimerToggle)
self.layout.addItem(self.forecastTopLayout)
self.layout.addStretch()
self.layout.addItem(self.forecastTopFrame)
self.layout.addItem(self.forecastBottomFrames)
self.layout.addStretch()
self.layout.addItem(self.forecastUpdateTimeSelector.layout)
def forecastTimerToggle(self, toggled):
if toggled:
multiplier = 1
if self.forecastUpdateTimeSelector.getInterval() == 'min':
multiplier = 60
if self.forecastUpdateTimeSelector.getInterval() == 'h':
multiplier = 60 * 60
self.updateTimer.start(self.forecastUpdateTimeSelector.getTime() * 1000 * multiplier)
self.update()
else:
self.updateTimer.stop()
def forecastTimeChanged(self, value):
if self.forecastUpdateTimeSelector.isChecked():
self.updateTimer.stop()
self.forecastTimerToggle(self.forecastUpdateTimeSelector.isChecked())
def update(self):
forecast = NoForecast()
forecastData = forecast.getData()
date = forecast.getForecastDate()
try:
urllib.urlopen('http://www.google.com', timeout=2)
forecast = BohinjForecast()
forecastData = forecast.getData()
date = forecast.getForecastDate()
except:
self.offlineMode()
return
date = date.split('-')
try:
self.forecastStatusLabel.setText(u"Bohinj, napoved dne <b>%s.%s.%s</b>" % (date[2], date[1], date[0]))
except:
pass
for i in range(4):
self.forecastDays[i].setText(u'<b>' + forecastData[i].day + u'</b>')
self.forecastIcons[i].setUrl(QUrl(forecastData[i].icon))
self.forecastTemperatures[i].setText(u"<b>%s</b> | <b>%s</b>" % (forecastData[i].low, forecastData[i].high))
def offlineMode(self):
self.forecastStatusLabel.setText(u"Bohinj, napoved ni na voljo.")
[a.setUrl(QUrl("weather-none-available.png")) for a in self.forecastIcons]
for i in range(4):
self.forecastTemperatures[i].setText(u"<b>N/A</b>")
self.forecastDays[i].setText(u'<b>N/A</b>')
class WeatherApplet(plasmascript.Applet):
def __init__(self, parent, args=None):
plasmascript.Applet.__init__(self, parent)
self._unit = "SI"
self._image_prefix = ":/images/"
self._img_width = 16
self._img_height = 16
self._big_img_width = 48
self._big_img_height = 48
self._fc_column_width = 100
def init(self):
self.setHasConfigurationInterface(False)
self.setAspectRatioMode(Plasma.IgnoreAspectRatio)
self.theme = Plasma.Svg(self)
self.theme.setImagePath("widgets/background")
self.setBackgroundHints(Plasma.Applet.DefaultBackground)
# self.layout = QGraphicsLinearLayout(Qt.Vertical, self.applet)
self.layout_main = QGraphicsGridLayout(self.applet)
self.layout_top_left = QGraphicsLinearLayout(Qt.Vertical, self.layout_main)
self.layout_bottom = QGraphicsGridLayout(self.layout_main)
self.layout_bottom.setColumnMaximumWidth(0, self._fc_column_width)
self.layout_bottom.setColumnMaximumWidth(1, self._fc_column_width)
self.layout_bottom.setColumnMaximumWidth(2, self._fc_column_width)
self.lb_location = Plasma.Label(self.applet)
self.lb_temperature = Plasma.Label(self.applet)
self.lb_condition = Plasma.Label(self.applet)
self.lb_humidity = Plasma.Label(self.applet)
self.lb_wind = Plasma.Label(self.applet)
# create svg widgets for conditions
self.svg_w_current = Plasma.SvgWidget(self.applet)
self.svg_w_fc1 = Plasma.SvgWidget(self.applet)
self.svg_w_fc2 = Plasma.SvgWidget(self.applet)
self.svg_w_fc3 = Plasma.SvgWidget(self.applet)
# self.svg_w_fc1.resize(self._img_width,self._img_height)
# create labels for forecast
self.lb_temp_fc1 = Plasma.Label(self.applet)
self.lb_temp_fc2 = Plasma.Label(self.applet)
self.lb_temp_fc3 = Plasma.Label(self.applet)
self.lb_day_fc1 = Plasma.Label(self.applet)
self.lb_day_fc2 = Plasma.Label(self.applet)
self.lb_day_fc3 = Plasma.Label(self.applet)
# create images to display conditions
self.svg_current = Plasma.Svg(self.applet)
self.svg_fc1 = Plasma.Svg(self.applet)
self.svg_fc2 = Plasma.Svg(self.applet)
self.svg_fc3 = Plasma.Svg(self.applet)
self.layout_main.addItem(self.layout_top_left, 0, 0)
self.layout_main.addItem(self.svg_w_current, 0, 1)
self.layout_main.addItem(self.layout_bottom, 1, 0, 1, 2, Qt.Alignment(Qt.AlignCenter))
# add current conditions
self.layout_top_left.addItem(self.lb_location)
self.layout_top_left.addItem(self.lb_temperature)
self.layout_top_left.addItem(self.lb_condition)
self.layout_top_left.addItem(self.lb_humidity)
self.layout_top_left.addItem(self.lb_wind)
# add forecast labels for days
self.layout_bottom.addItem(self.lb_day_fc1, 0, 0, 1, 1, Qt.Alignment(Qt.AlignHorizontal_Mask))
self.layout_bottom.addItem(self.lb_day_fc2, 0, 1, 1, 1, Qt.Alignment(Qt.AlignHCenter))
self.layout_bottom.addItem(self.lb_day_fc3, 0, 2, 1, 1, Qt.Alignment(Qt.AlignHCenter))
# add forecast images
self.layout_bottom.addItem(self.svg_w_fc1, 1, 0, 1, 1, Qt.Alignment(Qt.AlignLeft))
self.layout_bottom.addItem(self.svg_w_fc2, 1, 1, 1, 1, Qt.Alignment(Qt.AlignLeft))
self.layout_bottom.addItem(self.svg_w_fc3, 1, 2, 1, 1, Qt.Alignment(Qt.AlignLeft))
# add forecast labels for temp
self.layout_bottom.addItem(self.lb_temp_fc1, 2, 0, 1, 1, Qt.Alignment(Qt.AlignCenter))
self.layout_bottom.addItem(self.lb_temp_fc2, 2, 1, 1, 1, Qt.Alignment(Qt.AlignCenter))
self.layout_bottom.addItem(self.lb_temp_fc3, 2, 2, 1, 1, Qt.Alignment(Qt.AlignCenter))
self.setLayout(self.layout_main)
self.resize(375, 375)
self.checkWeather()
self.timer = QTimer()
self.connect(self.timer, SIGNAL("timeout()"), self.checkWeather)
self.timer.start(0.5 * 60000)
def checkWeather(self):
wi = WeatherInfo()
mapper = ConditionMapper()
wi.parse()
weather = Weather()
weather.extractData(wi, self._unit)
self.lb_location.setText("Location: " + weather.location)
self.lb_temperature.setText(weather.current_temperature)
self.lb_condition.setText("Condition: " + weather.current_condition)
self.lb_humidity.setText(weather.current_humidity)
self.lb_wind.setText(weather.current_wind)
# current condition image
self.svg_current.setImagePath(self._image_prefix + mapper.getMappedImageName(weather.current_condition))
self.svg_current.resize(self._big_img_width, self._big_img_height)
self.svg_w_current.setSvg(self.svg_current)
# load forecast days
fc_day = weather.fc_dl[0]
# self.lb_day_fc1.setText("Tomorrow")
self.lb_day_fc1.setText(fc_day)
fc_day = weather.fc_dl[1]
self.lb_day_fc2.setText(fc_day)
fc_day = weather.fc_dl[2]
self.lb_day_fc3.setText(fc_day)
# load forecast images
fc = weather.fc_conditions[0]
print fc
self.svg_fc1.setImagePath(self._image_prefix + mapper.getMappedImageName(fc))
self.svg_fc1.resize(self._img_width, self._img_height)
self.svg_w_fc1.setSvg(self.svg_fc1)
fc = weather.fc_conditions[1]
print fc
self.svg_fc2.setImagePath(self._image_prefix + mapper.getMappedImageName(fc))
self.svg_fc2.resize(self._img_width, self._img_height)
self.svg_w_fc2.setSvg(self.svg_fc2)
fc = weather.fc_conditions[2]
print fc
self.svg_fc3.setImagePath(self._image_prefix + mapper.getMappedImageName(fc))
self.svg_fc3.resize(self._img_width, self._img_height)
self.svg_w_fc3.setSvg(self.svg_fc3)
self.lb_temp_fc1.setText(weather.fc_low_high[0])
self.lb_temp_fc2.setText(weather.fc_low_high[1])
self.lb_temp_fc3.setText(weather.fc_low_high[2])
# self.layout.addItem(label)
# self.setLayout(self.layout)
self.update()
class CurrencyConverter(QGraphicsWidget):
updated = pyqtSignal()
def __init__(self,parent):
QGraphicsWidget.__init__(self)
self.applet = parent
def init(self):
print ("CurrencyConverter: init")
self.swapping = False
self.grid_layout = None
self.timer = None
self.last_updated = ""
self.def_from = self.applet.cfg.readEntry("default_from", QString("USD")).toString()
print "System default country:", KGlobal.locale().country()
print "System default currency code:", KGlobal.locale().currencyCode()
self.def_to = self.applet.cfg.readEntry("default_to", KGlobal.locale().currencyCode()).toString()
#self.def_to = self.applet.cfg.readEntry("default_to", QString("EUR")).toString()
self.def_amount = self.applet.cfg.readEntry("default_amount", 1.0).toString()
self.update_interval = self.applet.cfg.readEntry("update_interval", QVariant(60)).toInt()[0] # why does this return a tuple?
print "Update interval:", self.update_interval
#self.theme = Plasma.Svg(self)
#self.theme.setImagePath("widgets/background")
#self.setBackgroundHints(Plasma.Applet.DefaultBackground)
# init arrows svg
#self.arrows_svg = Plasma.Svg(self);
#self.arrows_svg.setImagePath("widgets/configuration-icons");
#self.arrows_svg.setContainsMultipleImages(True);
#self.arrows_svg.resize(KIconLoader.SizeSmall, KIconLoader.SizeSmall);
#self.collapse_button = Plasma.ToolButton()
#self.collapse_button.setZValue(3)
#self.collapse_button.nativeWidget().setMaximumSize(QSize(24, 24))
#if self.collapsed:
#self.collapse_button.nativeWidget().setIcon(KIcon(QIcon(self.arrows_svg.pixmap("collapse"))))
##self.collapse_button.nativeWidget().setIcon(KIcon("arrow-down"))
#else:
#self.collapse_button.nativeWidget().setIcon(KIcon(QIcon(self.arrows_svg.pixmap("restore"))))
##self.collapse_button.nativeWidget().setIcon(KIcon("arrow-up"))
#self.collapse_button.nativeWidget().setToolTip(i18n("Show/Hide controls"))
#self.collapse_button.clicked.connect(self.collapse_or_expand)
invert = "%scontents/icons/invert.png" % self.applet.package().path()
self.invert_button = Plasma.ToolButton()
self.invert_button.setZValue(3)
self.invert_button.nativeWidget().setMaximumSize(QSize(24, 24))
self.invert_button.nativeWidget().setIcon(KIcon(invert))
self.invert_button.nativeWidget().setToolTip(i18n("Swap currencies"))
self.invert_button.clicked.connect(self.invert_currencies)
self.title_label = Plasma.Label()
self.title_label.nativeWidget().setWordWrap(False)
#self.title_label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Minimum)
self.title_label.setText(i18n("Currency Converter"))
self.title_label.setAlignment(Qt.AlignCenter)
f = self.title_label.nativeWidget().font()
f.setBold(True)
self.title_label.nativeWidget().setFont(f)
self.from_label = Plasma.Label()
self.from_label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Minimum)
self.from_label.nativeWidget().setAlignment(Qt.AlignRight)
self.from_label.setText(i18n("From:"))
self.currency_from = Plasma.ComboBox()
self.currency_from.setZValue(2)
self.currency_from.setFocusPolicy(Qt.NoFocus)
self.to_label = Plasma.Label()
self.to_label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Minimum)
self.to_label.nativeWidget().setAlignment(Qt.AlignRight)
self.to_label.setText(i18n("To:"))
self.currency_to = Plasma.ComboBox()
self.currency_to.setZValue(1)
self.currency_to.setFocusPolicy(Qt.NoFocus)
self.amount_label = Plasma.Label()
self.amount_label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Minimum)
self.amount_label.nativeWidget().setAlignment(Qt.AlignTop) # NOTE: This is a hack because otherwise it flows down when you resize :-/
self.amount_label.nativeWidget().setAlignment(Qt.AlignRight)
self.amount_label.setText(i18n("Amount:"))
self.amount = Plasma.LineEdit()
self.amount.setClearButtonShown(True)
self.amount_validator = QDoubleValidator(self.amount.nativeWidget())
#if KGlobal.locale().decimalSymbol() == ",":
# self.amount_validator.setAcceptLocalizedNumbers(True)
self.amount.nativeWidget().setValidator(self.amount_validator)
print "Default amount:", self.def_amount
self.amount.setText(self.def_amount)
self.amount.setFocus()
self.amount.editingFinished.connect(self.amount_editing_finished)
self.from_amount_label = Plasma.Label()
self.from_amount_label.setMinimumWidth(30)
self.equal_label = Plasma.Label()
self.equal_label.setText("=")
# shows the currency symbol or abbreviation
self.to_amount_label = Plasma.Label()
self.to_amount_label.setMinimumWidth(30)
self.conversion_result = Plasma.LineEdit()
self.conversion_result.nativeWidget().setAlignment(Qt.AlignRight)
self.conversion_result.nativeWidget().setReadOnly(True)
self.credits_label = Plasma.Label()
self.credits_label.setAlignment(Qt.AlignRight)
self.credits_label.nativeWidget().setOpenExternalLinks(True)
logo = "%scontents/images/yahoo-attribution.png" % self.applet.package().path()
self.credits_label.setText(i18n("Data from <a href=\"http://finance.yahoo.com/currency-converter\"><img src=\"%s\"</a>" % logo))
f = self.credits_label.nativeWidget().font()
f.setPointSize(self.font_size()-2)
self.credits_label.nativeWidget().setFont(f)
QObject.connect(self.credits_label.nativeWidget(), SIGNAL("linkActivated(const QString&)"), self.open_link)
QObject.connect(self.credits_label, SIGNAL("linkActivated(const QString&)"), self.open_link)
self.credits_label.linkActivated.connect(self.open_link)
# Limit the number of currencies shown at a time if docked in bottom panel.
#if ((self.applet.formFactor() == Plasma.Horizontal) or (self.applet.formFactor() == Plasma.Vertical)):
if ((self.applet.formFactor() == Plasma.Horizontal) and (self.applet.location() == Plasma.BottomEdge)):
self.currency_from.nativeWidget().setMaxVisibleItems(6)
self.currency_to.nativeWidget().setMaxVisibleItems(4)
m_locale = KGlobal.locale()
#cc_list = l.currency().allCurrencyCodesList(KCurrencyCode.ActiveCurrency|KCurrencyCode.SuspendedCurrency|KCurrencyCode.ObsoleteCurrency)
cc_list = m_locale.currency().allCurrencyCodesList(KCurrencyCode.ActiveCurrency)
cc_namelist = []
#print "CC's:", len(l.currency().allCurrencyCodesList())
#print "# KDE Currency Codes:", len(cc_list)
for cc in cc_list:
cc_namelist.append(i18nc( "@item currency name and currency code", "%1 (%2)",
m_locale.currency().currencyCodeToName( cc ), cc ) )
#cc_namelist.sort()
for cur in sorted(set(cc_namelist)):
#print u"Currency:", unicode(cur)
self.currency_from.nativeWidget().addItem( cur, QVariant( cur.mid( cur.length()-4, 3 ) ) )
self.currency_to.nativeWidget().addItem( cur, QVariant( cur.mid( cur.length()-4, 3 ) ) )
self.currency_from.nativeWidget().setCurrentIndex( self.currency_from.nativeWidget().findData( QVariant( self.def_from ) ) )
self.currency_to.nativeWidget().setCurrentIndex( self.currency_to.nativeWidget().findData( QVariant( self.def_to ) ) )
self.currency_from.textChanged.connect(self.currency_changed)
self.currency_to.textChanged.connect(self.currency_changed)
self.layout_widgets()
if self.applet.nwmon.connected():
self.applet.setBusy(False)
self.start_timer()
def open_link(self, lnk):
print "open_link:", lnk
def start_timer(self):
print "CurrencyConverter::start_timer '%s'" % self.update_interval
if not self.timer:
self.timer = QTimer(self)
else:
self.timer.stop()
if self.update_interval > 0:
self.timer.setInterval(1000*60*self.update_interval)
self.timer.timeout.connect(self.do_convert)
self.timer.start()
self.do_convert()
def setEnabled(self, state):
self.collapse_button.setEnabled(state)
self.invert_button.setEnabled(state)
self.currency_from.setEnabled(state)
self.currency_to.setEnabled(state)
self.amount.setEnabled(state)
self.conversion_result.setEnabled(state)
def invert_currencies(self):
self.swapping = True
idx_from = self.currency_from.nativeWidget().currentIndex()
self.currency_from.nativeWidget().setCurrentIndex(self.currency_to.nativeWidget().currentIndex())
self.currency_to.nativeWidget().setCurrentIndex(idx_from)
cur = self.currency_from.text()
self.def_from = cur.mid( cur.length()-4, 3 )
cur = self.currency_to.text()
self.def_to = cur.mid( cur.length()-4, 3 )
self.swapping = False
self.do_convert()
def layout_widgets(self):
# Layout
if self.grid_layout <> None:
del self.grid_layout
self.grid_layout = QGraphicsGridLayout()
header_layout = QGraphicsLinearLayout()
header_layout.addItem(self.invert_button)
header_layout.addItem(self.title_label)
self.grid_layout.addItem(header_layout, 0, 0, 1, 2)
#self.grid_layout.addItem(self.collapse_button, 0, 0)
#self.grid_layout.addItem(self.title_label, 0, 1)
self.grid_layout.addItem(self.from_label, 1, 0)
self.grid_layout.addItem(self.currency_from, 1, 1)
self.grid_layout.addItem(self.to_label, 2, 0)
self.grid_layout.addItem(self.currency_to, 2, 1)
self.grid_layout.addItem(self.amount_label, 3, 0)
self.amount_layout = QGraphicsLinearLayout()
self.amount_layout.addItem(self.amount)
self.amount_layout.addItem(self.from_amount_label)
self.amount_layout.addItem(self.equal_label)
self.amount_layout.addItem(self.conversion_result)
self.amount_layout.addItem(self.to_amount_label)
self.grid_layout.addItem(self.amount_layout, 3, 1)
self.grid_layout.addItem(self.credits_label, 4, 0, 1, 2)
self.setLayout(self.grid_layout)
def currency_changed(self):
print "CurrencyConverter::currency_changed"
if self.swapping or not self.applet.nwmon.connected():
return
try:
cur = self.currency_from.text()
self.def_from = cur.mid( cur.length()-4, 3 )
#self.def_from = convert_from = self.currency_from.text()[0:3]
cur = self.currency_to.text()
self.def_to = cur.mid( cur.length()-4, 3 )
#self.def_to = convert_to = self.currency_to.text()[0:3]
self.applet.cfg.writeEntry("default_from", self.def_from)
self.applet.cfg.writeEntry("default_to", self.def_to)
self.applet.cfg.sync()
except RuntimeError:
print "CurrencyConverter::currency_changed: Regular update."
self.do_convert()
def do_convert(self):
print "CurrencyConverter::do_convert"
print "CurrencyConverter::do_convert. Update interval:", self.update_interval
print "Convert from:", self.def_from, "to", self.def_to
url = "http://quote.yahoo.com/d/quotes.csv?s=%s%s=X&f=l1&e=.csv" % (self.def_from, self.def_to)
print url
self.applet.setBusy(True)
job = KIO.get(KUrl(url), KIO.NoReload, KIO.HideProgressInfo)
job.warning.connect(self.job_warning)
job.data.connect(self.job_received)
job.result.connect(self.job_done)
self.timer.start() # restart the timer on activity
def job_warning(self, job, txt, richtxt):
print "Job warning: '%s' - '%s'" % (txt, richtxt)
self.applet.showMessage(KIcon("dialog-information"), richtxt, Plasma.ButtonOk)
def job_done(self, job):
print "Job done."
if job.error():
self.applet.notifier.notify("networkerror", job.errorString())
print job.errorString()
#self.applet.showMessage(KIcon("dialog-error"), job.errorString(), Plasma.ButtonOk)
#print job.errorText()
def job_received(self, job, data):
if len(data) > 0:
amount = self.def_amount
# NOTE: Check if self.amount.text() is localized and convert it if neccesary.
# Isn't there a better way of doing this?
if KGlobal.locale().decimalSymbol() == ",":
# remove any "."s and replace "," with "."
# there ought to bet a prettier way to do this
if amount.contains(","):
amount = amount.replace(".", "").replace(",", ".")
print "%f * %f = %f" % (float(amount), float(data), float(data)*float(amount))
print float(data)*float(amount)
self.conversion_result.setText(str(float(data)*float(amount)))
self.from_amount_label.setText(KCurrencyCode(self.def_from).defaultSymbol())
self.to_amount_label.setText(KCurrencyCode(self.def_to).defaultSymbol())
#self.from_amount_label.setText(QString.fromUtf8(CURRENCY[str(self.currency_from.text())[0:3]].get_symbol()))
#self.to_amount_label.setText(QString.fromUtf8(CURRENCY[str(self.currency_to.text())[0:3]].get_symbol()))
print "Last updated:", KGlobal.locale().formatDateTime(KDateTime.currentLocalDateTime())
self.last_updated = KGlobal.locale().formatDateTime(KDateTime.currentLocalDateTime())
#self.last_updated = str(datetime.now().ctime())
self.credits_label.nativeWidget().setToolTip(str(i18n("Last updated: %s")) % self.last_updated)
self.applet.setBusy(False)
print "Data recieved:", data
self.updated.emit()
def amount_editing_finished(self):
print "Amount editing finished"
self.def_amount = self.amount.text()
self.applet.cfg.writeEntry("default_amount", self.def_amount)
self.applet.cfg.sync()
self.do_convert()
def font_size(self):
return Plasma.Theme.defaultTheme().font(Plasma.Theme.DefaultFont).pointSize()
def fromCurrency(self):
return KCurrencyCode(self.def_from).defaultSymbol()
def toCurrency(self):
return KCurrencyCode(self.def_to).defaultSymbol()
def fromAmount(self):
return self.amount.text()
def toAmount(self):
return self.conversion_result.text()
def lastUpdated(self):
return self.last_updated
class UBlogApplet(plasmascript.Applet):
def __init__(self, parent, **kwargs):
plasmascript.Applet.__init__(self, parent)
self._layout = None
self.flash = None
self.tab_bar = None
self.ui = None
self.status_edit = None
self.scroll_widget = None
self.tweets_layout = None
self.main_frame = None
self.pm = None
self.consumer = oauth.Consumer(CONSUMER_KEY, CONSUMER_SECRET)
self.client = oauth.Client(self.consumer)
self.icon = None
self.oauth_secret = None
self.oauth_key = None
self.history_size = 10
self.timer = QTimer(self)
self.history_refresh = 1
self.tweets_widget = None
self.message_id = None
self._wallet_timer = QTimer(self)
def init(self):
"""
create interface, this method invoked by plasma it self
"""
self.setHasConfigurationInterface(True)
self.setAspectRatioMode(Plasma.IgnoreAspectRatio)
self.setBackgroundHints(Plasma.Applet.DefaultBackground)
#
self.flash = Plasma.FlashingLabel(self.applet)
self.flash.setAutohide(True)
self.flash.setMinimumSize(0, 20)
self.flash.setDuration(2000)
self.tab_bar = Plasma.TabBar()
self._layout = QGraphicsLinearLayout(Qt.Vertical, self.applet)
self._layout.setSpacing(3)
flash_layout = QGraphicsLinearLayout(Qt.Horizontal)
flash_layout.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
fnt = Plasma.Theme.defaultTheme().font(Plasma.Theme.DefaultFont)
fnt.setBold(True)
fm = QFontMetrics(fnt)
self.flash.setFont(fnt)
self.flash.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
title_layout = QGraphicsLinearLayout(Qt.Vertical)
flash_layout.addItem(self.flash)
flash_layout.addItem(title_layout)
self.main_frame = Plasma.Frame(self.applet)
m_header_layout = QGraphicsAnchorLayout(self.main_frame)
m_header_layout.setSpacing(5)
self.icon = Plasma.IconWidget(self.main_frame)
self.icon.setIcon(KIcon("user-identity"))
self.icon.setTextBackgroundColor(QColor())
icon_size = self.icon.sizeFromIconSize(48)
self.icon.setMinimumSize(icon_size)
self.icon.setMaximumSize(icon_size)
m_header_layout.addAnchor(self.icon, Qt.AnchorVerticalCenter, m_header_layout, Qt.AnchorVerticalCenter)
m_header_layout.addAnchor(self.icon, Qt.AnchorLeft, m_header_layout, Qt.AnchorLeft)
status_edit_frame = Plasma.Frame(self.main_frame)
status_edit_frame.setFrameShadow(Plasma.Frame.Sunken)
status_edit_layout = QGraphicsLinearLayout(status_edit_frame)
self.status_edit = Plasma.TextEdit()
self.status_edit.setPreferredHeight(fm.height() * 4)
self.status_edit.setEnabled(False)
status_edit_layout.addItem(self.status_edit)
edit_pal = self.status_edit.palette()
m_color_scheme = KColorScheme(QPalette.Active, KColorScheme.View, Plasma.Theme.defaultTheme().colorScheme())
edit_pal.setColor(QPalette.Text, m_color_scheme.foreground().color())
self.status_edit.nativeWidget().setPalette(edit_pal)
self.status_edit.nativeWidget().installEventFilter(self)
m_header_layout.addAnchor(self.icon, Qt.AnchorRight, status_edit_frame, Qt.AnchorLeft)
m_header_layout.addAnchors(status_edit_frame, m_header_layout, Qt.Vertical)
m_header_layout.addAnchor(status_edit_frame, Qt.AnchorRight, m_header_layout, Qt.AnchorRight)
m_header_layout.activate()
m_header_layout.setMaximumHeight(m_header_layout.effectiveSizeHint(Qt.PreferredSize).height())
self.scroll_widget = Plasma.ScrollWidget(self.applet)
self.tweets_widget = QGraphicsWidget(self.scroll_widget)
self.scroll_widget.setWidget(self.tweets_widget)
self.tweets_layout = QGraphicsLinearLayout(Qt.Vertical, self.tweets_widget)
self.tweets_layout.setSpacing(3)
self.tweets_layout.addItem(self.main_frame)
self.tab_bar.addTab(self.trUtf8("Timeline"))
self.tab_bar.addTab(self.trUtf8("Replies"))
self.tab_bar.addTab(self.trUtf8("Messages"))
self._layout.addItem(flash_layout)
self._layout.addItem(self.tab_bar)
self._layout.addItem(self.scroll_widget)
self.applet.setLayout(self._layout)
self.connect(self.tab_bar, SIGNAL('currentChanged(int)'), self.mode_changed)
self.connect(self.status_edit, SIGNAL('textChanged()'), self.edit_text_changed)
self.check_config()
def check_config(self):
if self.pm is None:
self._wallet_timer.setSingleShot(True)
self._wallet_timer.setInterval(1000)
self.connect(self._wallet_timer, SIGNAL("timeout()"), self.open_wallet);
self._wallet_timer.start()
return None
self.oauth_secret = unicode(self.pm.readPassword("twitter_secret")[1])
self.oauth_key = unicode(self.pm.readPassword("twitter_token")[1])
self.history_size = int(self.pm.readEntry("historySize")[1])
self.history_refresh = int(self.pm.readEntry("historyRefresh")[1])
if self.history_size == '':
self.history_size = 10
if self.history_refresh is None or self.history_refresh == '':
self.history_refresh = 5
if self.oauth_key == '' or self.oauth_secret == '':
self.authenticate()
else:
self.status_edit.setEnabled(True)
self.connect(self.timer, SIGNAL('timeout()'), self.update)
self.update()
self.timer.start(self.history_refresh * 60 * 1000)
def open_wallet(self):
if self.view() is None:
self._wallet_timer.start()
return None
if self.view().winId() is None:
self._wallet_timer.start()
return None
self.pm = PasswordManager(self.view().winId())
self.check_config()
def edit_text_changed(self):
remaining_char = 140 - self.status_edit.nativeWidget().toPlainText().length()
self.flash.flash(unicode(self.trUtf8("%s character left", "%s character left")) % remaining_char, 2000)
def createConfigurationInterface(self, dialog):
"""
create configuration settings for user parameters
"""
self.connect(dialog, SIGNAL('applyClicked()'), self.config_accepted)
self.connect(dialog, SIGNAL('okClicked()'), self.config_accepted)
widget = QWidget(dialog)
self.ui = uic.loadUi(self.package().filePath('ui', 'configuration.ui'), widget)
history_size = self.pm.readEntry("historySize")[1]
history_refresh = self.pm.readEntry("historyRefresh")[1]
if history_size:
self.ui.historySizeSpinBox.setValue(int(str(history_size)))
if history_refresh:
self.ui.historyRefreshSpinBox.setValue(int(str(history_refresh)))
dialog.addPage(widget, self.trUtf8("General"), "view-pim-journal")
def config_accepted(self):
"""
we must update timer object after these settings changed
"""
self.pm.writeEntry("historyRefresh", str(self.ui.historyRefreshSpinBox.value()))
self.pm.writeEntry("historySize", str(self.ui.historySizeSpinBox.value()))
self.history_size = str(self.ui.historyRefreshSpinBox.value())
self.history_refresh = int(self.ui.historySizeSpinBox.value())
self.status_edit.setEnabled(True)
self.timer.stop()
self.timer.start(self.history_refresh * 60 * 1000)
self.update()
def mode_changed(self):
self.flash.flash(self.trUtf8("Refreshing timeline..."))
self.timer.stop()
self.update()
self.timer.start(int(self.history_refresh) * 60 * 1000)
def update(self):
self.flash.flash(self.trUtf8("Refreshing timeline..."))
current_idx = self.tab_bar.currentIndex()
if current_idx == 0:
self.__update_timeline()
elif current_idx == 1:
self.__update_replies()
else:
self.__update_messages()
def __make_rest_calls(self, url, user=True):
token = oauth.Token(self.oauth_key, self.oauth_secret)
client = oauth.Client(self.consumer, token=token)
resp, content = client.request(url+"?count="+str(self.history_size))
self.tweets_widget.prepareGeometryChange()
if resp['status'] == '200':
# we must clear all tweets widgets before
for i in xrange(0, self.tweets_layout.count()-1):
widget = self.tweets_layout.itemAt(1)
if isinstance(widget, TweetWidget):
widget.deleteLater()
self.tweets_layout.removeAt(1)
tweets = json.loads(content)
for tweet in tweets:
widget = TweetWidget(self.tweets_widget)
widget.set_data(tweet, user=user)
self.connect(widget, SIGNAL('reply(QString, QString)'), self.reply)
self.connect(widget, SIGNAL('profile(QString)'), self.profile)
self.connect(widget, SIGNAL('retweet(QString)'), self.retweet)
self.connect(widget, SIGNAL('favorite(QString, bool)'), self.favorite)
self.tweets_layout.addItem(widget)
self.layout()
def __update_timeline(self):
self.__make_rest_calls("https://api.twitter.com/1.1/statuses/home_timeline.json")
def __update_messages(self):
self.__make_rest_calls("https://api.twitter.com/1.1/direct_messages.json", user=False)
def __update_replies(self):
self.__make_rest_calls("https://api.twitter.com/1.1/statuses/mentions_timeline.json")
def reply(self, message_id, authorname):
self.status_edit.setText(authorname + ' ')
self.message_id = message_id
def profile(self, user):
KToolInvocation.invokeBrowser("https://twitter.com/%s" % (user,))
def __make_post_calls(self, url, body):
self.timer.stop()
token = oauth.Token(self.oauth_key, self.oauth_secret)
client = oauth.Client(self.consumer, token=token)
resp, content = client.request(url,
method='POST', body=body)
if resp['status'] == '200':
self.update()
self.timer.start()
def retweet(self, message_id):
self.flash.flash(self.trUtf8("Retweetting..."))
self.__make_post_calls("https://api.twitter.com/1.1/statuses/retweet/"+str(message_id)+".json",
body='id='+str(message_id))
def favorite(self, message_id, add):
if add:
self.flash.flash(self.trUtf8("Adding favorites..."))
else:
self.flash.flash(self.trUtf8("Removing from favorites..."))
self.__make_post_calls("https://api.twitter.com/1.1/favorites/"+("create" if add else "destroy")+".json",
body='id='+str(message_id))
def update_status(self):
tweet = unicode(self.status_edit.nativeWidget().toPlainText())
self.status_edit.setText(' ')
self.flash.flash(self.trUtf8("Tweet sending..."))
self.setBusy(True)
body = 'status='+tweet
if tweet.startswith('@') and self.message_id is not None:
body += '&in_reply_to_status_id='+str(self.message_id)
self.message_id = None
self.__make_post_calls("https://api.twitter.com/1.1/statuses/update.json",
body=body)
self.setBusy(False)
def eventFilter(self, obj, event):
if isinstance(obj, KTextEdit):
if event.type() == QEvent.KeyPress:
key_event = QKeyEvent(event)
key = key_event.key()
if (key_event.modifiers() == Qt.ControlModifier) and (key == Qt.Key_Enter or key == Qt.Key_Return):
self.update_status()
return True
safe_keys = [Qt.Key_Delete, Qt.Key_Backspace,
Qt.Key_Up, Qt.Key_Down,
Qt.Key_Right, Qt.Key_Left,
Qt.Key_Home, Qt.Key_End]
if key not in safe_keys:
if self.status_edit.nativeWidget().toPlainText().length() >= 140:
return True
return False
elif isinstance(obj, KTabBar) and event.type() == QEvent.MouseButtonPress:
self.scroll_widget.ensureItemVisible(self.main_frame)
self.status_edit.setFocus()
return False
else:
return self.applet.eventFilter(obj, event)
def authenticate(self, loop_count):
if loop_count >= 5:
return self.quit()
loop_count += 1
resp, content = self.client.request("https://twitter.com/oauth/request_token", "GET")
if resp['status'] != '200':
raise Exception("Invalid response %s." % resp['status'])
request_token = dict(urlparse.parse_qsl(content))
KToolInvocation.invokeBrowser("https://twitter.com/oauth/authorize?oauth_token=%s&oauth_callback=oob" % (
request_token['oauth_token']))
dialog = KInputDialog.getText(self.trUtf8("PIN"), self.trUtf8("Enter the PIN received from Twitter:"))
if dialog[1] is True and not dialog[0].isEmpty():
token = oauth.Token(request_token['oauth_token'], request_token['oauth_token_secret'])
token.set_verifier(str(dialog[0]))
client = oauth.Client(self.consumer, token)
resp, content = client.request("https://twitter.com/oauth/access_token", "POST")
if resp['status'] == '200':
access_token = dict(urlparse.parse_qsl(content))
self.oauth_secret = access_token['oauth_token_secret']
self.oauth_key = access_token['oauth_token']
self.pm.writePassword("twitter_secret", self.oauth_secret)
self.pm.writePassword("twitter_token", self.oauth_key)
else:
self.authenticate(loop_count)
else:
self.quit()
def quit(self):
self.close()
class OWHierarchicalClustering(widget.OWWidget):
name = "Hierarchical Clustering"
description = ("Hierarchical clustering based on distance matrix, and "
"a dendrogram viewer.")
icon = "icons/HierarchicalClustering.svg"
priority = 2100
inputs = [("Distances", Orange.misc.DistMatrix, "set_distances")]
outputs = [("Selected Data", Orange.data.Table),
("Other Data", Orange.data.Table)]
#: Selected linkage
linkage = settings.Setting(1)
#: Index of the selected annotation item (variable, ...)
annotation_idx = settings.Setting(0)
#: Selected tree pruning (none/max depth)
pruning = settings.Setting(0)
#: Maximum depth when max depth pruning is selected
max_depth = settings.Setting(10)
#: Selected cluster selection method (none, cut distance, top n)
selection_method = settings.Setting(0)
#: Cut height ratio wrt root height
cut_ratio = settings.Setting(75.0)
#: Number of top clusters to select
top_n = settings.Setting(3)
append_clusters = settings.Setting(True)
cluster_role = settings.Setting(2)
cluster_name = settings.Setting("Cluster")
autocommit = settings.Setting(False)
#: Cluster variable domain role
AttributeRole, ClassRole, MetaRole = 0, 1, 2
def __init__(self, parent=None):
super().__init__(parent)
self.matrix = None
self.items = None
self.linkmatrix = None
self.root = None
self._displayed_root = None
self.cutoff_height = 0.0
gui.comboBox(gui.widgetBox(self.controlArea, "Linkage"),
self, "linkage", items=LINKAGE,
callback=self._invalidate_clustering)
box = gui.widgetBox(self.controlArea, "Annotation")
self.label_cb = gui.comboBox(
box, self, "annotation_idx", callback=self._update_labels)
self.label_cb.setModel(itemmodels.VariableListModel())
self.label_cb.model()[:] = ["None", "Enumeration"]
box = gui.radioButtons(
self.controlArea, self, "pruning", box="Pruning",
callback=self._invalidate_pruning
)
grid = QGridLayout()
box.layout().addLayout(grid)
grid.addWidget(
gui.appendRadioButton(box, "None", addToLayout=False),
0, 0
)
self.max_depth_spin = gui.spin(
box, self, "max_depth", minv=1, maxv=100,
callback=self._invalidate_pruning,
keyboardTracking=False
)
grid.addWidget(
gui.appendRadioButton(box, "Max depth", addToLayout=False),
1, 0)
grid.addWidget(self.max_depth_spin, 1, 1)
box = gui.radioButtons(
self.controlArea, self, "selection_method",
box="Selection",
callback=self._selection_method_changed)
grid = QGridLayout()
box.layout().addLayout(grid)
grid.addWidget(
gui.appendRadioButton(box, "Manual", addToLayout=False),
0, 0
)
grid.addWidget(
gui.appendRadioButton(box, "Height ratio", addToLayout=False),
1, 0
)
self.cut_ratio_spin = gui.spin(
box, self, "cut_ratio", 0, 100, step=1e-1, spinType=float,
callback=self._selection_method_changed
)
self.cut_ratio_spin.setSuffix("%")
grid.addWidget(self.cut_ratio_spin, 1, 1)
grid.addWidget(
gui.appendRadioButton(box, "Top N", addToLayout=False),
2, 0
)
self.top_n_spin = gui.spin(box, self, "top_n", 1, 20,
callback=self._selection_method_changed)
grid.addWidget(self.top_n_spin, 2, 1)
box.layout().addLayout(grid)
self.controlArea.layout().addStretch()
box = gui.widgetBox(self.controlArea, "Output")
gui.checkBox(box, self, "append_clusters", "Append cluster IDs",
callback=self._invalidate_output)
ibox = gui.indentedBox(box)
name_edit = gui.lineEdit(ibox, self, "cluster_name")
name_edit.editingFinished.connect(self._invalidate_output)
cb = gui.comboBox(
ibox, self, "cluster_role", callback=self._invalidate_output,
items=["Attribute",
"Class variable",
"Meta variable"]
)
form = QFormLayout(
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow,
labelAlignment=Qt.AlignLeft,
spacing=8
)
form.addRow("Name", name_edit)
form.addRow("Place", cb)
ibox.layout().addSpacing(5)
ibox.layout().addLayout(form)
ibox.layout().addSpacing(5)
gui.auto_commit(box, self, "autocommit", "Send data", "Auto send is on",
box=False)
self.scene = QGraphicsScene()
self.view = QGraphicsView(
self.scene,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
alignment=Qt.AlignLeft | Qt.AlignVCenter
)
def axis_view(orientation):
ax = pg.AxisItem(orientation=orientation, maxTickLength=7)
scene = QGraphicsScene()
scene.addItem(ax)
view = QGraphicsView(
scene,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
alignment=Qt.AlignLeft | Qt.AlignVCenter
)
view.setFixedHeight(ax.size().height())
ax.line = SliderLine(orientation=Qt.Horizontal,
length=ax.size().height())
scene.addItem(ax.line)
return view, ax
self.top_axis_view, self.top_axis = axis_view("top")
self.mainArea.layout().setSpacing(1)
self.mainArea.layout().addWidget(self.top_axis_view)
self.mainArea.layout().addWidget(self.view)
self.bottom_axis_view, self.bottom_axis = axis_view("bottom")
self.mainArea.layout().addWidget(self.bottom_axis_view)
self._main_graphics = QGraphicsWidget()
self._main_layout = QGraphicsLinearLayout(Qt.Horizontal)
self._main_layout.setSpacing(1)
self._main_graphics.setLayout(self._main_layout)
self.scene.addItem(self._main_graphics)
self.dendrogram = DendrogramWidget()
self.dendrogram.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.dendrogram.selectionChanged.connect(self._invalidate_output)
self.dendrogram.selectionEdited.connect(self._selection_edited)
fm = self.fontMetrics()
self.dendrogram.setContentsMargins(
5, fm.lineSpacing() / 2,
5, fm.lineSpacing() / 2
)
self.labels = GraphicsSimpleTextList()
self.labels.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.labels.setAlignment(Qt.AlignLeft)
self.labels.setMaximumWidth(200)
self.labels.layout().setSpacing(0)
self._main_layout.addItem(self.dendrogram)
self._main_layout.addItem(self.labels)
self._main_layout.setAlignment(
self.dendrogram, Qt.AlignLeft | Qt.AlignVCenter)
self._main_layout.setAlignment(
self.labels, Qt.AlignLeft | Qt.AlignVCenter)
self.view.viewport().installEventFilter(self)
self.top_axis_view.viewport().installEventFilter(self)
self.bottom_axis_view.viewport().installEventFilter(self)
self._main_graphics.installEventFilter(self)
self.cut_line = SliderLine(self.dendrogram,
orientation=Qt.Horizontal)
self.cut_line.valueChanged.connect(self._dendrogram_slider_changed)
self.cut_line.hide()
self.bottom_axis.line.valueChanged.connect(self._axis_slider_changed)
self.top_axis.line.valueChanged.connect(self._axis_slider_changed)
self.dendrogram.geometryChanged.connect(self._dendrogram_geom_changed)
self._set_cut_line_visible(self.selection_method == 1)
def set_distances(self, matrix):
self.matrix = matrix
self._invalidate_clustering()
self._set_items(matrix.row_items if matrix is not None else None)
def _set_items(self, items):
self.items = items
if items is None:
self.label_cb.model()[:] = ["None", "Enumeration"]
elif isinstance(items, Orange.data.Table):
vars = list(items.domain)
self.label_cb.model()[:] = ["None", "Enumeration"] + vars
elif isinstance(items, list) and \
all(isinstance(var, Orange.data.Variable) for var in items):
self.label_cb.model()[:] = ["None", "Enumeration", "Name"]
else:
self.label_cb.model()[:] = ["None", "Enumeration"]
self.annotation_idx = min(self.annotation_idx,
len(self.label_cb.model()) - 1)
def handleNewSignals(self):
self._update_labels()
def _clear_plot(self):
self.labels.set_labels([])
self.dendrogram.set_root(None)
def _set_displayed_root(self, root):
self._clear_plot()
self._displayed_root = root
self.dendrogram.set_root(root)
self._update_labels()
self._main_graphics.resize(
self._main_graphics.size().width(),
self._main_graphics.sizeHint(Qt.PreferredSize).height()
)
self._main_graphics.layout().activate()
def _update(self):
self._clear_plot()
distances = self.matrix
if distances is not None:
# Convert to flat upper triangular distances
i, j = numpy.triu_indices(distances.X.shape[0], k=1)
distances = distances.X[i, j]
method = LINKAGE[self.linkage].lower()
Z = scipy.cluster.hierarchy.linkage(
distances, method=method
)
tree = tree_from_linkage(Z)
self.linkmatrix = Z
self.root = tree
self.top_axis.setRange(tree.value.height, 0.0)
self.bottom_axis.setRange(tree.value.height, 0.0)
if self.pruning:
self._set_displayed_root(prune(tree, level=self.max_depth))
else:
self._set_displayed_root(tree)
else:
self.linkmatrix = None
self.root = None
self._set_displayed_root(None)
self._apply_selection()
def _update_labels(self):
labels = []
if self.root and self._displayed_root:
indices = [leaf.value.index for leaf in leaves(self.root)]
if self.annotation_idx == 0:
labels = []
elif self.annotation_idx == 1:
labels = [str(i) for i in indices]
elif isinstance(self.items, Orange.data.Table):
var = self.label_cb.model()[self.annotation_idx]
col = self.items[:, var]
labels = [var.repr_val(next(iter(row))) for row in col]
labels = [labels[idx] for idx in indices]
else:
labels = []
if labels and self._displayed_root is not self.root:
joined = leaves(self._displayed_root)
labels = [", ".join(labels[leaf.value.first: leaf.value.last])
for leaf in joined]
self.labels.set_labels(labels)
self.labels.setMinimumWidth(1 if labels else -1)
def _invalidate_clustering(self):
self._update()
self._update_labels()
def _invalidate_output(self):
self.commit()
def _invalidate_pruning(self):
if self.root:
selection = self.dendrogram.selected_nodes()
ranges = [node.value.range for node in selection]
if self.pruning:
self._set_displayed_root(
prune(self.root, level=self.max_depth))
else:
self._set_displayed_root(self.root)
selected = [node for node in preorder(self._displayed_root)
if node.value.range in ranges]
self.dendrogram.set_selected_clusters(selected)
self._apply_selection()
def commit(self):
items = getattr(self.matrix, "items", self.items)
if not items:
# nothing to commit
return
selection = self.dendrogram.selected_nodes()
selection = sorted(selection, key=lambda c: c.value.first)
indices = [leaf.value.index for leaf in leaves(self.root)]
maps = [indices[node.value.first:node.value.last]
for node in selection]
selected_indices = list(chain(*maps))
unselected_indices = sorted(set(range(self.root.value.last)) -
set(selected_indices))
selected = [items[k] for k in selected_indices]
unselected = [items[k] for k in unselected_indices]
if not selected:
self.send("Selected Data", None)
self.send("Other Data", None)
return
selected_data = unselected_data = None
if isinstance(items, Orange.data.Table):
c = numpy.zeros(len(items))
for i, indices in enumerate(maps):
c[indices] = i
c[unselected_indices] = len(maps)
mask = c != len(maps)
if self.append_clusters:
clust_var = Orange.data.DiscreteVariable(
str(self.cluster_name),
values=["Cluster {}".format(i + 1)
for i in range(len(maps))] +
["Other"], ordered=True
)
data, domain = items, items.domain
attrs = domain.attributes
class_ = domain.class_vars
metas = domain.metas
if self.cluster_role == self.AttributeRole:
attrs = attrs + (clust_var,)
elif self.cluster_role == self.ClassRole:
class_ = class_ + (clust_var,)
elif self.cluster_role == self.MetaRole:
metas = metas + (clust_var,)
domain = Orange.data.Domain(attrs, class_, metas)
data = Orange.data.Table(domain, data)
data.get_column_view(clust_var)[0][:] = c
else:
data = items
if selected:
selected_data = data[mask]
if unselected:
unselected_data = data[~mask]
self.send("Selected Data", selected_data)
self.send("Other Data", unselected_data)
def sizeHint(self):
return QSize(800, 500)
def eventFilter(self, obj, event):
if obj is self.view.viewport() and event.type() == QEvent.Resize:
width = self.view.viewport().width() - 2
self._main_graphics.setMaximumWidth(width)
self._main_graphics.setMinimumWidth(width)
self._main_graphics.layout().activate()
elif event.type() == QEvent.MouseButtonPress and \
(obj is self.top_axis_view.viewport() or
obj is self.bottom_axis_view.viewport()):
self.selection_method = 1
# Map click point to cut line local coordinates
pos = self.top_axis_view.mapToScene(event.pos())
cut = self.top_axis.line.mapFromScene(pos)
self.top_axis.line.setValue(cut.x())
# update the line visibility, output, ...
self._selection_method_changed()
return super().eventFilter(obj, event)
def _dendrogram_geom_changed(self):
pos = self.dendrogram.pos_at_height(self.cutoff_height)
geom = self.dendrogram.geometry()
crect = self.dendrogram.contentsRect()
self._set_slider_value(pos.x(), geom.width())
self.cut_line.setLength(geom.height())
self.top_axis.resize(crect.width(), self.top_axis.height())
self.top_axis.setPos(geom.left() + crect.left(), 0)
self.top_axis.line.setPos(self.cut_line.scenePos().x(), 0)
self.bottom_axis.resize(crect.width(), self.bottom_axis.height())
self.bottom_axis.setPos(geom.left() + crect.left(), 0)
self.bottom_axis.line.setPos(self.cut_line.scenePos().x(), 0)
geom = self._main_graphics.geometry()
assert geom.topLeft() == QPointF(0, 0)
self.scene.setSceneRect(geom)
geom.setHeight(self.top_axis.size().height())
self.top_axis.scene().setSceneRect(geom)
self.bottom_axis.scene().setSceneRect(geom)
def _axis_slider_changed(self, value):
self.cut_line.setValue(value)
def _dendrogram_slider_changed(self, value):
p = QPointF(value, 0)
cl_height = self.dendrogram.height_at(p)
self.set_cutoff_height(cl_height)
# Sync the cut positions between the dendrogram and the axis.
self._set_slider_value(value, self.dendrogram.size().width())
def _set_slider_value(self, value, span):
with blocked(self.cut_line):
self.cut_line.setValue(value)
self.cut_line.setRange(0, span)
with blocked(self.top_axis.line):
self.top_axis.line.setValue(value)
self.top_axis.line.setRange(0, span)
with blocked(self.bottom_axis.line):
self.bottom_axis.line.setValue(value)
self.bottom_axis.line.setRange(0, span)
def set_cutoff_height(self, height):
self.cutoff_height = height
if self.root:
self.cut_ratio = 100 * height / self.root.value.height
self.select_max_height(height)
def _set_cut_line_visible(self, visible):
self.cut_line.setVisible(visible)
self.top_axis.line.setVisible(visible)
self.bottom_axis.line.setVisible(visible)
def select_top_n(self, n):
root = self._displayed_root
if root:
clusters = top_clusters(root, n)
self.dendrogram.set_selected_clusters(clusters)
def select_max_height(self, height):
root = self._displayed_root
if root:
clusters = clusters_at_height(root, height)
self.dendrogram.set_selected_clusters(clusters)
def _selection_method_changed(self):
self._set_cut_line_visible(self.selection_method == 1)
if self.root:
self._apply_selection()
def _apply_selection(self):
if not self.root:
return
if self.selection_method == 0:
pass
elif self.selection_method == 1:
height = self.cut_ratio * self.root.value.height / 100
self.set_cutoff_height(height)
pos = self.dendrogram.pos_at_height(height)
self._set_slider_value(pos.x(), self.dendrogram.size().width())
elif self.selection_method == 2:
self.select_top_n(self.top_n)
def _selection_edited(self):
# Selection was edited by clicking on a cluster in the
# dendrogram view.
self.selection_method = 0
self._selection_method_changed()
class OWHierarchicalClustering(widget.OWWidget):
name = "Hierarchical Clustering"
description = ("Hierarchical clustering based on distance matrix, and "
"a dendrogram viewer.")
icon = "icons/HierarchicalClustering.svg"
priority = 2100
inputs = [("Distances", Orange.misc.DistMatrix, "set_distances")]
outputs = [("Selected Data", Orange.data.Table),
("Other Data", Orange.data.Table)]
#: Selected linkage
linkage = settings.Setting(1)
#: Index of the selected annotation item (variable, ...)
annotation_idx = settings.Setting(0)
#: Selected tree pruning (none/max depth)
pruning = settings.Setting(0)
#: Maximum depth when max depth pruning is selected
max_depth = settings.Setting(10)
#: Selected cluster selection method (none, cut distance, top n)
selection_method = settings.Setting(0)
#: Cut height ratio wrt root height
cut_ratio = settings.Setting(75.0)
#: Number of top clusters to select
top_n = settings.Setting(3)
append_clusters = settings.Setting(True)
cluster_role = settings.Setting(2)
cluster_name = settings.Setting("Cluster")
autocommit = settings.Setting(False)
#: Cluster variable domain role
AttributeRole, ClassRole, MetaRole = 0, 1, 2
def __init__(self, parent=None):
super().__init__(parent)
self.matrix = None
self.items = None
self.linkmatrix = None
self.root = None
self._displayed_root = None
self.cutoff_height = 0.0
self._invalidated = False
gui.comboBox(gui.widgetBox(self.controlArea, "Linkage"),
self,
"linkage",
items=LINKAGE,
callback=self._invalidate_clustering)
box = gui.widgetBox(self.controlArea, "Annotation")
self.label_cb = gui.comboBox(box,
self,
"annotation_idx",
callback=self._update_labels)
self.label_cb.setModel(itemmodels.VariableListModel())
self.label_cb.model()[:] = ["None", "Enumeration"]
box = gui.radioButtons(self.controlArea,
self,
"pruning",
box="Pruning",
callback=self._invalidate_pruning)
grid = QGridLayout()
box.layout().addLayout(grid)
grid.addWidget(gui.appendRadioButton(box, "None", addToLayout=False),
0, 0)
self.max_depth_spin = gui.spin(box,
self,
"max_depth",
minv=1,
maxv=100,
callback=self._invalidate_pruning,
keyboardTracking=False)
grid.addWidget(
gui.appendRadioButton(box, "Max depth", addToLayout=False), 1, 0)
grid.addWidget(self.max_depth_spin, 1, 1)
box = gui.radioButtons(self.controlArea,
self,
"selection_method",
box="Selection",
callback=self._selection_method_changed)
grid = QGridLayout()
box.layout().addLayout(grid)
grid.addWidget(gui.appendRadioButton(box, "Manual", addToLayout=False),
0, 0)
grid.addWidget(
gui.appendRadioButton(box, "Height ratio", addToLayout=False), 1,
0)
self.cut_ratio_spin = gui.spin(box,
self,
"cut_ratio",
0,
100,
step=1e-1,
spinType=float,
callback=self._selection_method_changed)
self.cut_ratio_spin.setSuffix("%")
grid.addWidget(self.cut_ratio_spin, 1, 1)
grid.addWidget(gui.appendRadioButton(box, "Top N", addToLayout=False),
2, 0)
self.top_n_spin = gui.spin(box,
self,
"top_n",
1,
20,
callback=self._selection_method_changed)
grid.addWidget(self.top_n_spin, 2, 1)
box.layout().addLayout(grid)
self.controlArea.layout().addStretch()
box = gui.widgetBox(self.controlArea, "Output")
gui.checkBox(box,
self,
"append_clusters",
"Append cluster IDs",
callback=self._invalidate_output)
ibox = gui.indentedBox(box)
name_edit = gui.lineEdit(ibox, self, "cluster_name")
name_edit.editingFinished.connect(self._invalidate_output)
cb = gui.comboBox(
ibox,
self,
"cluster_role",
callback=self._invalidate_output,
items=["Attribute", "Class variable", "Meta variable"])
form = QFormLayout(fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow,
labelAlignment=Qt.AlignLeft,
spacing=8)
form.addRow("Name", name_edit)
form.addRow("Place", cb)
ibox.layout().addSpacing(5)
ibox.layout().addLayout(form)
ibox.layout().addSpacing(5)
cb = gui.checkBox(box, self, "autocommit", "Commit automatically")
b = gui.button(box, self, "Commit", callback=self.commit, default=True)
gui.setStopper(self, b, cb, "_invalidated", callback=self.commit)
self.scene = QGraphicsScene()
self.view = QGraphicsView(
self.scene,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
alignment=Qt.AlignLeft | Qt.AlignVCenter)
def axis_view(orientation):
ax = pg.AxisItem(orientation=orientation, maxTickLength=7)
scene = QGraphicsScene()
scene.addItem(ax)
view = QGraphicsView(
scene,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
alignment=Qt.AlignLeft | Qt.AlignVCenter)
view.setFixedHeight(ax.size().height())
ax.line = SliderLine(orientation=Qt.Horizontal,
length=ax.size().height())
scene.addItem(ax.line)
return view, ax
self.top_axis_view, self.top_axis = axis_view("top")
self.mainArea.layout().setSpacing(1)
self.mainArea.layout().addWidget(self.top_axis_view)
self.mainArea.layout().addWidget(self.view)
self.bottom_axis_view, self.bottom_axis = axis_view("bottom")
self.mainArea.layout().addWidget(self.bottom_axis_view)
self._main_graphics = QGraphicsWidget()
self._main_layout = QGraphicsLinearLayout(Qt.Horizontal)
self._main_layout.setSpacing(1)
self._main_graphics.setLayout(self._main_layout)
self.scene.addItem(self._main_graphics)
self.dendrogram = DendrogramWidget()
self.dendrogram.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.dendrogram.selectionChanged.connect(self._invalidate_output)
self.dendrogram.selectionEdited.connect(self._selection_edited)
fm = self.fontMetrics()
self.dendrogram.setContentsMargins(5,
fm.lineSpacing() / 2, 5,
fm.lineSpacing() / 2)
self.labels = GraphicsSimpleTextList()
self.labels.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.labels.setAlignment(Qt.AlignLeft)
self.labels.setMaximumWidth(200)
self.labels.layout().setSpacing(0)
self._main_layout.addItem(self.dendrogram)
self._main_layout.addItem(self.labels)
self._main_layout.setAlignment(self.dendrogram,
Qt.AlignLeft | Qt.AlignVCenter)
self._main_layout.setAlignment(self.labels,
Qt.AlignLeft | Qt.AlignVCenter)
self.view.viewport().installEventFilter(self)
self.top_axis_view.viewport().installEventFilter(self)
self.bottom_axis_view.viewport().installEventFilter(self)
self._main_graphics.installEventFilter(self)
self.cut_line = SliderLine(self.dendrogram, orientation=Qt.Horizontal)
self.cut_line.valueChanged.connect(self._dendrogram_slider_changed)
self.cut_line.hide()
self.bottom_axis.line.valueChanged.connect(self._axis_slider_changed)
self.top_axis.line.valueChanged.connect(self._axis_slider_changed)
self.dendrogram.geometryChanged.connect(self._dendrogram_geom_changed)
self._set_cut_line_visible(self.selection_method == 1)
def set_distances(self, matrix):
self.matrix = matrix
self._invalidate_clustering()
self._set_items(matrix.row_items if matrix is not None else None)
def _set_items(self, items):
self.items = items
if items is None:
self.label_cb.model()[:] = ["None", "Enumeration"]
elif isinstance(items, Orange.data.Table):
vars = list(items.domain)
self.label_cb.model()[:] = ["None", "Enumeration"] + vars
elif isinstance(items, list) and \
all(isinstance(var, Orange.data.Variable) for var in items):
self.label_cb.model()[:] = ["None", "Enumeration", "Name"]
else:
self.label_cb.model()[:] = ["None", "Enumeration"]
self.annotation_idx = min(self.annotation_idx,
len(self.label_cb.model()) - 1)
def handleNewSignals(self):
self._update_labels()
def _clear_plot(self):
self.labels.set_labels([])
self.dendrogram.set_root(None)
def _set_displayed_root(self, root):
self._clear_plot()
self._displayed_root = root
self.dendrogram.set_root(root)
self._update_labels()
self._main_graphics.resize(
self._main_graphics.size().width(),
self._main_graphics.sizeHint(Qt.PreferredSize).height())
self._main_graphics.layout().activate()
def _update(self):
self._clear_plot()
distances = self.matrix
if distances is not None:
# Convert to flat upper triangular distances
i, j = numpy.triu_indices(distances.X.shape[0], k=1)
distances = distances.X[i, j]
method = LINKAGE[self.linkage].lower()
Z = scipy.cluster.hierarchy.linkage(distances, method=method)
tree = tree_from_linkage(Z)
self.linkmatrix = Z
self.root = tree
self.top_axis.setRange(tree.value.height, 0.0)
self.bottom_axis.setRange(tree.value.height, 0.0)
if self.pruning:
self._set_displayed_root(prune(tree, level=self.max_depth))
else:
self._set_displayed_root(tree)
else:
self.linkmatrix = None
self.root = None
self._set_displayed_root(None)
self._apply_selection()
def _update_labels(self):
labels = []
if self.root and self._displayed_root:
indices = [leaf.value.index for leaf in leaves(self.root)]
if self.annotation_idx == 0:
labels = []
elif self.annotation_idx == 1:
labels = [str(i) for i in indices]
elif isinstance(self.items, Orange.data.Table):
var = self.label_cb.model()[self.annotation_idx]
col = self.items[:, var]
labels = [var.repr_val(next(iter(row))) for row in col]
labels = [labels[idx] for idx in indices]
else:
labels = []
if labels and self._displayed_root is not self.root:
joined = leaves(self._displayed_root)
labels = [
", ".join(labels[leaf.value.first:leaf.value.last])
for leaf in joined
]
self.labels.set_labels(labels)
self.labels.setMinimumWidth(1 if labels else -1)
def _invalidate_clustering(self):
self._update()
self._update_labels()
def _invalidate_output(self):
self._invalidated = True
if self.autocommit:
self.commit()
def _invalidate_pruning(self):
if self.root:
selection = self.dendrogram.selected_nodes()
ranges = [node.value.range for node in selection]
if self.pruning:
self._set_displayed_root(prune(self.root,
level=self.max_depth))
else:
self._set_displayed_root(self.root)
selected = [
node for node in preorder(self._displayed_root)
if node.value.range in ranges
]
self.dendrogram.set_selected_clusters(selected)
self._apply_selection()
def commit(self):
self._invalidated = False
items = getattr(self.matrix, "items", self.items)
if not items:
# nothing to commit
return
selection = self.dendrogram.selected_nodes()
selection = sorted(selection, key=lambda c: c.value.first)
indices = [leaf.value.index for leaf in leaves(self.root)]
maps = [
indices[node.value.first:node.value.last] for node in selection
]
selected_indices = list(chain(*maps))
unselected_indices = sorted(
set(range(self.root.value.last)) - set(selected_indices))
selected = [items[k] for k in selected_indices]
unselected = [items[k] for k in unselected_indices]
if not selected:
self.send("Selected Data", None)
self.send("Other Data", None)
return
selected_data = unselected_data = None
if isinstance(items, Orange.data.Table):
c = numpy.zeros(len(items))
for i, indices in enumerate(maps):
c[indices] = i
c[unselected_indices] = len(maps)
mask = c != len(maps)
if self.append_clusters:
clust_var = Orange.data.DiscreteVariable(
str(self.cluster_name),
values=[
"Cluster {}".format(i + 1) for i in range(len(maps))
] + ["Other"])
data, domain = items, items.domain
attrs = domain.attributes
class_ = domain.class_vars
metas = domain.metas
X, Y, M = data.X, data.Y, data.metas
if self.cluster_role == self.AttributeRole:
attrs = attrs + (clust_var, )
X = numpy.c_[X, c]
elif self.cluster_role == self.ClassRole:
class_ = class_ + (clust_var, )
Y = numpy.c_[Y, c]
elif self.cluster_role == self.MetaRole:
metas = metas + (clust_var, )
M = numpy.c_[M, c]
domain = Orange.data.Domain(attrs, class_, metas)
data = Orange.data.Table(domain, X, Y, M)
else:
data = items
if selected:
selected_data = data[mask]
if unselected:
unselected_data = data[~mask]
self.send("Selected Data", selected_data)
self.send("Other Data", unselected_data)
def sizeHint(self):
return QSize(800, 500)
def eventFilter(self, obj, event):
if obj is self.view.viewport() and event.type() == QEvent.Resize:
width = self.view.viewport().width() - 2
self._main_graphics.setMaximumWidth(width)
self._main_graphics.setMinimumWidth(width)
self._main_graphics.layout().activate()
elif event.type() == QEvent.MouseButtonPress and \
(obj is self.top_axis_view.viewport() or
obj is self.bottom_axis_view.viewport()):
self.selection_method = 1
# Map click point to cut line local coordinates
pos = self.top_axis_view.mapToScene(event.pos())
cut = self.top_axis.line.mapFromScene(pos)
self.top_axis.line.setValue(cut.x())
# update the line visibility, output, ...
self._selection_method_changed()
return super().eventFilter(obj, event)
def _dendrogram_geom_changed(self):
pos = self.dendrogram.pos_at_height(self.cutoff_height)
geom = self.dendrogram.geometry()
crect = self.dendrogram.contentsRect()
self._set_slider_value(pos.x(), geom.width())
self.cut_line.setLength(geom.height())
self.top_axis.resize(crect.width(), self.top_axis.height())
self.top_axis.setPos(geom.left() + crect.left(), 0)
self.top_axis.line.setPos(self.cut_line.scenePos().x(), 0)
self.bottom_axis.resize(crect.width(), self.bottom_axis.height())
self.bottom_axis.setPos(geom.left() + crect.left(), 0)
self.bottom_axis.line.setPos(self.cut_line.scenePos().x(), 0)
geom = self._main_graphics.geometry()
assert geom.topLeft() == QPointF(0, 0)
self.scene.setSceneRect(geom)
geom.setHeight(self.top_axis.size().height())
self.top_axis.scene().setSceneRect(geom)
self.bottom_axis.scene().setSceneRect(geom)
def _axis_slider_changed(self, value):
self.cut_line.setValue(value)
def _dendrogram_slider_changed(self, value):
p = QPointF(value, 0)
cl_height = self.dendrogram.height_at(p)
self.set_cutoff_height(cl_height)
# Sync the cut positions between the dendrogram and the axis.
self._set_slider_value(value, self.dendrogram.size().width())
def _set_slider_value(self, value, span):
with blocked(self.cut_line):
self.cut_line.setValue(value)
self.cut_line.setRange(0, span)
with blocked(self.top_axis.line):
self.top_axis.line.setValue(value)
self.top_axis.line.setRange(0, span)
with blocked(self.bottom_axis.line):
self.bottom_axis.line.setValue(value)
self.bottom_axis.line.setRange(0, span)
def set_cutoff_height(self, height):
self.cutoff_height = height
if self.root:
self.cut_ratio = 100 * height / self.root.value.height
self.select_max_height(height)
def _set_cut_line_visible(self, visible):
self.cut_line.setVisible(visible)
self.top_axis.line.setVisible(visible)
self.bottom_axis.line.setVisible(visible)
def select_top_n(self, n):
root = self._displayed_root
if root:
clusters = top_clusters(root, n)
self.dendrogram.set_selected_clusters(clusters)
def select_max_height(self, height):
root = self._displayed_root
if root:
clusters = clusters_at_height(root, height)
self.dendrogram.set_selected_clusters(clusters)
def _selection_method_changed(self):
self._set_cut_line_visible(self.selection_method == 1)
if self.root:
self._apply_selection()
def _apply_selection(self):
if not self.root:
return
if self.selection_method == 0:
pass
elif self.selection_method == 1:
height = self.cut_ratio * self.root.value.height / 100
self.set_cutoff_height(height)
pos = self.dendrogram.pos_at_height(height)
self._set_slider_value(pos.x(), self.dendrogram.size().width())
elif self.selection_method == 2:
self.select_top_n(self.top_n)
def _selection_edited(self):
# Selection was edited by clicking on a cluster in the
# dendrogram view.
self.selection_method = 0
self._selection_method_changed()
class AurApplet(plasmascript.Applet):
def __init__(self, parent):
plasmascript.Applet.__init__(self, parent)
def _getData(self):
try:
self.data = aur_py2.aurUpdates()
except subprocess.CalledProcessError:
self.errorMsg = "Could not run pacman"
self.data = None
except IOError:
self.errorMsg = "Could not access the AUR"
self.data = None
def _writeData(self):
print self.data
string = ""
for line in self.data[0]:
string = string+line[0]+"\t"+line[1]+" -> "+line[2]+"\n"
self.updateData.setText(string)
string = ""
for line in self.data[1]:
string = string+line[0]+"\t"+line[1]+"\n"
self.oodData.setText(string)
string = ""
for line in self.data[2]:
string = string+line[0]+"\t"+line[1]+"\n"
self.orphanData.setText(string)
string = ""
for line in self.data[3]:
string = string+line[0]+"\t"+line[1]+"\n"
self.notFoundData.setText(string)
def _checkForNone(self):
if self.data == None:
self.updateInfo.setText("<h1>"+self.errorMsg+"</h1>")
else:
self.updateInfo.setText("<h1>Updates</h1>")
self.oodInfo.setText("<h1>Out Of Date</h1>")
self.orphanInfo.setText("<h1>Orphans</h1>")
self.notFoundInfo.setText("<h1>Not Found</h1>")
self._writeData()
def init(self):
self.updateInfo = Plasma.Label(self.applet)
self.updateData = Plasma.Label(self.applet)
self.oodInfo = Plasma.Label(self.applet)
self.oodData = Plasma.Label(self.applet)
self.orphanInfo = Plasma.Label(self.applet)
self.orphanData = Plasma.Label(self.applet)
self.notFoundInfo = Plasma.Label(self.applet)
self.notFoundData = Plasma.Label(self.applet)
self.layout = QGraphicsLinearLayout(Qt.Vertical, self.applet)
self.layout.addItem(self.updateInfo)
self.layout.addItem(self.updateData)
self.layout.addItem(self.oodInfo)
self.layout.addItem(self.oodData)
self.layout.addItem(self.orphanInfo)
self.layout.addItem(self.orphanData)
self.layout.addItem(self.notFoundInfo)
self.layout.addItem(self.notFoundData)
self._getData()
self._checkForNone()
class FlowModule:
def __init__(self):
self.name = "Pretok"
self.updateTimer = QTimer()
self.updateTimer.timeout.connect(self.update)
def makeLayout(self):
self.layout = QGraphicsLinearLayout(Qt.Vertical)
self.flowComboLayout = QGraphicsLinearLayout(Qt.Horizontal)
self.flowLabelLayout = QGraphicsGridLayout()
#Flow Layout
self.flowData = SvJanez()
self.flowView = QGraphicsWebView()
self.flowView.setUrl( QUrl(self.flowData.flowImageUrl) )
self.flowView.setEnabled(False)
self.flowSelectorCombo = Plasma.ComboBox()
self.flowSelectorCombo.addItem(u"Sveti Janez")
self.flowSelectorCombo.addItem(u"Soteska")
self.flowSelectorCombo.setMinimumWidth(125)
self.flowSelectorCombo.textChanged.connect(self.flowSourceChanged)
self.flowRefresh = Plasma.IconWidget()
self.flowRefresh.setIcon("view-refresh")
self.flowRefresh.clicked.connect(self.update)
self.flowEnlargeButton = Plasma.IconWidget()
self.flowEnlargeButton.setIcon("zoom-in")
self.flowEnlargeButton.clicked.connect(self.showFullFlowWidget)
self.flowLabel = Plasma.Label()
self.flowLabel.setText(u"<b>Pretok:</b> ")
self.flowDataLabel = Plasma.Label()
self.flowLevelLabel = Plasma.Label()
self.flowLevelLabel.setText(u"<b>Višina:</b> ")
self.flowLevelDataLabel = Plasma.Label()
self.flowTempLabel = Plasma.Label()
self.flowTempLabel.setText(u"<b>Temperatura:</b> ")
self.flowTempDataLabel = Plasma.Label()
self.flowLabelLayout.addItem(self.flowLevelLabel,0,0)
self.flowLabelLayout.addItem(self.flowLevelDataLabel,0,1)
self.flowLabelLayout.addItem(self.flowLabel,1,0)
self.flowLabelLayout.addItem(self.flowDataLabel,1,1)
self.flowLabelLayout.addItem(self.flowTempLabel,2,0)
self.flowLabelLayout.addItem(self.flowTempDataLabel,2,1)
self.flowUpdateTimeSelector = UpdateTimeSelector()
self.flowUpdateTimeSelector.setDefaultTime(4)
self.flowUpdateTimeSelector.setDefaultInterval('h')
self.flowUpdateTimeSelector.updateTimeSpin.valueChanged.connect(self.flowTimeChanged)
self.flowUpdateTimeSelector.updateCheckBox.toggled.connect(self.flowTimerToggle)
self.flowComboLayout.addItem(self.flowSelectorCombo)
self.flowComboLayout.addStretch()
self.flowComboLayout.addItem(self.flowEnlargeButton)
self.flowComboLayout.addItem(self.flowRefresh)
self.layout.addItem(self.flowComboLayout)
self.layout.addItem(self.flowView)
self.layout.addItem(self.flowLabelLayout)
self.layout.addStretch()
self.layout.addItem(self.flowUpdateTimeSelector.layout)
self.layout.itemAt(0).setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed, QSizePolicy.DefaultType)
self.layout.itemAt(2).setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed, QSizePolicy.DefaultType)
def flowTimerToggle(self, toggled):
if toggled:
multiplier = 1
if self.flowUpdateTimeSelector.getInterval() == 'min':
multiplier = 60
if self.flowUpdateTimeSelector.getInterval() == 'h':
multiplier = 60 * 60
self.updateTimer.start(self.flowUpdateTimeSelector.getTime() * 1000 * multiplier)
self.update()
else:
self.updateTimer.stop()
def flowTimeChanged(self, value):
if self.flowUpdateTimeSelector.isChecked():
self.updateTimer.stop()
self.flowTimerToggle(self.flowUpdateTimeSelector.isChecked())
def flowSourceChanged(self, text):
if text == "Sveti Janez":
self.flowData = SvJanez()
else:
self.flowData = Soteska()
self.flowView.setUrl(QUrl(self.flowData.flowImageUrl))
self.updateFlowLabels()
def updateFlowImage(self):
self.flowSourceChanged(self.flowSelectorCombo.text())
def updateFlowLabels(self):
self.flowData.fetchData()
self.flowDataLabel.setText(u"%s %s" % (self.flowData.currentFlow, u' m3/s'))
self.flowTempDataLabel.setText(u"%s %s" % (self.flowData.temperature , u' °C'))
self.flowLevelDataLabel.setText(u"%s %s" % (self.flowData.waterLevel , u' cm'))
def update(self):
try:
urllib.urlopen('http://www.google.com', timeout=2)
except:
self.offlineMode()
return
self.updateFlowLabels()
self.updateFlowImage()
def offlineMode(self):
self.flowView.setUrl(QUrl("weather-none-available.png"))
self.flowDataLabel.setText(u"N/A")
self.flowTempDataLabel.setText(u"N/A")
self.flowLevelDataLabel.setText(u"N/A")
def showFullFlowWidget(self):
fullcamwidget = FullCamWidget()
fullcamwidget.show(self.flowView.url(), 840, 400)
class Multimobilewidget(plasmascript.Applet):
def __init__(self, parent, args=None):
plasmascript.Applet.__init__(self, parent)
def init(self):
self.setHasConfigurationInterface(False)
self.setAspectRatioMode(Plasma.Square)
self.theme = Plasma.Svg(self)
self.setBackgroundHints(Plasma.Applet.DefaultBackground)
self.layout = QGraphicsLinearLayout(Qt.Vertical, self.applet)
self.getLogin()
self.setHasConfigurationInterface(True)
self.label = Plasma.Label(self.applet)
self.label.setText(i18n("Welcome to the Multimobilewidget"))
nrlabel = Plasma.Label(self.applet)
nrlabel.setText(i18n("Phonenr(s)"))
self.messagelabel = Plasma.Label(self.applet)
self.messagelabel.setText(i18n("Message - 0 signs used"))
self.nrfield = Plasma.LineEdit()
self.messageText = Plasma.TextEdit(self.applet)
self.messageText.nativeWidget()
sendButton = Plasma.PushButton(self.applet)
sendButton.setText(i18n("Send the SMS!"))
sendButton.resize(20, 40)
configButton = Plasma.PushButton(self.applet)
configButton.setText("Config")
configButton.resize(20, 40)
self.layout.addItem(self.label)
self.layout.addItem(nrlabel)
self.layout.addItem(self.nrfield)
self.layout.addItem(self.messagelabel)
self.layout.addItem(self.messageText)
self.layout.addItem(sendButton)
self.layout.addItem(configButton)
self.applet.setLayout(self.layout)
self.connect(sendButton, SIGNAL("clicked()"), self.onSendClick)
self.connect(configButton, SIGNAL("clicked()"), self.onConfigClick)
self.connect(self.messageText, SIGNAL("textChanged()"), self.onTextChanged)
fullPath = str(self.package().path())
self.providerPluginManager = PluginManager("multimobilewidget/contents/code/providerplugins/","", providerplugins.Provider.Provider)
self.providerpluginlist = self.providerPluginManager.getPluginClassList()
for provider in self.providerpluginlist:
self.ui.providerList.addItem(provider.getObjectname())
print provider.getObjectname()
self.ui.providerList.setCurrentRow(0)
self.adressplugins = PluginManager("multimobilewidget/contents/code/adressplugins/","", adressplugins.AdressPlugin.AdressPlugin)
self.adresspluginlist = self.adressplugins.getPluginClassList()
self.adressList = list()
def onConfigClick(self):
from config import config
self.startAssistant = config(self.providerPluginManager, self.adressplugins)
self.startAssistant.show()
self.connect(self.startAssistant, SIGNAL("finished(int)"), self.getLogin)
def connectToAkonadi(self):
self.akonadiEngine = Plasma.DataEngine()
self.akonadiEngine.setName("akonadi")
def onSendClick(self):
for provider in self.providerpluginlist:
if(provider.getObjectname() == self.ui.providerList.selectedItems()[0].text()):
sms = provider
if self.ui.smstext.toPlainText() != "":
if self.ui.phonenr.text() != "":
self.getLogin()
try:
sms.setConfig(self.config)
except Exception:
self.onConfigClick()
return
sms.clearNrs()
for nr in re.findall("(\+\d*)", self.ui.phonenr.text()):
sms.addNr(nr)
sms.setText(self.ui.smstext.toPlainText())
savenr = self.ui.phonenr.text()
try:
sms.execute()
# self.notification.setText(i18n("Wurde erfolgreich an <i>%1</i> geschickt!").arg(savenr ))
# self.notification.setTitle("Erfolg!")
# self.notification.sendEvent()
KMessageBox.information(None, i18n("SMS sendet successfully to " + savenr + ". Service: "+sms.getProvidername()), i18n("Success!"))
except Exception, error:
KMessageBox.error(None, i18n(error.message), i18n("Sendproblems"))
self.ui.phonenr.clear()
self.ui.smstext.clear()
else:
KMessageBox.error(None, i18n("Please fill in a phonenr"), i18n("Please fill in a phonenr"))
else:
class PlasmaFreq(plasmascript.Applet):
def __init__(self, parent, args=None):
# Init for plasma applet
plasmascript.Applet.__init__(self, parent)
def listGovernors(self):
# Lists governors aka power modes available in current system.
self.listGovPath = "/sys/devices/system/cpu/cpu0/cpufreq/scaling_available_governors"
governorsFile = open(self.listGovPath, 'r') # Open the file
availableGovernors = governorsFile.read()
governorsList = split(
" +", availableGovernors
) # Splitting the string to list, space is the separator
governorsList.remove(
"\n") # Remove newline item from list, added by split
governorsFile.close()
return governorsList
def listFrequencies(self):
# Lists processor core frequencies available for scaling
self.listFreqPath = "/sys/devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies"
frequenciesFile = open(self.listFreqPath, 'r')
availableFrequencies = frequenciesFile.read()
frequenciesList = split(" +", availableFrequencies)
frequenciesList.remove("\n")
frequenciesFile.close()
return frequenciesList
def currentFrequency(self):
# Returns a string containing the current governor
self.curFreqPath = "/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq"
frequencyFile = open(self.curFreqPath, 'r')
if self.curFreqPath not in self.watcher.files():
self.watcher.addPath(self.curFreqPath)
currentFrequency = frequencyFile.read()
currentFrequency = currentFrequency.rstrip(
) # Removes newline from string, since we don't need a list for this.
frequencyFile.close()
return currentFrequency
def currentGovernor(self):
self.curGovPath = "/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor"
governorFile = open(self.curGovPath, 'r')
if self.curGovPath not in self.watcher.files(
): # Not adding file to watcher in case of it excists already
self.watcher.addPath(self.curGovPath)
currentGovernor = governorFile.read()
currentGovernor = currentGovernor.rstrip(
) # Removes newline from string, since we don't need a list for this.
governorFile.close()
return currentGovernor
def file_changed(self, path):
if path == self.curGovPath: # When scaling governor has changed, this is true
self.currentGovernorStr = self.currentGovernor()
self.radioButton[self.currentGovernorStr].setChecked(
True) # Check radioButton that represents the new governor
if path == self.curFreqPath:
self.currentFrequencyStr = self.currentFrequency()
def applyChanges(self):
# With some Linux distros kdesudo is not default/not even available in official software repositories
kdesudoY = True
try:
call(["kdesudo", "--"])
except OSError:
kdesudoY = False
#kdesudoY := just a flag to change command in the cycle below while keeping changes to code separated
# We basically run a for-loop to try out that which radioButton is checked. Better ways warmly welcome.
for x in self.availableGovernors:
if self.radioButton[x].isChecked(
) == True: # radioButton for x governor is checked
cpufreqFiles = " ".join(
self.cpufreqGovPath
) # Converting list to space-separated string
if kdesudoY:
governor = '"%s"' % x # Adding quotes to governor name
# Insert some variables to command. We should use KAuth instead of kdesudo but I have no idea how to use KAuth in python
cmd = "kdesudo -i %s --comment '<b>PlasmaFreq</b> need administrative priviledges. Please enter your password.' -c 'echo %s | tee %s'" % (
self.icon, governor, cpufreqFiles)
else:
# no kdesudo: use kdesu in cmd
governor = "%s" % x # Adding single (to work with kdesu + tee) quotes to governor name
# Insert some variables to command. We should use KAuth instead of kdesu(do) but I have no idea how to use KAuth in python
cmd = "kdesu -i %s -c 'echo %s | tee %s'" % (
self.icon, governor, cpufreqFiles)
# Run the command. shell=True would be a security vulnerability (shell injection) if the cmd parameter would have something from user input
fnull = open(
devnull,
'w') # Open /dev/null for stdout/stderr redirection
call(cmd, shell=True, stdout=fnull, stderr=fnull)
fnull.close()
def init(self):
# Setting some Plasma-specific settings
self.setHasConfigurationInterface(
False) # We dont have a configuration interface, yet.
self.setAspectRatioMode(Plasma.IgnoreAspectRatio)
self.theme = Plasma.Svg(self)
self.setBackgroundHints(Plasma.Applet.DefaultBackground)
self.layout = QGraphicsLinearLayout(Qt.Vertical, self.applet)
self.applet.setLayout(self.layout)
self.icon = self.package().path(
) + "plasmafreq.svg" # Finding a path for our apps icon
# Adding a nice-looking GroupBox for RadioButtons
self.setGovernorBox = Plasma.GroupBox(self.applet)
self.setGovernorBox.setText("Mode selection")
self.setGovernorBox.setLayout(
QGraphicsLinearLayout(Qt.Vertical, self.setGovernorBox))
self.setGovernorBox.setSizePolicy(
QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding))
self.layout.addItem(self.setGovernorBox)
self.governorGroup = QButtonGroup(
self.applet
) # Creating a abstract ButtonGroup in order to link RadioButtons together
# Creating a QFileSystemWatcher to watch changes in current frequency and governor
self.watcher = QFileSystemWatcher(self)
QObject.connect(self.watcher, SIGNAL("fileChanged(const QString&)"),
self.file_changed)
# Setting paths for cpufreq
self.cpuCores = glob(path.join("/sys/devices/system/cpu/",
"cpu?")) # List all CPU cores
self.cpufreqGovPath = []
# This is going to be ugly...but hey, it works (at least if you dont have many physical CPUs. Cores are ok)
for x in self.cpuCores:
self.cpufreqGovPath.append(
x + "/cpufreq/scaling_governor"
) # path.join doesn't work here, dunno why
# Initializing some variables and setting variables to them.
self.availableFrequencies = self.listFrequencies()
self.availableGovernors = self.listGovernors()
self.currentGovernorStr = self.currentGovernor()
self.currentFrequencyStr = self.currentFrequency()
self.radioButton = {}
# This contains texts and tooltips for RadioButtons
self.governorTextsDict = {
'conservative': [
'Conservative',
'Similiar to On Demand, but CPU clock speed switches gradually through all its available frequencies based on system load '
],
'ondemand': [
'On Demand',
'Dynamically switches between the CPU available clock speeds based on system load '
],
'userspace':
['User Defined', 'Lets user to manually configure clock speeds'],
'powersave': ['Powersave', 'Runs the CPU at minimum clock speeds'],
'performance':
['Performance', 'Runs the CPU at maximum clock speeds']
}
for x in self.availableGovernors:
# Makes a RadioButton for each governor available.
self.radioButton[x] = Plasma.RadioButton(self.applet)
self.radioButton[x].setText(
self.governorTextsDict[x][0]
) # Sets the text for radioButton from governorTextsDict above
self.radioButton[x].setToolTip(self.governorTextsDict[x][1])
self.radioButton[x].setSizePolicy(
QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred))
self.governorGroup.addButton(self.radioButton[x].nativeWidget(
)) # We need to add radioButton's native widget
self.setGovernorBox.layout().addItem(self.radioButton[x])
if x == self.currentGovernorStr:
self.radioButton[x].setChecked(
True
) # Checks if x is current governor and should we have a tick on RadioButton
# Add a button for applying changes
self.applyButton = Plasma.PushButton(self.applet)
self.applyButton.setText("Apply")
self.applyButton.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum))
self.layout.addItem(self.applyButton)
QObject.connect(self.applyButton, SIGNAL("clicked()"),
self.applyChanges)
def init(self):
"""
create interface, this method invoked by plasma it self
"""
self.setHasConfigurationInterface(True)
self.setAspectRatioMode(Plasma.IgnoreAspectRatio)
self.setBackgroundHints(Plasma.Applet.DefaultBackground)
#
self.flash = Plasma.FlashingLabel(self.applet)
self.flash.setAutohide(True)
self.flash.setMinimumSize(0, 20)
self.flash.setDuration(2000)
self.tab_bar = Plasma.TabBar()
self._layout = QGraphicsLinearLayout(Qt.Vertical, self.applet)
self._layout.setSpacing(3)
flash_layout = QGraphicsLinearLayout(Qt.Horizontal)
flash_layout.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
fnt = Plasma.Theme.defaultTheme().font(Plasma.Theme.DefaultFont)
fnt.setBold(True)
fm = QFontMetrics(fnt)
self.flash.setFont(fnt)
self.flash.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
title_layout = QGraphicsLinearLayout(Qt.Vertical)
flash_layout.addItem(self.flash)
flash_layout.addItem(title_layout)
self.main_frame = Plasma.Frame(self.applet)
m_header_layout = QGraphicsAnchorLayout(self.main_frame)
m_header_layout.setSpacing(5)
self.icon = Plasma.IconWidget(self.main_frame)
self.icon.setIcon(KIcon("user-identity"))
self.icon.setTextBackgroundColor(QColor())
icon_size = self.icon.sizeFromIconSize(48)
self.icon.setMinimumSize(icon_size)
self.icon.setMaximumSize(icon_size)
m_header_layout.addAnchor(self.icon, Qt.AnchorVerticalCenter, m_header_layout, Qt.AnchorVerticalCenter)
m_header_layout.addAnchor(self.icon, Qt.AnchorLeft, m_header_layout, Qt.AnchorLeft)
status_edit_frame = Plasma.Frame(self.main_frame)
status_edit_frame.setFrameShadow(Plasma.Frame.Sunken)
status_edit_layout = QGraphicsLinearLayout(status_edit_frame)
self.status_edit = Plasma.TextEdit()
self.status_edit.setPreferredHeight(fm.height() * 4)
self.status_edit.setEnabled(False)
status_edit_layout.addItem(self.status_edit)
edit_pal = self.status_edit.palette()
m_color_scheme = KColorScheme(QPalette.Active, KColorScheme.View, Plasma.Theme.defaultTheme().colorScheme())
edit_pal.setColor(QPalette.Text, m_color_scheme.foreground().color())
self.status_edit.nativeWidget().setPalette(edit_pal)
self.status_edit.nativeWidget().installEventFilter(self)
m_header_layout.addAnchor(self.icon, Qt.AnchorRight, status_edit_frame, Qt.AnchorLeft)
m_header_layout.addAnchors(status_edit_frame, m_header_layout, Qt.Vertical)
m_header_layout.addAnchor(status_edit_frame, Qt.AnchorRight, m_header_layout, Qt.AnchorRight)
m_header_layout.activate()
m_header_layout.setMaximumHeight(m_header_layout.effectiveSizeHint(Qt.PreferredSize).height())
self.scroll_widget = Plasma.ScrollWidget(self.applet)
self.tweets_widget = QGraphicsWidget(self.scroll_widget)
self.scroll_widget.setWidget(self.tweets_widget)
self.tweets_layout = QGraphicsLinearLayout(Qt.Vertical, self.tweets_widget)
self.tweets_layout.setSpacing(3)
self.tweets_layout.addItem(self.main_frame)
self.tab_bar.addTab(self.trUtf8("Timeline"))
self.tab_bar.addTab(self.trUtf8("Replies"))
self.tab_bar.addTab(self.trUtf8("Messages"))
self._layout.addItem(flash_layout)
self._layout.addItem(self.tab_bar)
self._layout.addItem(self.scroll_widget)
self.applet.setLayout(self._layout)
self.connect(self.tab_bar, SIGNAL('currentChanged(int)'), self.mode_changed)
self.connect(self.status_edit, SIGNAL('textChanged()'), self.edit_text_changed)
self.check_config()
class IMAPresourceStatus(plasmascript.Applet):
def __init__(self,parent,args=None):
plasmascript.Applet.__init__(self,parent)
def init(self):
self.setHasConfigurationInterface(False)
self.setAspectRatioMode(Plasma.Square)
# Theme
self.theme = Plasma.Svg(self)
self.theme.setImagePath("widgets/background")
self.theme.setContainsMultipleImages(False)
self.setBackgroundHints(Plasma.Applet.DefaultBackground)
# DBus
loop = DBusQtMainLoop()
dbus.set_default_main_loop(loop)
self.sessionBus = dbus.SessionBus()
i = 0
while i < 10:
# ugly hack to wait for service to be available
i = i + 1
try:
self.imap_res = self.sessionBus.get_object('org.freedesktop.Akonadi.Agent.' + RES, '/')
self.imap_res.connect_to_signal("onlineChanged", self.onlineChanged)
except dbus.exceptions.DBusException as e:
if(e.get_dbus_name() == "org.freedesktop.DBus.Error.ServiceUnknown"):
# Service is not yet ready
print "Waiting for 'org.freedesktop.Akonadi.Agent.%s/' to become available..." % RES
time.sleep(0.2)
else:
break
else:
break
# Icon
self.layout = QGraphicsLinearLayout(Qt.Horizontal, self.applet)
self.icon = Plasma.IconWidget()
self.icon.mousePressEvent = self.mousePressEvent
self.icon.mouseReleaseEvent = self.mouseReleaseEvent
if self.isOnline():
self.onlineChanged(True)
else:
self.onlineChanged(False)
self.layout.addItem(self.icon)
self.applet.setLayout(self.layout)
def isOnline(self):
return self.imap_res.isOnline(dbus_interface='org.freedesktop.Akonadi.Agent.Status')
def onlineChanged(self, status):
if status:
self.icon.setIcon(self.package().path() + "contents/icons/network-server-on.png")
else:
self.icon.setIcon(self.package().path() + "contents/icons/network-server-off.png")
def mouseReleaseEvent(self,event):
if self.isOnline():
state = False
else:
state = True
self.imap_res.setOnline(state, dbus_interface='org.freedesktop.Akonadi.Agent.Status')
def mousePressEvent(self, event):
if event.buttons() == Qt.LeftButton:
self.clicked = self.scenePos().toPoint()
event.setAccepted(True)
class CamModule:
def __init__(self):
self.name = "Kamere"
#Cam urls
self.camUrls = {u"Ribčev Laz (v živo)": "http://firma.sportnet.si:8080/dvs2000/r1.jpg",\
u"Ribčev Laz": "http://www.bohinj.si/cam/slika3.jpg",\
u"Vogel - 1" : "http://www.snezni-telefon.si/Images/Kamere/6_a.jpg",\
u"Vogel - 2" : "http://www.snezni-telefon.si/Images/Kamere/6_b.jpg",\
u"Vogel - 3" : "http://www.snezni-telefon.si/Images/Kamere/6_c.jpg",\
u"Vogel - 4" : "http://www.snezni-telefon.si/Images/Kamere/6_d.jpg",\
u"Bohinjska Češnjica" : "http://www2.arnes.si/~smisma1/canon.jpg",\
u"Bohinjska Bistrica" : "http://www.drsc.si/kamere/kamslike/bohinjska/slike/boh1_0001.jpg",\
u"Orožnova koča": "http://www.bohinj.si/cam/lisc/slika1.jpg"}
self.camSizes ={u"Ribčev Laz (v živo)": "352x228", \
u"Ribčev Laz": "2048x1536",\
u"Vogel - 1" : "1280x1024",\
u"Vogel - 2" : "640x480",\
u"Vogel - 3" : "1280x1024",\
u"Vogel - 4" : "640x480",\
u"Bohinjska Češnjica" : "800x600",\
u"Bohinjska Bistrica" : "352x228",\
u"Orožnova koča": "1280x1024"}
self.updateTimer = QTimer()
self.updateTimer.timeout.connect(self.update)
def makeLayout(self):
self.layout = QGraphicsLinearLayout(Qt.Vertical)
self.topCamLayout = QGraphicsLinearLayout(Qt.Horizontal)
# Cam layout
self.camRefreshButton = Plasma.IconWidget()
self.camRefreshButton.setIcon("view-refresh")
self.camRefreshButton.clicked.connect(self.update)
self.camTimeLabel = Plasma.Label()
self.camTimeLabel.setText(u"ob")
self.camEnlargeButton = Plasma.IconWidget()
self.camEnlargeButton.setIcon("zoom-in")
self.camEnlargeButton.clicked.connect(self.showFullCamWidget)
self.camSelectorCombo = Plasma.ComboBox()
for source in sorted(self.camUrls.keys()):
self.camSelectorCombo.addItem(source)
self.camSelectorCombo.setMinimumWidth(125)
self.camSelectorCombo.textChanged.connect(self.camChanged)
self.camView = QGraphicsWebView()
self.camView.setEnabled(False)
self.camTimeDataLabel = Plasma.Label()
self.camUpdateTimeSelector = UpdateTimeSelector()
self.camUpdateTimeSelector.setDefaultTime(30)
self.camUpdateTimeSelector.setDefaultInterval('min')
self.camUpdateTimeSelector.updateTimeSpin.valueChanged.connect(self.camTimeChanged)
self.camUpdateTimeSelector.updateCheckBox.toggled.connect(self.camTimerToggle)
self.topCamLayout.addItem(self.camSelectorCombo)
self.topCamLayout.addItem(self.camTimeLabel)
self.topCamLayout.addItem(self.camTimeDataLabel)
self.topCamLayout.addStretch()
self.topCamLayout.addItem(self.camEnlargeButton)
self.topCamLayout.addItem(self.camRefreshButton)
self.layout.addItem(self.topCamLayout)
self.layout.addItem(self.camView)
self.layout.addItem(self.camUpdateTimeSelector.layout)
self.layout.itemAt(0).setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed, QSizePolicy.DefaultType)
self.layout.itemAt(2).setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed, QSizePolicy.DefaultType)
def update(self, text=None):
try:
urllib.urlopen('http://www.google.com', timeout=2)
except:
self.offlineMode()
return
if not self.camUpdateTimeSelector.updateCheckBox.isChecked():
self.updateTimer.stop()
self.camChanged(self.camSelectorCombo.text())
self.setCamTimeLabel()
def offlineMode(self):
self.camView.setUrl(QUrl("weather-none-available.png"))
self.camTimeDataLabel.setText(" ni na voljo.")
def setCamTimeLabel(self):
hour = time.localtime().tm_hour if not time.localtime().tm_hour in range(10) else '0' + str(time.localtime().tm_hour)
minute = time.localtime().tm_min if not time.localtime().tm_min in range(10) else '0' + str(time.localtime().tm_min)
second = time.localtime().tm_sec if not time.localtime().tm_sec in range(10) else '0' + str(time.localtime().tm_sec)
self.camTimeDataLabel.setText(u'<b>%s:%s:%s</b>' % (str(hour), str(minute), str(second)) )
def camTimerToggle(self, toggled):
if toggled:
multiplier = 1
if self.camUpdateTimeSelector.getInterval() == 'min':
multiplier = 60
if self.camUpdateTimeSelector.getInterval() == 'h':
multiplier = 60 * 60
self.updateTimer.start(self.camUpdateTimeSelector.getTime() * 1000 * multiplier)
self.update()
else:
self.updateTimer.stop()
def camChanged(self, text):
self.camView.setUrl( QUrl( self.camUrls[unicode(text)] ) )
self.setCamTimeLabel()
def camTimeChanged(self, value):
if self.camUpdateTimeSelector.isChecked():
self.updateTimer.stop()
self.camTimerToggle(self.camUpdateTimeSelector.isChecked())
def showFullCamWidget(self):
fullcamwidget = FullCamWidget()
size = self.camSizes[unicode(self.camSelectorCombo.text())]
size = [ int(i) for i in size.split('x')]
if size[0] < 640 and size[1] < 480:
fullcamwidget.show(self.camView.url(), size[0] + 25, size[1] + 125)
else:
fullcamwidget.show(self.camView.url(), 645, 505)
