class Tray(QObject):
activated = pyqtSignal()
def __init__(self, parent, title, icon):
QObject.__init__(self)
# Setup contextual menu
if kde:
self.menu = KMenu(parent)
self.tray = KStatusNotifierItem(parent)
self.tray.setStatus(KStatusNotifierItem.Passive)
self.tray.setCategory(KStatusNotifierItem.ApplicationStatus)
self.tray.setAssociatedWidget(parent)
self.tray.setStandardActionsEnabled(False)
self.tray.activateRequested.connect(self._activateRequested)
else:
self.menu = QMenu()
self.tray = QSystemTrayIcon()
self.tray.activated.connect(self._activated)
self.setIcon(icon)
self.setTitle(title)
if not kde:
self.tray.show()
self.tray.setContextMenu(self.menu)
def setActive(self, active=True):
if kde:
self.tray.setStatus(KStatusNotifierItem.Active if active else KStatusNotifierItem.Passive)
def setTitle(self, title):
if kde:
self.tray.setTitle(title)
self.tray.setToolTipTitle(title)
else:
self.tray.setToolTip(title)
self.menu.setTitle(title)
def setToolTipSubTitle(self, subtitle):
if kde:
self.tray.setToolTipSubTitle(subtitle)
def setIcon(self, icon):
if kde:
self.tray.setIconByPixmap(icon)
self.tray.setToolTipIconByPixmap(icon)
else:
self.tray.setIcon(icon)
def showMessage(self, title, message, icon=None):
if kde:
self.tray.showMessage(title, message, "network-server")
else:
self.tray.showMessage(title, message, QSystemTrayIcon.Information if icon is None else icon)
def _activated(self, reason):
if reason == QSystemTrayIcon.DoubleClick:
self.activated.emit()
def _activateRequested(self, active, pos):
self.activated.emit()
class SystemTrayRemoto(ServicoFuncao):
def __init__(self, parent=None):
super().__init__(5433, 5433, parent)
self.systemTray = QSystemTrayIcon()
self.systemTray.setIcon(QIcon("bad.svg"))
self.systemTray.show()
@send_funcao
def ativar(self, titulo, mensagem):
self.systemTray.showMessage(titulo, mensagem, QSystemTrayIcon.Information, 3000)
class StartQT4(Windows):
def keyPressEvent(self, event):
k = event.key()
if k == QtCore.Qt.Key_Escape:
sys.exit()
elif k == QtCore.Qt.Key_Enter-1:
self.ui.btnSend.clicked.emit(True)
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_winMain()
self.ui.setupUi(self)
QtCore.QObject.connect(self.ui.btnSend, QtCore.SIGNAL("clicked()"), self.SendQuery)
self.setMouseTracking(True)
self.setWindowFlags(QtCore.Qt.FramelessWindowHint|QtCore.Qt.WindowStaysOnTopHint| Qt.Popup | Qt.Tool)
# 创建托盘
self.icon = QIcon("img.png")
self.trayIcon = QSystemTrayIcon(self)
self.trayIcon.setIcon(self.icon)
self.trayIcon.setToolTip(u"simple有道")
self.trayIcon.show()
# 托盘气泡消息
self.trayIcon.showMessage(u"simple有道", u"simple有道已经启动，随时待命！")
# 托盘菜单
self.action = QAction(u"退出simple有道", self, triggered = sys.exit) # 触发点击后调用sys.exit()命令，即退出
self.menu = QMenu(self)
self.menu.addAction(self.action)
self.trayIcon.setContextMenu(self.menu)
self.move(1100,50)
#开启监听线程
system("xclip -f /dev/null") #清空剪切板
listener = Thread(target=listenMouse, args=(self.ui,))
listener.setDaemon(True)
listener.start()
def SendQuery(self):
querystring = "http://fanyi.youdao.com/openapi.do?keyfrom=hustbg&key=1205943053&type=data&doctype=json&version=1.1&q="+unicode(self.ui.txtSend.text())
response = json.loads(requests.get(querystring).text)
try:
result = u" 音标:"+response["basic"].get("phonetic","")+u"\n 翻译:"+u','.join(response["translation"])+u"\n 解释:\n "+'\n '.join(response["basic"]["explains"][0:2])
self.ui.labresult.setText(result)
except:
self.ui.labresult.setText(u"没有查到相关记录")
class sysBaloon(QMainWindow):
def baloon(self, t, m, tm=50000):
self.trayicon = QSystemTrayIcon(self)
if self.trayicon.supportsMessages():
icona = QIcon('py.ico')
self.trayicon.setIcon(icona)
self.trayicon.show()
self.trayicon.showMessage(t, m, msecs=tm)
time.sleep(10)
self.trayicon.hide()
else:
print "This Function isn't supported."
choose = raw_input("Would you enable it? Y/N \n --> ")
if choose == "Y":
shell = os.popen('enable_baloon.reg')
print "Run again this program"
elif choose == "N":
print "You don't use this program without baloon enabled."
else:
print "You have insert wrong char."
class SessionTesterWindow(QMainWindow, Ui_MainAppWindow):
progress_bar_change = QtCore.pyqtSignal()
session_end = QtCore.pyqtSignal()
def __init__(self):
QMainWindow.__init__(self)
self.isStarted = False
self.isPaused = True
self.isRIP = False
self.current_time = 0
self.tray_icon = QSystemTrayIcon(QIcon("sessiontester/resources/trayicon.xpm"))
self.tray_icon.activated.connect(self.maximize_window)
self.tray_icon.show()
self.session_end.connect(self.session_end_message)
self.setupUi(self)
self.sessionStartButton.clicked.connect(self.start_session)
self.newSessionButton.clicked.connect(self.new_session)
self.exportSessionButton.clicked.connect(self.export_session)
self.settingsButton.clicked.connect(self.open_settings)
self.progressBar.setTextVisible(True)
self.progressBar.setFormat("Session progress")
self.session_config = SessionConfig(os.path.join(os.path.expanduser('~'),'sessiontester','config.ini'))
def start_session(self):
self.session_time = self.__count_session_time(
self.sessionTimeField.time().toString("hh:mm:ss"))
if (self.isPaused is True) & (self.session_time > 0):
self.isPaused = False
self.sessionStartButton.setText("Pause session")
self.session_time = self.__count_session_time(
self.sessionTimeField.time().toString("hh:mm:ss"))
self.progressBar.setMaximum(self.session_time)
if self.isRIP is True:
self.progressBar.setValue(0)
self.current_time = 0
self.isRIP = False
self.progress_bar_change.connect(self.set_progress_bar)
self.t = threading.Thread(target=self.set_progress)
self.t.daemon = True
self.t.start()
else:
self.sessionStartButton.setText("Start session")
self.isPaused = True
def new_session(self):
self.progressBar.setValue(0)
self.progressBar.setFormat("Session progress")
self.sessionStartButton.setText("Start session")
self.current_time = 0
self.isPaused = True
def export_session(self):
export_session.export_session_to_html(self.textEdit.toPlainText(), self.session_config)
def set_progress_bar(self):
self.progressBar.setValue(self.current_time)
self.progressBar.setFormat("Time left:" + str(
datetime.timedelta(seconds=self.time_to_go)))
def session_end_message(self):
self.tray_icon.showMessage("Session is over!", "Session time is over")
self.sessionStartButton.setText("Start session")
self.progressBar.setFormat("Session is over!")
self.isPaused = True
self.isRIP = True
def set_progress(self):
while (self.current_time < self.session_time):
if self.isPaused is False:
time.sleep(1)
else:
break
if self.isPaused is False:
self.current_time = self.current_time + 1
self.progress_bar_change.emit()
self.time_to_go = self.session_time - self.current_time
if self.current_time == self.session_time:
self.session_end.emit()
def __count_session_time(self, time_string):
self.result_date = time_string.split(":")
return (int(self.result_date[0])*3600) + (int(self.result_date[1])*60) + int(self.result_date[2])
def maximize_window(self):
if self.isHidden() is False:
self.hide()
elif self.isHidden() is True:
self.show()
def open_settings(self):
self.settings = SettingsWindow(self)
self.settings.show()
class Terminals(QWidget):
ready = pyqtSignal(bool)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.ui = uic.loadUiType('terminal.ui')[0]()
self.ui.setupUi(self)
self.notifier = QSystemTrayIcon(QIcon('arrow-up-icon.png'), self)
self.notifier.show()
self.model = None
self.mainloop = None
self.delegate = None
def test_display(self):
if self.mainloop:
self.mainloop.test_display()
def update_device_config(self):
if self.mainloop:
self.mainloop.update_config()
def terminal_open(self, addr):
if self.mainloop:
self.mainloop.terminal_open(addr)
def terminal_close(self, addr):
if self.mainloop:
self.mainloop.terminal_close(addr)
def start_mainloop(self):
if self.mainloop is None:
self.mainloop = Mainloop(parent=self)
self.mainloop.ready.connect(self.on_mainloop_ready)
self.mainloop.notify.connect(lambda title, msg: self.notifier.showMessage(title, msg))
self.mainloop.start()
def stop_mainloop(self):
if self.mainloop:
self.mainloop.state.disconnect()
self.mainloop.ready.disconnect()
self.mainloop.notify.disconnect()
[self.ui.terminals.closePersistentEditor(self.model.index(row, 0))
for row in xrange(self.model.rowCount())]
self.mainloop.stop()
self.mainloop = None
def update_model(self):
self.stop_mainloop()
self.start_mainloop()
def on_mainloop_ready(self, ok, titles):
if ok:
self.model = QStandardItemModel(len(titles), 1)
[self.model.setItem(i, QStandardItem(str(addr))) for i, addr in enumerate(titles.keys())]
self.delegate = TerminalDelegate(self.mainloop, titles)
self.mainloop.report.connect(self.delegate.report)
self.mainloop.state.connect(self.delegate.state)
self.ui.terminals.setModel(self.model)
self.ui.terminals.setItemDelegateForColumn(0, self.delegate)
[self.ui.terminals.openPersistentEditor(self.model.index(row, 0))
for row in xrange(self.model.rowCount())]
self.mainloop.db.free_places_update.connect(self.ui.free_places.setValue)
self.mainloop.update_config()
else:
self.model = None
self.mainloop = None
self.ready.emit(ok)
class MainWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, VENDOR, APP)
self.setup = ConfigDialog(None, Qt.WindowSystemMenuHint | Qt.WindowTitleHint)
self.setup.setModal(True)
centerOnScreen(self.setup)
self.setup.wake.connect(self.wake)
self.setup.serversChanged.connect(self.updateMenu)
self.menuServers = []
self.trayIcon = QSystemTrayIcon(QIcon("res/power.png"), self)
self.trayIcon.activated.connect(self.activated)
menu = QMenu()
self.populateMenuFromSettings(menu)
menu.addSeparator()
self.setupAction = menu.addAction(QIcon('res/setup.png'), "Configure")
self.setupAction.triggered.connect(self.setup.show)
menu.addSeparator()
exitAction = menu.addAction("Exit")
exitAction.triggered.connect(self.close)
self.trayIcon.setContextMenu(menu)
self.trayIcon.setToolTip("Wake on LAN")
self.trayIcon.show()
servers = self.settings.beginReadArray("servers")
self.settings.endArray()
if not servers:
self.setup.show()
def populateMenuFromSettings(self, menu):
"""
:type menu: QMenu
"""
actions = menu.actions()
before = actions[0] if actions else None
title = QWidgetAction(menu)
label = QLabel("Hosts")
font = label.font()
px = font.pointSize()
font.setBold(True)
font.setPointSize(px * 1.5)
label.setFont(font)
label.setMargin(4)
label.setIndent(10)
# label.setStyleSheet("font-weight: bold; margin: 4px 2px; border-bottom: 2px solid black")
title.setDefaultWidget(label)
menu.insertAction(before, title)
self.menuServers.append(title)
servers = self.settings.beginReadArray("servers")
for d in range(servers):
self.settings.setArrayIndex(d)
server = Server.fromSettings(self.settings)
action = QAction(QIcon("res/server.png"), server.alias, menu)
menu.insertAction(before, action)
action.setData(server)
action.triggered.connect(self.wakeFromMenu)
self.menuServers.append(action)
self.settings.endArray()
def activated(self, reason):
if reason == QSystemTrayIcon.DoubleClick:
self.setup()
elif reason == QSystemTrayIcon.Trigger:
menu = QMenu()
self.populateMenuFromSettings(menu)
menu.exec_(QCursor.pos())
def updateMenu(self):
menu = self.trayIcon.contextMenu()
for action in self.menuServers:
action.setData(None)
menu.removeAction(action)
self.populateMenuFromSettings(menu)
def wakeFromMenu(self):
action = self.sender()
server = action.data().toPyObject()
self.wake(server)
def wake(self, server):
if QMessageBox.Yes == QMessageBox.question(self, "Wake on LAN", "Wake %s?" % server.alias, QMessageBox.Yes|QMessageBox.No):
magic = '\xFF' * 6
bits = str(server.mac).split(':')
machex = ''.join([struct.pack('B', (int(x, 16))) for x in bits])
magic += machex * 16
sock = socket(type=SOCK_DGRAM)
if server.broadcast:
sock.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
sock.sendto(magic, ('<broadcast>', server.port))
sock.close()
self.trayIcon.showMessage("Wake on LAN", "Magic packet was sent to %s" % server.alias, msecs=3000)
def close(self):
QApplication.quit()
class KerberusSystray(QWidget):
def __init__(self):
self.chequeos_activos = True
self.ultimo_estado_kerberus = True
QWidget.__init__(self)
#icono = 'kerby-activo.ico'
#pixmap = QPixmap(icono)
self.style = self.style()
##setear el nombre de la ventana
self.setWindowTitle('Kerberus Control Parental')
#colocar el icono cargado a la ventana
self.setWindowIcon(self.style.standardIcon(
QStyle.SP_DialogYesButton))
self.filtradoHabilitado = True
if not os.path.isfile('dontShowMessage'):
self.mostrarMensaje = True
self.noMostrarMasMensaje()
else:
self.mostrarMensaje = False
#Menu
self.menu = QMenu('Kerberus')
#accion configurar Dominios
self.configurarDominiosAction = self.menu.addAction(
'Permitir/Denegar dominios'
)
#accion deshabilitar filtrado
self.deshabilitarFiltradoAction = self.menu.addAction(
'Deshabilitar Filtrado'
)
#accion habilitar filtrado
self.habilitarFiltradoAction = self.menu.addAction(
'Habilitar Filtrado'
)
self.habilitarFiltradoAction.setVisible(False)
#cambiar password
self.cambiarPasswordAction = self.menu.addAction(
'Cambiar password de administrador'
)
#recordar password
self.recordarPasswordAction = self.menu.addAction(
'Recordar password del administrador'
)
#accion salir
self.exitAction = self.menu.addAction(
'Salir')
#SIGNAL->SLOT
QObject.connect(
self.exitAction,
SIGNAL("triggered()"),
#lambda: sys.exit()
self.salir
)
# esta conexion es utilizada para refrezcar el icono en caso de
# que se desactive/active kerberus
QObject.connect(
self,
SIGNAL("update()"),
#lambda: sys.exit()
self.setIconStatus
)
QObject.connect(
self.menu, SIGNAL("clicked()"),
lambda: self.menu.popup(QCursor.pos())
)
QObject.connect(
self.deshabilitarFiltradoAction,
SIGNAL("triggered()"),
self.deshabilitarFiltradoWindow
)
QObject.connect(
self.habilitarFiltradoAction,
SIGNAL("triggered()"),
self.habilitarFiltradoWindow
)
QObject.connect(
self.cambiarPasswordAction,
SIGNAL("triggered()"),
self.cambiarPasswordWindow
)
QObject.connect(
self.configurarDominiosAction,
SIGNAL("triggered()"),
self.configurarDominios
)
QObject.connect(
self.recordarPasswordAction,
SIGNAL("triggered()"),
self.recordarPasswordWindow
)
#SystemTray
#self.tray = QSystemTrayIcon(QIcon(pixmap), self)
self.tray = QSystemTrayIcon(self.style.standardIcon(
QStyle.SP_DialogYesButton), self)
self.tray.setToolTip('Kerberus Control Parental - Activado')
self.tray.setContextMenu(self.menu)
self.tray.setVisible(True)
QObject.connect(
self.tray,
SIGNAL("messageClicked()"),
self.noMostrarMasMensaje
)
if self.mostrarMensaje:
self.tray.showMessage(
u'Kerberus Control Parental',
u'Filtro de Protección para menores de edad Activado',
2000
)
# Lanzo el thead que verifica si esta activo o no kerberus
self.t = threading.Thread(target=self.chequeosPeriodicos)
self.t.start()
def chequeosPeriodicos(self):
while self.chequeos_activos:
time.sleep(3)
status = self.checkKerberusStatus()
if status != self.ultimo_estado_kerberus:
self.ultimo_estado_kerberus = status
self.emit(SIGNAL('update()'))
def setIconStatus(self):
if self.ultimo_estado_kerberus:
self.habilitarFiltradoAction.setVisible(False)
self.deshabilitarFiltradoAction.setVisible(True)
self.tray.setIcon(self.style.standardIcon(
QStyle.SP_DialogYesButton))
self.tray.setToolTip('Kerberus Control Parental - Activado')
self.tray.showMessage(
u'Kerberus Control Parental',
u'Filtro de Protección para menores de edad Activado',
2000
)
else:
self.habilitarFiltradoAction.setVisible(True)
self.deshabilitarFiltradoAction.setVisible(False)
self.tray.setIcon(self.style.standardIcon(
QStyle.SP_DialogNoButton))
self.tray.setToolTip('Kerberus Control Parental - Inactivo')
self.tray.showMessage(
u'Kerberus Control Parental',
u'Filtro de Protección para menores de edad Desactivado',
2000
)
def salir(self):
self.chequeos_activos = False
sys.exit()
def configurarDominios(self):
admin = adminPanel()
admin.show()
def noMostrarMasMensaje(self):
try:
open('dontShowMessage', 'a').close()
except IOError:
print 'No se pudo crear el archivo dontShowMessage'
def deshabilitarFiltradoWindow(self):
url = 'http://%s:%s/!DeshabilitarFiltrado!' % ('inicio.kerberus.com.ar',
'80')
webbrowser.open(
url,
new=2
)
def checkKerberusStatus(self):
try:
url = 'http://%s:%s/' % (config.BIND_ADDRESS, config.BIND_PORT)
con = httplib.HTTPConnection(config.BIND_ADDRESS, config.BIND_PORT)
con.request(method='KERBERUSESTADO', url=url)
respuesta = con.getresponse().read()
return respuesta == 'Activo'
except:
return False
def habilitarFiltradoWindow(self):
url = "http://%s:%s/!HabilitarFiltrado!" % ('inicio.kerberus.com.ar',
'80')
webbrowser.open(
url,
new=2
)
def cambiarPasswordWindow(self):
url = "http://%s:%s/!CambiarPassword!" % ('inicio.kerberus.com.ar',
'80')
webbrowser.open(
url,
new=2
)
def recordarPasswordWindow(self):
url = "http://%s:%s/!RecordarPassword!" % ('inicio.kerberus.com.ar',
'80')
webbrowser.open(
url,
new=2
)
class KerberusSystray(QWidget):
def __init__(self):
QWidget.__init__(self)
icono = 'kerby-activo.ico'
pixmap = QPixmap(icono)
##setear el nombre de la ventana
self.setWindowTitle('Kerberus Control Parental')
#colocar el icono cargado a la ventana
self.setWindowIcon(QIcon(pixmap))
##creamos objeto Style para hacer uso de los iconos de Qt
self.style = self.style()
self.filtradoHabilitado = True
if not os.path.isfile('dontShowMessage'):
self.mostrarMensaje = True
self.noMostrarMasMensaje()
else:
self.mostrarMensaje = False
#Menu
self.menu = QMenu('Kerberus')
#accion deshabilitar filtrado
self.deshabilitarFiltradoAction = self.menu.addAction(
self.style.standardIcon(QStyle.SP_DialogNoButton),
'Deshabilitar Filtrado'
)
#accion habilitar filtrado
self.habilitarFiltradoAction = self.menu.addAction(
self.style.standardIcon(QStyle.SP_DialogYesButton),
'Habilitar Filtrado'
)
self.habilitarFiltradoAction.setVisible(False)
#cambiar password
self.cambiarPasswordAction = self.menu.addAction(
self.style.standardIcon(QStyle.SP_BrowserReload),
'Cambiar password de administrador'
)
#accion salir
self.exitAction = self.menu.addAction(
self.style.standardIcon(QStyle.SP_TitleBarCloseButton),
'Salir')
#SIGNAL->SLOT
QObject.connect(
self.exitAction,
SIGNAL("triggered()"),
lambda: sys.exit()
)
QObject.connect(
self.menu, SIGNAL("clicked()"),
lambda: self.menu.popup(QCursor.pos())
)
QObject.connect(
self.deshabilitarFiltradoAction,
SIGNAL("triggered()"),
self.deshabilitarFiltradoWindow
)
QObject.connect(
self.habilitarFiltradoAction,
SIGNAL("triggered()"),
self.habilitarFiltradoWindow
)
QObject.connect(
self.cambiarPasswordAction,
SIGNAL("triggered()"),
self.cambiarPasswordWindow
)
#SystemTray
#self.tray = QSystemTrayIcon(QIcon(pixmap), self)
self.tray = QSystemTrayIcon(self.style.standardIcon(QStyle.SP_DialogYesButton), self)
self.tray.setToolTip('Kerberus Control Parental - Activado')
self.tray.setContextMenu(self.menu)
self.tray.setVisible(True)
QObject.connect(
self.tray,
SIGNAL("messageClicked()"),
self.noMostrarMasMensaje
)
if self.mostrarMensaje:
self.tray.showMessage(
u'Kerberus Control Parental',
u'Filtro de Protección para menores de edad Activado',
2000
)
#def closeEvent(self, event):
#event.ignore()
#self.hide()
def noMostrarMasMensaje(self):
try:
open('dontShowMessage','a').close()
except IOError:
print 'No se pudo crear el archivo dontShowMessage'
def deshabilitarFiltradoWindow(self):
webbrowser.open(
'http://inicio.kerberus.com.ar/!DeshabilitarFiltrado!',
new=2
)
self.habilitarFiltradoAction.setVisible(True)
self.deshabilitarFiltradoAction.setVisible(False)
self.tray.setIcon(self.style.standardIcon(QStyle.SP_DialogNoButton))
self.tray.setToolTip('Kerberus Control Parental')
def habilitarFiltradoWindow(self):
webbrowser.open(
'http://inicio.kerberus.com.ar/!HabilitarFiltrado!',
new=2
)
self.habilitarFiltradoAction.setVisible(False)
self.deshabilitarFiltradoAction.setVisible(True)
self.tray.setIcon(self.style.standardIcon(QStyle.SP_DialogYesButton))
self.tray.setToolTip('Kerberus Control Parental - Activado')
def cambiarPasswordWindow(self):
webbrowser.open(
'http://inicio.kerberus.com.ar/!CambiarPassword!',
new=2
)
class TrayController():
"""Display and control context menu."""
setings_win = None
def __init__(self):
"""Create TrayController."""
self._tray_ico = QSystemTrayIcon()
def set_menu(self, quit_callable, app_icon):
"""Show tray icon and sets its context menu items.
:param quit_callable: function to call when user choose Exit menu item
:type quit_callable: function
:param app_icon: QIcon object - tray icon image
:type app_icon: QIcon
"""
tray_menu = QMenu()
self._delay_menu = tray_menu.addAction(
QIcon(
os.path.join(PROGRAMM_RESOURCE_PATH, 'k-timer-icon.png')
),
QtCore.QCoreApplication.translate('TrayController', 'Delay')
)
delay_sub_menu = QMenu()
delay_sub_menu.addAction(
QtCore.QCoreApplication.translate('TrayController', '15 minutes'),
self.action_delay15
)
delay_sub_menu.addAction(
QtCore.QCoreApplication.translate('TrayController', '30 minutes'),
self.action_delay30
)
delay_sub_menu.addAction(
QtCore.QCoreApplication.translate('TrayController', '1 hour'),
self.action_delay60
)
delay_sub_menu.addAction(
QtCore.QCoreApplication.translate('TrayController', '2 hours'),
self.action_delay120
)
self._delay_menu.setMenu(delay_sub_menu)
self._resume_menu = tray_menu.addAction(
QIcon(
os.path.join(PROGRAMM_RESOURCE_PATH,
'App-Quick-restart-icon.png')
),
QtCore.QCoreApplication.translate('TrayController', 'Resume'),
self.action_resume
)
self._resume_menu.setVisible(False)
tray_menu.addAction(
QIcon(
os.path.join(PROGRAMM_RESOURCE_PATH, 'Settings-icon.png')
),
QtCore.QCoreApplication.translate('TrayController', 'Settings'),
self.show_settings
)
tray_menu.addSeparator()
tray_menu.addAction(
QIcon(
os.path.join(PROGRAMM_RESOURCE_PATH, 'delete-icon.png')
),
QtCore.QCoreApplication.translate('TrayController', 'Exit'),
quit_callable
)
self._tray_ico.setContextMenu(tray_menu)
self._tray_ico.setToolTip(PROGRAM_NAME)
self._tray_ico.setIcon(app_icon)
self._tray_ico.show()
self.setings_win = SettingsManager(self, app_icon)
def show_message(self, message):
"""Show message near tray icon.
(alternative to show message is via module
from PyQt4.QtGui import QMessageBox)
:param message: message string
:type message: str
"""
self._tray_ico.showMessage(
PROGRAM_NAME, message,
msecs=5000
)
# Functions - menu click actions
def toggle_delay_menu(self):
"""Toggle some context menu items.
(depending program delay is on or off)
"""
delay_on = self.setings_win.main_timer.delay_on
self._resume_menu.setVisible(delay_on)
self._delay_menu.setVisible(not delay_on)
self.setings_win.ui.notActiveLb.setText(
QtCore.QCoreApplication.translate('TrayController', 'Delay time')
if delay_on else
QtCore.QCoreApplication.translate(
'TrayController', 'Time not active'
)
)
def action_delay15(self):
"""User choose to delay program on 15 minutes."""
self.setings_win.main_timer.set_work_delay(15)
def action_delay30(self):
"""User choose to delay program on 30 minutes."""
self.setings_win.main_timer.set_work_delay(30)
def action_delay60(self):
"""User choose to delay program on 1 hour."""
self.setings_win.main_timer.set_work_delay(60)
def action_delay120(self):
"""User choose to delay program on 2 hours."""
self.setings_win.main_timer.set_work_delay(120)
def action_resume(self):
"""User cancel delay."""
self.setings_win.main_timer.delay_on = False
self.toggle_delay_menu()
def show_settings(self):
"""Show settings window."""
self.setings_win.show()
def select():
"""select folder"""
fileDialog = QFileDialog(d)
fileDialog.setWindowTitle('Select Folder')
folderPath = fileDialog.getExistingDirectory()
#print folderPath
fts.append('%s' % folderPath)
confManager.setValue('common', 'folders', fts)
confManager.save()
ui.connBtn.connect(ui.connBtn, SIGNAL('clicked()'),
lambda: connect(ui.connBtn))
ui.addFolderBtn.clicked.connect(select)
menu = QMenu(m)
es = menu.addAction('ShowConfig')
menu.connect(es, SIGNAL('triggered()'), d, SLOT('show()'))
menu.addSeparator()
ea = menu.addAction("&Exit")
menu.connect(ea, SIGNAL('triggered()'), app, SLOT('quit()'))
t.setContextMenu(menu)
t.show()
t.showMessage('UniFileSyncPop Message', 'This is UniFileSyncUI!!')
sys.exit(app.exec_())
class Main(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.ui = uic.loadUiType('main.ui')[0]()
self.ui.setupUi(self)
self.localize()
self.ui.config.setup(self.ui.terminals, self.ui.payments)
self.tabs = [self.ui.terminals, self.ui.payments, self.ui.config]
self.ui.terminals.ready.connect(self.ui.config.terminals_ready)
self.left_terminals = []
self.right_terminals = []
self.ui.leftUp.clicked.connect(self.left_up)
self.ui.leftDown.clicked.connect(self.left_down)
self.ui.rightUp.clicked.connect(self.right_up)
self.ui.rightDown.clicked.connect(self.right_down)
self.end_session()
self.notifier = QSystemTrayIcon(QIcon('arrow-up-icon.png'), self)
self.notifier.show()
self.session = None
self.executor = self.setup_executor()
self.executor.start()
#self.setWindowFlags(Qt.CustomizeWindowHint)
def localize(self):
self.setWindowTitle(_('Stop-Park'))
self.ui.tabs.setTabText(0, _('Terminals'))
self.ui.tabs.setTabText(1, _('Payments'))
self.ui.tabs.setTabText(2, _('Config'))
def setup_payments(self, executor):
self.ui.payments.tariff_update_requested.connect(executor.update_tariffs)
executor.tariffs_updated.connect(self.ui.payments.update_tariffs)
executor.new_payable.connect(self.ui.payments.handle_payable)
self.ui.payments.payable_accepted.connect(lambda: self.ui.tabs.setCurrentIndex(1))
self.ui.payments.display_requested.connect(executor.display)
self.ui.payments.manual_ticket_inputted.connect(executor.handle_bar)
self.ui.payments.notify_requested.connect(self.notifier.showMessage)
self.ui.payments.payment_initiated.connect(executor.pay)
executor.payment_processed.connect(self.ui.payments.handle_payment_processed)
def setup_executor(self):
executor = Executor()
executor.notify.connect(lambda title, msg: self.notifier.showMessage(title, msg))
self.setup_payments(executor)
executor.new_operator.connect(self.handle_operator)
executor.session_begin.connect(self.begin_session)
executor.session_end.connect(self.end_session)
executor.option_notification.connect(self.ui.config.set_option)
self.ui.config.option_changed.connect(executor.set_option)
self.ui.config.terminals_changed.connect(executor.notify_terminals)
self.ui.config.terminals_update_requested.connect(executor.update_terminals)
executor.terminals_notification.connect(self.update_terminals)
return executor
@staticmethod
def disconnect_from_signal(signal, slot):
try:
signal.disconnect(slot)
return True
except TypeError: # .disconnect raises TypeError when given signal is not connected
return False
def handle_operator(self, card):
print 'operator', card
if not self.disconnect_from_signal(self.executor.new_operator, self.handle_operator):
return
if self.session is None:
login_dialog = LoginDialog(card, parent=self)
if login_dialog.exec_() == QDialog.Accepted:
self.executor.begin_session(card)
elif self.session == card.sn or card.type == Card.ADMIN:
login_dialog = LogoffDialog(card, self.executor)
if login_dialog.exec_() == QDialog.Accepted:
self.executor.end_session()
self.executor.new_operator.connect(self.handle_operator)
def begin_session(self, sn, fio, access):
self.session = sn
for tab_index, tab_widget in enumerate(self.tabs):
self.ui.tabs.setTabEnabled(tab_index, tab_widget.begin_session(fio, access))
if access in ['admin', 'operator']:
self.executor.notify_terminals()
else:
self.update_buttons()
def end_session(self):
self.session = None
for tab_index, tab_widget in enumerate(self.tabs):
if tab_widget.end_session():
self.ui.tabs.setTabEnabled(tab_index, False)
else:
self.ui.tabs.setCurrentIndex(tab_index)
self.update_terminals()
def update_terminals(self, terminals=None):
if terminals is None:
terminals = {}
else:
self.ui.terminals.stop_mainloop()
self.left_terminals = [key for key, value in terminals.iteritems() if value[1] == 'left']
print self.left_terminals
self.ui.leftUp.setEnabled(not not self.left_terminals)
self.ui.leftDown.setEnabled(not not self.left_terminals)
self.right_terminals = [key for key, value in terminals.iteritems() if value[1] == 'right']
print self.right_terminals
self.ui.rightUp.setEnabled(not not self.right_terminals)
self.ui.rightDown.setEnabled(not not self.right_terminals)
def left_up(self):
for addr in self.left_terminals:
self.ui.terminals.terminal_open(addr)
def left_down(self):
for addr in self.left_terminals:
self.ui.terminals.terminal_close(addr)
def right_up(self):
for addr in self.right_terminals:
self.ui.terminals.terminal_open(addr)
def right_down(self):
for addr in self.right_terminals:
self.ui.terminals.terminal_close(addr)
#noinspection PyPep8Naming
def closeEvent(self, event):
self.ui.terminals.end_session(block=True)
self.executor.stop()
return QWidget.closeEvent(self, event)
class Tray(QObject):
activated = pyqtSignal()
def __init__(self, parent, title, icon):
QObject.__init__(self)
# Setup contextual menu
if kde:
self.menu = KMenu(parent)
self.tray = KStatusNotifierItem(parent)
self.tray.setStatus(KStatusNotifierItem.Passive)
self.tray.setCategory(KStatusNotifierItem.ApplicationStatus)
self.tray.setAssociatedWidget(parent)
self.tray.setStandardActionsEnabled(False)
self.tray.activateRequested.connect(self._activateRequested)
else:
self.menu = QMenu()
self.tray = QSystemTrayIcon()
self.tray.activated.connect(self._activated)
self.setIcon(icon)
self.setTitle(title)
if not kde:
self.tray.show()
self.tray.setContextMenu(self.menu)
def setActive(self, active=True):
if kde:
self.tray.setStatus(KStatusNotifierItem.Active
if active else KStatusNotifierItem.Passive)
def setTitle(self, title):
if kde:
self.tray.setTitle(title)
self.tray.setToolTipTitle(title)
else:
self.tray.setToolTip(title)
self.menu.setTitle(title)
def setToolTipSubTitle(self, subtitle):
if kde:
self.tray.setToolTipSubTitle(subtitle)
def setIcon(self, icon):
if kde:
self.tray.setIconByPixmap(icon)
self.tray.setToolTipIconByPixmap(icon)
else:
self.tray.setIcon(icon)
def showMessage(self, title, message, icon=None):
if kde:
self.tray.showMessage(title, message, "network-server")
else:
self.tray.showMessage(
title, message,
QSystemTrayIcon.Information if icon is None else icon)
def _activated(self, reason):
if reason == QSystemTrayIcon.DoubleClick:
self.activated.emit()
def _activateRequested(self, active, pos):
self.activated.emit()
def select():
"""select folder"""
fileDialog = QFileDialog(d)
fileDialog.setWindowTitle("Select Folder")
folderPath = fileDialog.getExistingDirectory()
# print folderPath
fts.append("%s" % folderPath)
confManager.setValue("common", "folders", fts)
confManager.save()
ui.connBtn.connect(ui.connBtn, SIGNAL("clicked()"), lambda: connect(ui.connBtn))
ui.addFolderBtn.clicked.connect(select)
menu = QMenu(m)
es = menu.addAction("ShowConfig")
menu.connect(es, SIGNAL("triggered()"), d, SLOT("show()"))
menu.addSeparator()
ea = menu.addAction("&Exit")
menu.connect(ea, SIGNAL("triggered()"), app, SLOT("quit()"))
t.setContextMenu(menu)
t.show()
t.showMessage("UniFileSyncPop Message", "This is UniFileSyncUI!!")
sys.exit(app.exec_())
class UniFileSyncUI(QMainWindow):
"""UniFileSyncUI class"""
def __init__(self, name=None):
super(UniFileSyncUI, self).__init__()
self.ui = Ui_UniFileSyncPop()
self.ui.setupUi(self)
self.setFixedSize(self.size())
self.server = UServer('UServer')
self.server.regSelfToBus()
if name:
self.setName(name)
self.createActions()
self.createTrayIcon()
self.createStatusBar()
qApp.setQuitOnLastWindowClosed(False)
#connect the signal with slot
self.connectUISlots(self.ui)
#set UI label
username = ConfManager.getManager().getValue('UI', 'username')
self.ui.nameLabel.setText(username)
#Start server immediately
self.server.start()
#self.server.getHandler('start')({'name': 'all'})
msg = self.server.initMsg('start', None, MSG_UNIQUE_ID_T_CONTROLLER,
False, {'name': 'all'})
UMsgBus.getBus().send(msg)
self.server.addCallBack(self.statusupdate)
self.server.addCallBack(self.cloudinfoupdate)
#setup list
self.setupFolderList(self.ui.folderList)
self.setupPluginList(self.ui.pluginList)
self.setupNetworkConf()
#Init status bar
stBarConf = ConfManager.getManager().getValue('UI', 'statusbar')
self.statusbar.showMessage(stBarConf['messages']['init'])
#Init system icon
self.trayIcon.show()
self.showTrayIconMessage()
def setupNetworkConf(self):
"""setup network configuration into UI"""
conf = ConfManager.getManager().getValue('common', 'network')
self.ui.proxyLineEdit.setText(conf['proxy'])
self.ui.portLineEdit.setText("%s" % conf['port'])
def closeEvent(self, event):
"""override close event"""
if self.trayIcon.isVisible():
self.hide()
event.ignore()
ConfManager.getManager().save()
logging.debug('[%s] is closed, window is hide, configuration is saved',
self.getName())
def createActions(self):
"""create tray icon menu action"""
self.configAction = QAction("&ShowConfig", self, triggered=self.show)
self.exitAction = QAction("&Exit", self)
self.exitAction.triggered.connect(lambda: UMsgBus.getBus().send(
self.server.initMsg('stop', None, MSG_UNIQUE_ID_T_CONTROLLER,
False, {'name': 'all'})))
self.exitAction.triggered.connect(qApp.quit)
def createTrayIcon(self):
"""create system tray icon"""
self.trayIconMenu = QMenu(self)
es = self.trayIconMenu.addAction(self.configAction)
self.trayIconMenu.addSeparator()
ea = self.trayIconMenu.addAction(self.exitAction)
self.trayIcon = QSystemTrayIcon(self)
self.trayIcon.setContextMenu(self.trayIconMenu)
self.trayIcon.setIcon(QIcon('icon/tray.png'))
def showTrayIconMessage(self):
"""show tray icon message"""
conf = ConfManager.getManager().getValue('UI', 'trayicon')
popup = conf['popup']
self.trayIcon.showMessage(popup['title'], popup['message'])
def setupFolderList(self, folderList):
"""setup folder list for showing"""
fts = ConfManager.getManager().getValue('common', 'folders')
i = 0
for ft in fts:
flistItem = QListWidgetItem(QIcon('icon/folder.png'), ft,
folderList)
folderList.insertItem(i, flistItem)
i += 1
def setupPluginList(self, pluginList):
"""setup plugin list from configuration file"""
fts = ConfManager.getManager().getValue('common', 'plugins')
i = 0
for ft in fts:
flistItem = QListWidgetItem(QIcon('icon/plugin.png'), ft['name'],
pluginList)
pluginList.insertItem(i, flistItem)
i += 1
def show(self):
"""ovrride parent show method"""
super(UniFileSyncUI, self).show()
#Init status bar
stBarConf = ConfManager.getManager().getValue('UI', 'statusbar')
self.statusbar.showMessage(stBarConf['messages']['init'])
#set UI label
username = ConfManager.getManager().getValue('UI', 'username')
self.ui.nameLabel.setText(username)
def connectUISlots(self, ui):
"""connect ui component with slots"""
ui.connBtn.clicked.connect(lambda: self.connBtnSlots(ui.connBtn))
ui.addFolderBtn.clicked.connect(
lambda: self.connBtnSlots(ui.addFolderBtn))
ui.rmFolderBtn.clicked.connect(
lambda: self.connBtnSlots(ui.rmFolderBtn))
ui.saveBtn.clicked.connect(lambda: self.connBtnSlots(ui.saveBtn))
ui.unloadBtn.clicked.connect(lambda: self.connBtnSlots(ui.unloadBtn))
ui.reloadBtn.clicked.connect(lambda: self.connBtnSlots(ui.reloadBtn))
ui.resetBtn.clicked.connect(lambda: self.connBtnSlots(ui.resetBtn))
ui.addPluginBtn.clicked.connect(
lambda: self.connBtnSlots(ui.addPluginBtn))
ui.syncFolderBtn.clicked.connect(
lambda: self.connBtnSlots(ui.syncFolderBtn))
self.connect(self, SIGNAL('statusupdate'), self.statusbarUpdate)
self.connect(self, SIGNAL('cloudinfoupdate'), self.infoLabelUpdate)
def connBtnSlots(self, btn):
"""docstring for connBtnSlots"""
if btn is self.ui.connBtn:
if btn.text() == 'Connect':
msg = self.server.initMsg('info', None,
MSG_UNIQUE_ID_T_CONTROLLER, True,
{'name': 'all'})
UMsgBus.getBus().send(msg)
#res, data = self.server.getHandler('info')({'name': 'all'})
btn.setText('Connecting')
#self.ui.infoLabel.setText(data)
logging.debug('[%s]: Press Connect to getCloudInfo',
self.getName())
elif btn.text() == 'Disconnect':
#self.server.getHandler('stop')({'name': 'all'})
btn.setText('Connect')
self.ui.infoLabel.setText('Cloud Disk is disconnected')
elif btn is self.ui.addFolderBtn:
fileDialog = QFileDialog(self)
fileDialog.setWindowTitle('Select Folder')
folderPath = fileDialog.getExistingDirectory()
if folderPath != "":
listItem = QListWidgetItem(QIcon('icon/folder.png'),
folderPath, self.ui.folderList)
pyStr = '%s' % folderPath
logging.debug('[%s]: add folder path %s', self.getName(),
pyStr)
self.ui.folderList.insertItem(self.ui.folderList.count(),
listItem)
folderList = ConfManager.getManager().getValue(
'common', 'folders')
folderList.append(pyStr)
ConfManager.getManager().setValue('common', 'folders',
folderList)
#send watch dir request
msg = self.server.initMsg('watch', None,
MSG_UNIQUE_ID_T_CONTROLLER, True, {
'path': pyStr,
'action': 'add'
})
UMsgBus.getBus().send(msg)
self.statusbar.showMessage('Adding watch path %s' % folderPath)
elif btn is self.ui.rmFolderBtn:
row = self.ui.folderList.currentRow()
item = self.ui.folderList.currentItem()
folderList = ConfManager.getManager().getValue('common', 'folders')
self.statusbar.showMessage('Removing watch path %s' % item.text())
pyStr = '%s' % item.text()
folderList.remove(pyStr)
ConfManager.getManager().setValue('common', 'folders', folderList)
logging.debug('[%s]: remove item %d %s', self.getName(), row,
item.text())
msg = self.server.initMsg('watch', None,
MSG_UNIQUE_ID_T_CONTROLLER, True, {
'path': pyStr,
'action': 'rm'
})
UMsgBus.getBus().send(msg)
self.ui.folderList.takeItem(row)
elif btn is self.ui.saveBtn:
proxyConf = ConfManager.getManager().getValue('common', 'network')
server = str(self.ui.proxyLineEdit.text())
if server != "" and server != None:
user = str(self.ui.proxyNameLineEdit.text())
password = str(self.ui.proxyPwdLineEdit.text())
logging.debug(
'[%s]: save server=>%s user=>%s password=>%s into configuration',
self.getName(), server, user, password)
proxyConf['proxy'] = server
proxyConf['user'] = user
proxyConf['password'] = password
ConfManager.getManager().setValue('common', 'network',
proxyConf)
msg = self.server.initMsg('proxy', None,
MSG_UNIQUE_ID_T_CONTROLLER, True, {
'http': 'http://%s' % server,
'https': 'https://%s' % server
})
UMsgBus.getBus().send(msg)
self.statusbar.showMessage('Applying proxy %s' % server)
ConfManager.getManager().save()
elif btn is self.ui.resetBtn:
proxyConf = ConfManager.getManager().getValue('common', 'network')
server = proxyConf['proxy']
user = proxyConf['user']
password = proxyConf['password']
port = proxyConf['port']
self.ui.proxyLineEdit.setText(server)
self.ui.proxyNameLineEdit.setText(user)
self.ui.proxyPwdLineEdit.setText(password)
self.ui.portLineEdit.setText(str(port))
self.ui.serverEnableCheckBox.setCheckState(0)
elif btn is self.ui.unloadBtn:
row = self.ui.pluginList.currentRow()
it = str(self.ui.pluginList.currentItem().text())
logging.debug('[%s]: unload plugin name %s', self.getName(), it)
self.statusbar.showMessage('Unloading plugin %s' % it)
PluginManager.getManager().unload(it)
self.ui.pluginList.takeItem(row)
conf = ConfManager.getManager().getValue('common', 'plugins')
for pc in conf:
if pc['name'] == it:
conf.remove(pc)
ConfManager.getManager().setValue('common', 'plugins', conf)
elif btn is self.ui.reloadBtn:
row = self.ui.pluginList.currentRow()
it = str(self.ui.pluginList.currentItem().text())
logging.debug('[%s]: reload plugin name %s', self.getName(), it)
self.statusbar.showMessage('Reloading plugin %s' % it)
PluginManager.getManager().reload(it)
elif btn is self.ui.addPluginBtn:
path = QFileDialog.getOpenFileName(self)
PluginManager.getManager().loadPluginFromPath(str(path))
elif btn is self.ui.syncFolderBtn:
folder = str(self.ui.folderList.currentItem().text())
msg = self.server.initMsg('sync', None, MSG_UNIQUE_ID_T_CONTROLLER,
True, {
'path': str(folderPath),
'action': 'add'
})
UMsgBus.getBus().send(msg)
self.statusbar.showMessage('Sync %s with cloud' % folder)
def createStatusBar(self):
"""create status bar"""
self.statusbar = QStatusBar(self)
self.setStatusBar(self.statusbar)
def setName(self, name):
"""set server name"""
self.name = name
def getName(self):
"""get server name"""
return self.name
def statusupdate(self, param):
"""call back for status update"""
self.emit(SIGNAL('statusupdate'), param['result'])
def statusbarUpdate(self, res):
"""statusbar update callback"""
self.statusbar.showMessage(ERR_STR_TABLE[res])
def cloudinfoupdate(self, param):
"""cloud infor update callback"""
self.emit(SIGNAL('cloudinfoupdate'), param['data'])
def infoLabelUpdate(self, res):
"""infoLabelUpdate"""
if res:
self.ui.infoLabel.setText(res)
self.ui.connBtn.setText('Disconnect')
class PigeonFeather(QMainWindow):
"""Main class for the application, inherits class genrated from pyuic"""
def __init__(self, parent=None):
super(PigeonFeather, self).__init__(parent)
# Check that environment supports systemtray
if not QSystemTrayIcon.isSystemTrayAvailable():
print('FATAL: There is no system tray')
sys.exit(1)
# Make sure that we can load an icon list
try:
with open('code2iconlist.pkl', 'rb') as iconList:
self.codeToIconList = pickle.load(iconList)
except (IOError, pickle.PickleError):
print('FATAL: Could not not load code2iconlist')
sys.exit(1)
# See if balloon messages are supported
#print('Desktop support balloon messages = ' + \
# str(QSystemTrayIcon.supportsMessages()))
# Set the user config fle
self.USER_CONFIG = os.path.expanduser('~/.pigeonfeather')
# Load preferences
self.loadConfig()
# Class properties
self.trayIcon = QSystemTrayIcon(self)
# Weather Dialog and Configure Dialog
self.weatherDialog = WeatherDialog(self)
self.configureDialog = ConfigureDialog(self)
# Set up the application
self.setup()
def setup(self):
"""Setup and start the application"""
# Connect some slots
# Icon is clicked
self.connect(self.trayIcon, \
SIGNAL('activated(QSystemTrayIcon::ActivationReason)'), \
self.trayIconClicked)
# Connnect slot emitted from CnfigureDialog to update preferences
self.connect(self.configureDialog, SIGNAL('ConfigureDialogOk'), \
self.saveConfig)
# Set an initial icon for tray and weather dialog
self.setTrayIcon(QIcon('images/22/dunno.png'))
self.weatherDialog.labelIcon.setPixmap(QPixmap('images/64/dunno.png'))
# Set the menu
self.trayIcon.setContextMenu(self.createMenu())
# Setup the config dialog with values loaded from config
woeid = self.config.get('main', 'woeid')
# If woeid is not valid set a default and use that
try:
self.configureDialog.setWoeid(woeid)
except ValueError as ve:
self.config.set('main', 'woeid', '2408842')
self.configureDialog.setWoeid('2408842')
# Set temperature units
if self.config.get('units', 'temperature') == 'fahrenheit':
self.configureDialog.setTemperature('fahrenheit')
else:
self.configureDialog.setTemperature('celcius')
# Set distance units
if self.config.get('units', 'distance') == 'km':
self.configureDialog.setDistance('km')
else:
self.configureDialog.setDistance('mi')
# Set wind units
if self.config.get('units', 'wind') == 'kph':
self.configureDialog.setWind('kph')
else:
self.configureDialog.setWind('mph')
# Set pressure units
if self.config.get('units', 'pressure') == 'mb':
self.configureDialog.setPressure('mb')
else:
self.configureDialog.setPressure('in')
# Start getWeather thread with Id from config
# Connect two slots for the two signals emitted from thread
self.getWeatherThread = GetWeatherQThread(self.config.get( \
'main', 'woeid'))
self.getWeatherThread.start()
self.connect(self.getWeatherThread, SIGNAL('WeatherUpdate'), \
self.processWeather)
self.connect(self.getWeatherThread, SIGNAL('WeatherReadError'), \
self.showErrorMessage)
def loadConfig(self):
"""Load preferences from defaults then self.USER_CONFIG if exists"""
# Load a default set first
defaultConfig = io.StringIO("""\
[main]
Woeid=2408842
[units]
temperature=celcius
wind=mph
pressure=mb
distance=mi
""")
self.config = ConfigParser()
# Load defaults
self.config.readfp(defaultConfig)
# Load config if it exists
self.config.read(self.USER_CONFIG)
def createMenu(self):
"""Create and return the applications menu"""
menu = QMenu(self)
menu.addAction(QIcon('images/22/sunny.png'), '&Show Weather Report', \
self.showWeatherDialog)
menu.addAction(QIcon('images/22/configure.png'), '&Configure', \
self.showConfigureDialog)
menu.addAction(QIcon('images/22/help.png'), '&About', \
self.showAboutDialog)
menu.addAction(QIcon('images/22/exit.png'), '&Exit', self.quitApp)
return menu
def saveConfig(self, config):
"""Save the recieved config back to the config file and update the
local copy in the object
Keyword arguments:
config -- A dict. of config recieved from the configuration dialog
"""
# Set the local config object and try and save it
self.config.set('main', 'woeid', config['woeid'])
self.config.set('units', 'temperature', config['temperature'])
self.config.set('units', 'wind', config['wind'])
self.config.set('units', 'pressure', config['pressure'])
self.config.set('units', 'distance', config['distance'])
# Update the Weoid in the get weather thread
self.getWeatherThread.setWoeid(config['woeid'])
# Try and save the config
try:
with open(self.USER_CONFIG, 'wb') as configfile:
self.config.write(configfile)
except IOError as ioe:
self.showErrorMessage('Could not save configuration settings' + \
'to disk')
def showErrorMessage(self, message):
"""Show a error as a tray balloon message
Keyword arguments:
message -- Error message to display
"""
self.trayIcon.showMessage('Application Error', message, \
QSystemTrayIcon.Critical)
def trayIconClicked(self, reason):
"""If the tray icon is left clicked, show/hide the weather dialog
If this is called on a Darwin(mac) machine do not pop up. This follows
better mac convention
Keyword arguments:
reason -- A QSystemTrayIcon.ActivationReason enum
"""
# If mac then ignore click
if platform.system() == 'Darwin':
return
# Test for left click
if reason == 3:
if self.weatherDialog.isVisible():
self.weatherDialog.hide()
else:
self.weatherDialog.show()
def showWeatherDialog(self):
"""Show the weather report dialog"""
self.weatherDialog.show()
def showConfigureDialog(self):
"""Show the configure dialog"""
self.configureDialog.show()
def showAboutDialog(self):
"""Show the about pyqtweather dialog"""
QMessageBox.about(None, 'About Pigeon Feather', 'Pigeon Feather\n \
(c) 2010 Ben Sampson\nPigeon Feather uses the Yahoo! Weather API\n\
License: GNU General Public License Version 3')
def processWeather(self, weather):
"""Slot that is called by the weather thread, responsible for updating
the GUI with the new weather data, this includes the trayicon and
tooltip and the weather report dialog
Keyword arguments:
weather -- map of weather data
"""
# TODO These should really call setter methods on weather dialog
# Copy weather to local vars basd on preferences
fetched = weather['fetched']
code = weather['code']
if self.config.get('units', 'temperature') == 'celcius':
temp = weather['tempC']
chill = weather['chillC']
tempUnit = 'C'
else:
temp = weather['tempF']
chill = weather['chillF']
tempUnit = 'F'
text = weather['text']
city = weather['city']
region = weather['region']
country = weather['country']
sunrise = weather['sunrise']
sunset = weather['sunset']
if self.config.get('units', 'wind') == 'mph':
windSpeed = weather['windSpeedMph']
speedUnit = 'mph'
else:
windSpeed = weather['windSpeedKph']
speedUnit = 'kph'
if self.config.get('units', 'pressure') == 'mb':
pressure = weather['pressureMb']
pressureUnit = 'mb'
else:
pressure = weather['pressureIn']
pressureUnit = 'in'
directionTextual = weather['directionTextual']
pressureTendancy = weather['pressureTendancy']
humidity = weather['humidity']
if self.config.get('units', 'distance') == 'mi':
visibility = weather['visibilityMi']
distanceUnit = 'mi'
else:
visibility = weather['visibilityKm']
distanceUnit = 'km'
# Get the filename for the icon to disply from the icon list map
# Generate the system tray icon and set it
iconFileName = self.codeToIconList[int(code)][1]
icon = self.createWeatherIcon('images/22/' + iconFileName, str(temp))
self.setTrayIcon(icon)
# Set the tool tip
tempString = str(temp) + '°' + tempUnit + ' ' + text
self.trayIcon.setToolTip(tempString)
# Update the weather report dialog
self.weatherDialog.labelLastUpdate.setText( \
fetched.strftime('%H:%M:%S'))
self.weatherDialog.setWindowTitle('Weather report for ' + city + \
', ' + region + ' ' + country)
self.weatherDialog.labelTemp.setText(tempString)
self.weatherDialog.labelSunrise.setText(sunrise)
self.weatherDialog.labelSunset.setText(sunset)
self.weatherDialog.labelWindChill.setText(str(chill) + \
'°' + tempUnit)
self.weatherDialog.labelWindSpeed.setText(str(windSpeed) + ' ' + \
speedUnit)
self.weatherDialog.labelWindDirection.setText(directionTextual)
self.weatherDialog.labelHumidity.setText(str(humidity) + '%')
self.weatherDialog.labelVisibility.setText(str(visibility) + ' ' + \
distanceUnit)
self.weatherDialog.labelPressure.setText(str(pressure) + ' ' + \
pressureUnit)
self.weatherDialog.labelRising.setText(pressureTendancy)
# Set the image
self.weatherDialog.labelIcon.setPixmap(QPixmap('images/64/' + \
iconFileName))
# TODO - this should really be in another class
def createWeatherIcon(self, iconFileName, temp):
"""Create the icon to display in the tray"""
# Create a map of what image to use based on code
# Start by creating a transparent image to paint on
print(('Using' + iconFileName))
icon = QPixmap(22, 22)
icon.fill(Qt.transparent)
# Create a painter to paint on to the icon and draw on the text
painter = QPainter(icon)
painter.setOpacity(0.5)
# Draw text of temperature
font = QFont('Times', 10, QFont.Black)
painter.setFont(font)
painter.setPen(QColor('red'))
painter.drawPixmap(QPoint(0, 0), QPixmap(iconFileName))
painter.setOpacity(1)
painter.drawText(5, 15, temp)
painter.end()
# Return the icon
return QIcon(icon)
def setTrayIcon(self, icon):
"""Set the tray icon"""
self.trayIcon.setIcon(icon)
self.trayIcon.show()
def quitApp(self):
"""Exit the application"""
sys.exit(0)
class Application(QApplication):
def __init__(self, *args, **kwargs):
super(Application, self).__init__(*args, **kwargs)
self.application_path = dirname(__file__)
self.settings = Settings()
if Settings.config().debug:
basicConfig(level=DEBUG)
self.setQuitOnLastWindowClosed(Settings.config().debug)
self.history = History(
tray_notify=self.tray_notify
)
self.aboutToQuit.connect(self.settings.settings_save)
self.create_actions()
self.create_tray_icon()
def create_actions(self):
self.action_take_screenshot = QAction(
'Take a screenshot',
self,
triggered=self.take_screenshot
)
self.action_quit = QAction(
'Quit',
self,
triggered=qApp.quit
)
def create_tray_icon(self):
self.menu_tray = QMenu()
self.menu_tray.addAction(self.action_take_screenshot)
self.menu_tray.addSeparator()
self.menu_tray.addAction(self.action_quit)
self.icon_tray = QSystemTrayIcon(
QIcon(join(
self.application_path,
'icons/camera.png'
))
)
self.icon_tray.setContextMenu(self.menu_tray)
self.icon_tray.activated.connect(self.tray_icon_activated)
self.icon_tray.show()
def tray_icon_activated(self, reason):
if reason != QSystemTrayIcon.Trigger:
return
self.take_screenshot()
def take_screenshot(self):
self.selecter = SelectArea(
doneSignal=self.history.start_new_upload
)
def tray_notify(self, message):
self.icon_tray.showMessage(
'Screenshot',
message,
QSystemTrayIcon.Information,
3000
)
class SingleApplication(QApplication):
def __init__(self, *args):
QApplication.__init__(self, *args)
self._memory = QSharedMemory(self)
self._memory.setKey("d2mp")
if self._memory.attach():
self._running = True
else:
self._running = False
if not self._memory.create(1):
raise RuntimeError(self._memory.errorString().toLocal8Bit().data())
def is_running(self):
return self._running
def exec_(self):
self._create_tray_icon()
self._create_mod_manager()
self._start_file_watcher()
self._create_socket()
Settings()
return super(SingleApplication, self).exec_()
def _create_mod_manager(self):
self.manager = ModManager()
self.manager.mod_game_info()
self.manager.signals.message.connect(self.show_message_from_mod_manager)
self.manager.signals.error.connect(self.show_error_from_mod_manager)
def _create_socket(self):
self.socket = ConnectionManager()
self.manager.signals.contact_server.connect(self.socket.send)
self.socket.message.connect(self.show_message_from_socket)
self.socket.error.connect(self.show_error_from_socket)
@property
def _watcher_file_name(self):
return "d2mp.pid"
def _start_file_watcher(self):
self.watcher = QFileSystemWatcher()
self.watcher_file_path = join(abspath("."), self._watcher_file_name)
log.DEBUG("creating watcher file: %s" %(self.watcher_file_path))
write_to_file(self.watcher_file_path, "Delete this file to shutdown D2MP\n")
self.watcher.addPath(abspath("."))
self.watcher.directoryChanged.connect(self._watcher_changed_callback)
def _watcher_changed_callback(self, val):
if self._watcher_file_name not in os.listdir(val):
secs = 3
self.show_message("Shutdown", "Watcher file was deleted. D2MP will shotdown in %d seconds." %(secs))
sleep(secs)
self.exit()
def _create_tray_icon(self):
self.tray = QSystemTrayIcon(self)
self.tray.setToolTip("D2Moddin Manager")
self.tray.setIcon(QIcon(SETTINGS['icon']))
traymenu = QMenu()
traymenu.addAction("Restart", self.restart)
traymenu.addAction("Uninstall", self.uninstall)
traymenu.addAction("Preferences", UIManager().open_preferences)
traymenu.addAction("Show mod list", self.show_mod_list)
traymenu.addSeparator()
traymenu.addAction("Exit", self.exit)
self.tray.setContextMenu(traymenu)
self.tray.show()
def restart(self):
python = sys.executable
args = set(sys.argv)
args.add("restart")
os.execl(python, python, *list(sys.argv))
self.exit()
def uninstall(self):
ModManager().delete_mods()
# ModManager().uninstall_d2mp()
self.exit()
def exit(self):
# do some cleanup
return super(SingleApplication, self).exit()
def show_mod_list(self):
self.show_message("Mod List", ModManager().mod_names_as_string())
def show_message_from_socket(self, message):
self.show_message("Server message", message)
def show_error_from_socket(self, message):
self.show_message("Server error", message, QSystemTrayIcon.Critical)
def show_message_from_mod_manager(self, message):
self.show_message("ModManager message", message)
def show_error_from_mod_manager(self, message):
self.show_message("ModManager error", message, QSystemTrayIcon.Critical)
def show_message(self, title, message, icon = QSystemTrayIcon.Information):
self.tray.showMessage(title, message, icon)
class Terminals(QWidget):
ready = pyqtSignal(bool)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.ui = uic.loadUiType('terminal.ui')[0]()
self.ui.setupUi(self)
self.notifier = QSystemTrayIcon(QIcon('arrow-up-icon.png'), self)
self.notifier.show()
self.session = None
self.model = None
self.devices = {}
self.mainloop = None
self.delegate = None
def test_display(self):
if self.mainloop:
self.mainloop.test_display()
def update_device_config(self):
if self.mainloop:
self.mainloop.update_config()
def terminal_open(self, addr):
if self.mainloop:
self.mainloop.terminal_open(addr)
def terminal_close(self, addr):
if self.mainloop:
self.mainloop.terminal_close(addr)
def begin_session(self, fio, access):
if access in ['operator']:
self.ui.cashier.setText(fio)
self.session = (fio, access)
return True
return False
def end_session(self, block=False):
self.ui.cashier.setText(u'')
self.session = None
self.stop_mainloop(block)
return True
def on_mainloop_stopped(self):
self.mainloop = None
if self.session:
self.start_mainloop()
def start_mainloop(self):
if self.mainloop is None:
self.mainloop = Mainloop(devices=self.devices)
self.mainloop.ready.connect(self.on_mainloop_ready)
self.mainloop.stopped.connect(self.on_mainloop_stopped)
self.mainloop.notify.connect(lambda title, msg: self.notifier.showMessage(title, msg))
self.mainloop.start()
def stop_mainloop(self, block=False):
if self.mainloop:
try:
self.mainloop.state.disconnect()
self.mainloop.ready.disconnect()
self.mainloop.notify.disconnect()
except TypeError:
print 'NOTE: mainloop signals disconnect'
if self.model:
[self.ui.terminals.closePersistentEditor(self.model.index(row, 0))
for row in xrange(self.model.rowCount())]
self.mainloop.stop(block)
else:
self.ready.emit(False)
def reset_mainloop(self, devices):
self.devices = devices
if self.mainloop is None:
self.start_mainloop()
else:
self.stop_mainloop()
def on_mainloop_ready(self, ok, titles):
if ok:
self.model = QStandardItemModel(len(titles), 1)
[self.model.setItem(i, QStandardItem(str(addr))) for i, addr in enumerate(titles.keys())]
self.delegate = TerminalDelegate(self.mainloop, titles)
self.mainloop.report.connect(self.delegate.report)
self.mainloop.state.connect(self.delegate.state)
self.ui.terminals.setModel(self.model)
self.ui.terminals.setItemDelegateForColumn(0, self.delegate)
[self.ui.terminals.openPersistentEditor(self.model.index(row, 0))
for row in xrange(self.model.rowCount())]
self.mainloop.db.free_places_update.connect(self.ui.free_places.setValue)
self.mainloop.update_config()
else:
self.model = None
self.mainloop = None
self.ready.emit(ok)
class UniFileSyncUI(QMainWindow):
"""UniFileSyncUI class"""
def __init__(self, name=None):
super(UniFileSyncUI, self).__init__()
self.ui = Ui_UniFileSyncPop()
self.ui.setupUi(self)
self.setFixedSize(self.size())
self.server = UServer('UServer')
self.server.regSelfToBus()
if name:
self.setName(name)
self.createActions()
self.createTrayIcon()
self.createStatusBar()
qApp.setQuitOnLastWindowClosed(False)
#connect the signal with slot
self.connectUISlots(self.ui)
#set UI label
username = ConfManager.getManager().getValue('UI', 'username')
self.ui.nameLabel.setText(username)
#Start server immediately
self.server.start()
#self.server.getHandler('start')({'name': 'all'})
msg = self.server.initMsg('start', None, MSG_UNIQUE_ID_T_CONTROLLER, False, {'name': 'all'})
UMsgBus.getBus().send(msg)
self.server.addCallBack(self.statusupdate)
self.server.addCallBack(self.cloudinfoupdate)
#setup list
self.setupFolderList(self.ui.folderList)
self.setupPluginList(self.ui.pluginList)
self.setupNetworkConf()
#Init status bar
stBarConf = ConfManager.getManager().getValue('UI', 'statusbar')
self.statusbar.showMessage(stBarConf['messages']['init'])
#Init system icon
self.trayIcon.show()
self.showTrayIconMessage()
def setupNetworkConf(self):
"""setup network configuration into UI"""
conf = ConfManager.getManager().getValue('common', 'network')
self.ui.proxyLineEdit.setText(conf['proxy'])
self.ui.portLineEdit.setText("%s" % conf['port'])
def closeEvent(self, event):
"""override close event"""
if self.trayIcon.isVisible():
self.hide()
event.ignore()
ConfManager.getManager().save()
logging.debug('[%s] is closed, window is hide, configuration is saved', self.getName())
def createActions(self):
"""create tray icon menu action"""
self.configAction = QAction("&ShowConfig", self, triggered=self.show)
self.exitAction = QAction("&Exit", self)
self.exitAction.triggered.connect(lambda: UMsgBus.getBus().send(self.server.initMsg('stop', None, MSG_UNIQUE_ID_T_CONTROLLER, False, {'name': 'all'})))
self.exitAction.triggered.connect(qApp.quit)
def createTrayIcon(self):
"""create system tray icon"""
self.trayIconMenu = QMenu(self)
es = self.trayIconMenu.addAction(self.configAction)
self.trayIconMenu.addSeparator()
ea = self.trayIconMenu.addAction(self.exitAction)
self.trayIcon = QSystemTrayIcon(self)
self.trayIcon.setContextMenu(self.trayIconMenu)
self.trayIcon.setIcon(QIcon('icon/tray.png'))
def showTrayIconMessage(self):
"""show tray icon message"""
conf = ConfManager.getManager().getValue('UI', 'trayicon')
popup = conf['popup']
self.trayIcon.showMessage(popup['title'], popup['message'])
def setupFolderList(self, folderList):
"""setup folder list for showing"""
fts = ConfManager.getManager().getValue('common', 'folders')
i = 0
for ft in fts:
flistItem = QListWidgetItem(QIcon('icon/folder.png'), ft, folderList)
folderList.insertItem(i, flistItem)
i += 1
def setupPluginList(self, pluginList):
"""setup plugin list from configuration file"""
fts = ConfManager.getManager().getValue('common', 'plugins')
i = 0
for ft in fts:
flistItem = QListWidgetItem(QIcon('icon/plugin.png'), ft['name'], pluginList)
pluginList.insertItem(i, flistItem)
i += 1
def show(self):
"""ovrride parent show method"""
super(UniFileSyncUI, self).show()
#Init status bar
stBarConf = ConfManager.getManager().getValue('UI', 'statusbar')
self.statusbar.showMessage(stBarConf['messages']['init'])
#set UI label
username = ConfManager.getManager().getValue('UI', 'username')
self.ui.nameLabel.setText(username)
def connectUISlots(self, ui):
"""connect ui component with slots"""
ui.connBtn.clicked.connect(lambda : self.connBtnSlots(ui.connBtn))
ui.addFolderBtn.clicked.connect(lambda: self.connBtnSlots(ui.addFolderBtn))
ui.rmFolderBtn.clicked.connect(lambda: self.connBtnSlots(ui.rmFolderBtn))
ui.saveBtn.clicked.connect(lambda: self.connBtnSlots(ui.saveBtn))
ui.unloadBtn.clicked.connect(lambda: self.connBtnSlots(ui.unloadBtn))
ui.reloadBtn.clicked.connect(lambda: self.connBtnSlots(ui.reloadBtn))
ui.resetBtn.clicked.connect(lambda: self.connBtnSlots(ui.resetBtn))
ui.addPluginBtn.clicked.connect(lambda: self.connBtnSlots(ui.addPluginBtn))
ui.syncFolderBtn.clicked.connect(lambda: self.connBtnSlots(ui.syncFolderBtn))
self.connect(self, SIGNAL('statusupdate'), self.statusbarUpdate)
self.connect(self, SIGNAL('cloudinfoupdate'), self.infoLabelUpdate)
def connBtnSlots(self, btn):
"""docstring for connBtnSlots"""
if btn is self.ui.connBtn:
if btn.text() == 'Connect':
msg = self.server.initMsg('info', None, MSG_UNIQUE_ID_T_CONTROLLER, True, {'name': 'all'})
UMsgBus.getBus().send(msg)
#res, data = self.server.getHandler('info')({'name': 'all'})
btn.setText('Connecting')
#self.ui.infoLabel.setText(data)
logging.debug('[%s]: Press Connect to getCloudInfo', self.getName())
elif btn.text() == 'Disconnect':
#self.server.getHandler('stop')({'name': 'all'})
btn.setText('Connect')
self.ui.infoLabel.setText('Cloud Disk is disconnected')
elif btn is self.ui.addFolderBtn:
fileDialog = QFileDialog(self)
fileDialog.setWindowTitle('Select Folder')
folderPath = fileDialog.getExistingDirectory()
if folderPath != "":
listItem = QListWidgetItem(QIcon('icon/folder.png'), folderPath, self.ui.folderList)
pyStr = '%s' % folderPath
logging.debug('[%s]: add folder path %s', self.getName(), pyStr)
self.ui.folderList.insertItem(self.ui.folderList.count(), listItem)
folderList = ConfManager.getManager().getValue('common', 'folders')
folderList.append(pyStr)
ConfManager.getManager().setValue('common', 'folders', folderList)
#send watch dir request
msg = self.server.initMsg('watch', None, MSG_UNIQUE_ID_T_CONTROLLER, True, {'path': pyStr, 'action': 'add'})
UMsgBus.getBus().send(msg)
self.statusbar.showMessage('Adding watch path %s' % folderPath)
elif btn is self.ui.rmFolderBtn:
row = self.ui.folderList.currentRow()
item = self.ui.folderList.currentItem()
folderList = ConfManager.getManager().getValue('common', 'folders')
self.statusbar.showMessage('Removing watch path %s' % item.text())
pyStr = '%s' % item.text()
folderList.remove(pyStr)
ConfManager.getManager().setValue('common', 'folders', folderList)
logging.debug('[%s]: remove item %d %s', self.getName(), row, item.text())
msg = self.server.initMsg('watch', None, MSG_UNIQUE_ID_T_CONTROLLER, True, {'path': pyStr, 'action': 'rm'})
UMsgBus.getBus().send(msg)
self.ui.folderList.takeItem(row)
elif btn is self.ui.saveBtn:
proxyConf = ConfManager.getManager().getValue('common', 'network')
server = str(self.ui.proxyLineEdit.text())
if server != "" and server != None:
user = str(self.ui.proxyNameLineEdit.text())
password = str(self.ui.proxyPwdLineEdit.text())
logging.debug('[%s]: save server=>%s user=>%s password=>%s into configuration',
self.getName(), server, user, password)
proxyConf['proxy'] = server
proxyConf['user'] = user
proxyConf['password'] = password
ConfManager.getManager().setValue('common', 'network', proxyConf)
msg = self.server.initMsg('proxy', None, MSG_UNIQUE_ID_T_CONTROLLER, True,
{'http': 'http://%s' % server, 'https': 'https://%s' % server})
UMsgBus.getBus().send(msg)
self.statusbar.showMessage('Applying proxy %s' % server)
ConfManager.getManager().save()
elif btn is self.ui.resetBtn:
proxyConf = ConfManager.getManager().getValue('common', 'network')
server = proxyConf['proxy']
user = proxyConf['user']
password = proxyConf['password']
port = proxyConf['port']
self.ui.proxyLineEdit.setText(server)
self.ui.proxyNameLineEdit.setText(user)
self.ui.proxyPwdLineEdit.setText(password)
self.ui.portLineEdit.setText(str(port))
self.ui.serverEnableCheckBox.setCheckState(0)
elif btn is self.ui.unloadBtn:
row = self.ui.pluginList.currentRow()
it = str(self.ui.pluginList.currentItem().text())
logging.debug('[%s]: unload plugin name %s', self.getName(), it)
self.statusbar.showMessage('Unloading plugin %s' % it)
PluginManager.getManager().unload(it)
self.ui.pluginList.takeItem(row)
conf = ConfManager.getManager().getValue('common', 'plugins')
for pc in conf:
if pc['name'] == it:
conf.remove(pc)
ConfManager.getManager().setValue('common', 'plugins', conf)
elif btn is self.ui.reloadBtn:
row = self.ui.pluginList.currentRow()
it = str(self.ui.pluginList.currentItem().text())
logging.debug('[%s]: reload plugin name %s', self.getName(), it)
self.statusbar.showMessage('Reloading plugin %s' % it)
PluginManager.getManager().reload(it)
elif btn is self.ui.addPluginBtn:
path = QFileDialog.getOpenFileName(self)
PluginManager.getManager().loadPluginFromPath(str(path))
elif btn is self.ui.syncFolderBtn:
folder = str(self.ui.folderList.currentItem().text())
msg = self.server.initMsg('sync', None, MSG_UNIQUE_ID_T_CONTROLLER, True, {'path': str(folderPath), 'action': 'add'})
UMsgBus.getBus().send(msg)
self.statusbar.showMessage('Sync %s with cloud' % folder)
def createStatusBar(self):
"""create status bar"""
self.statusbar = QStatusBar(self)
self.setStatusBar(self.statusbar)
def setName(self, name):
"""set server name"""
self.name = name
def getName(self):
"""get server name"""
return self.name
def statusupdate(self, param):
"""call back for status update"""
self.emit(SIGNAL('statusupdate'), param['result'])
def statusbarUpdate(self, res):
"""statusbar update callback"""
self.statusbar.showMessage(ERR_STR_TABLE[res])
def cloudinfoupdate(self, param):
"""cloud infor update callback"""
self.emit(SIGNAL('cloudinfoupdate'), param['data'])
def infoLabelUpdate(self, res):
"""infoLabelUpdate"""
if res:
self.ui.infoLabel.setText(res)
self.ui.connBtn.setText('Disconnect')
class MainWindow(QWidget):
def __init__(self):
super(QWidget, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.systemTray = QSystemTrayIcon(self)
self.systemTray.setIcon(QIcon(':/images/icon.png'))
self.act_autostart = QAction('开机启动', self)
self.act_autostart.setCheckable(True)
is_autostart = self.is_autostart()
self.act_autostart.setChecked(is_autostart)
self.act_autostart.triggered.connect(self.on_autostart)
act_setting = QAction('设置启动项', self)
act_setting.triggered.connect(self.on_settings)
act_exit = QAction('退出', self)
act_exit.triggered.connect(self.on_exit)
self.menu_run = QMenu('运行', self)
menu = QMenu('菜单', self)
menu.addMenu(self.menu_run)
menu.addAction(act_setting)
menu.addSeparator()
menu.addAction(self.act_autostart)
menu.addAction(act_exit)
self.systemTray.setContextMenu(menu)
self.systemTray.show()
self.showMessage('启动工具正在运行')
self.ui.btn_add.clicked.connect(self.on_add)
self.ui.btn_delete.clicked.connect(self.on_delete)
self.ui.btn_apply.clicked.connect(self.on_apply)
self.ui.btn_env_add.clicked.connect(self.on_env_add)
self.ui.btn_env_del.clicked.connect(self.on_env_del)
self.ui.btn_open.clicked.connect(self.on_open)
self.ui.btn_run.clicked.connect(self.on_run)
self.ui.le_args.textEdited.connect(self.on_edited)
self.ui.le_desc.textEdited.connect(self.on_edited)
self.ui.le_exe.textEdited.connect(self.on_edited)
self.ui.cb_process.currentIndexChanged.connect(self.on_index_changed)
self.ui.le_exe.installEventFilter(self)
self.init()
def eventFilter(self, obj, event):
if event.type() == QEvent.DragEnter:
# we need to accept this event explicitly to be able to receive QDropEvents!
event.accept()
if event.type() == QEvent.Drop:
md = event.mimeData()
urls = md.urls()
if (urls and urls[0].scheme() == 'file'):
# for some reason, this doubles up the intro slash
filepath = urls[0].path().mid(1)
self.ui.le_exe.setText(filepath)
self.modify = True
self.ui.btn_apply.setEnabled(True)
event.accept()
return QObject.eventFilter(self, obj, event)
def showMessage(self, msg):
self.systemTray.showMessage('Launcher', msg,
QSystemTrayIcon.Information, 10000)
def config_dir(self):
confd = QString2str(
QApplication.applicationDirPath()) + os.sep + 'configs'
dir = QDir(confd)
if not dir.exists():
dir.mkpath(confd)
return confd
def on_settings(self):
self.show()
def on_exit(self):
QtGui.qApp.quit()
def on_edited(self):
self.modify = True
self.ui.btn_apply.setEnabled(True)
def on_apply(self):
if self.currentProcess is None:
QMessageBox.warning(self, '警告', '未选择有效启动项，无法完成保存！')
return
args = self.ui.le_args.text()
exe = self.ui.le_exe.text()
desc = self.ui.le_desc.text()
isInherit = self.ui.cb_inheri.checkState() == QtCore.Qt.Checked
self.currentProcess.setArgs(QString2str(args))
self.currentProcess.setExe(QString2str(exe))
self.currentProcess.setDesc(QString2str(desc))
self.currentProcess.setIsInherit(isInherit)
envs = {}
for i in range(self.ui.tw_envs.rowCount()):
key = self.ui.tw_envs.item(i, 0).text()
value = self.ui.tw_envs.item(i, 1).text()
envs[QString2str(key)] = QString2str(value)
self.currentProcess.setEnvs(envs)
self.processDict[self.currentProcess.getName()] = self.currentProcess
configDir = self.config_dir()
configFilePath = configDir + os.sep + self.currentProcess.getName(
) + '.json'
with open(configFilePath, 'w+') as f:
f.write(self.currentProcess.save())
self.modify = False
self.ui.btn_apply.setEnabled(False)
QMessageBox.information(self, '提示', '已保存！')
def on_add(self):
ret = QInputDialog.getText(self, '请输入启动项目名称', '名称')
if not ret[1]:
return
name = ret[0]
if name.isEmpty():
return
if self.processDict.has_key(QString2str(name)):
QMessageBox.warning(self, '警告', '该启动项已存在！')
return
curProcess = Process()
curProcess.setName(QString2str(name))
configDir = self.config_dir()
configFilePath = configDir + os.sep + QString2str(name) + '.json'
with open(configFilePath, 'w+') as f:
f.write(curProcess.save())
self.add_item(curProcess)
self.ui.cb_process.setCurrentIndex(self.ui.cb_process.count() - 1)
def on_delete(self):
name = self.ui.cb_process.currentText()
index = self.ui.cb_process.currentIndex()
if not self.processDict.has_key(QString2str(name)):
QMessageBox.warning(self, '警告', '请先选择要删除的配置项！')
return
process = self.processDict.pop(QString2str(name))
for action in self.menu_run.actions():
if action.text() == name:
self.menu_run.removeAction(action)
self.ui.cb_process.removeItem(index)
configFilePath = self.config_dir() + os.sep + QString2str(
name) + '.json'
os.remove(configFilePath)
def on_index_changed(self, index):
if self.modify and QMessageBox.question(
self, '提示', '启动项已修改，是否保存？',
QMessageBox.Yes | QMessageBox.No) == QMessageBox.Yes:
self.on_apply()
name = self.ui.cb_process.itemText(index)
self.reset()
if self.processDict.has_key(QString2str(name)):
process = self.processDict[QString2str(name)]
self.currentProcess = process
self.display(process)
def on_env_add(self):
self.ui.tw_envs.setRowCount(self.ui.tw_envs.rowCount() + 1)
self.modify = True
self.ui.btn_apply.setEnabled(True)
def on_env_del(self):
index = self.ui.tw_envs.currentRow()
self.ui.tw_envs.removeRow(index)
self.modify = True
self.ui.btn_apply.setEnabled(True)
def on_run(self):
if self.modify and QMessageBox.question(
self, '提示', '启动项已修改，是否保存？',
QMessageBox.Yes | QMessageBox.No) == QMessageBox.Yes:
self.on_apply()
name = self.ui.cb_process.currentText()
if self.processDict.has_key(QString2str(name)):
process = self.processDict[QString2str(name)]
if process.start():
self.showMessage(u'%s启动项已执行' % process.getName())
else:
self.showMessage(u'%s启动项执行失败，请检查配置' % process.getName())
else:
QMessageBox.warning(self, '警告', '请先选择要运行的启动项！')
def on_action_run(self):
name = self.sender().text()
if self.processDict.has_key(QString2str(name)):
process = self.processDict[QString2str(name)]
if process.start():
self.showMessage(u'%s启动项已执行' % process.getName())
else:
self.showMessage(u'%s启动项执行失败，请检查配置' % process.getName())
else:
QMessageBox.warning(self, '警告', '请先选择要运行的启动项！')
def on_open(self):
filePath = QFileDialog.getOpenFileName(self, '选择程序')
self.ui.le_exe.setText(filePath)
self.modify = True
self.ui.btn_apply.setEnabled(True)
def closeEvent(self, event):
event.ignore()
self.hide()
def add_item(self, process):
self.processDict[process.getName()] = process
self.ui.cb_process.addItem(process.getName())
act = self.menu_run.addAction(process.getName())
act.triggered.connect(self.on_action_run)
def init(self):
self.modify = False
self.ui.btn_apply.setEnabled(False)
self.currentProcess = None
self.processDict = {}
config_dir = self.config_dir()
items = os.listdir(config_dir)
for item in items:
currentPath = self.config_dir() + os.sep + item
if not os.path.isdir(currentPath) and os.path.exists(currentPath):
with open(currentPath, 'r') as f:
content = f.read()
process = Process()
if process.load(content):
self.add_item(process)
def reset(self):
self.ui.le_args.setText('')
self.ui.le_exe.setText('')
self.ui.le_desc.setText('')
self.ui.tw_envs.clear()
self.ui.tw_envs.setRowCount(0)
self.modify = False
self.ui.btn_apply.setEnabled(False)
def display(self, process):
self.ui.le_args.setText(process.getArgs())
self.ui.le_exe.setText(process.getExe())
self.ui.le_desc.setText(process.getDesc())
envs = process.getEnvs()
for key in envs.keys():
row = self.ui.tw_envs.rowCount()
self.ui.tw_envs.setRowCount(row + 1)
self.ui.tw_envs.setItem(row, 0, QTableWidgetItem(key))
self.ui.tw_envs.setItem(row, 1, QTableWidgetItem(envs[key]))
def on_autostart(self):
if self.act_autostart.isChecked():
self.set_autostart(True)
self.showMessage('已设置开机启动')
else:
self.set_autostart(False)
self.showMessage('已取消开机启动')
def is_autostart(self):
reg = QSettings(
"HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run",
QSettings.NativeFormat)
return reg.contains("launcher")
def set_autostart(self, auto):
path = QApplication.applicationFilePath()
path = QDir.toNativeSeparators(path)
reg = QSettings(
"HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run",
QSettings.NativeFormat)
if auto is True:
reg.setValue("launcher", QVariant(QString('"%1"').arg(path)))
else:
reg.remove("launcher")
