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 Example(QtGui.QMainWindow):
def __init__(self):
super(Example, self).__init__()
self.path=sys.path[0]
f=open('%s/ACCESS_KEY'% self.path,'r')
f1=open('%s/ACCESS_SECRET'% self.path,'r')
f2=open('%s/user_info'% self.path)
self.user_name=f2.readline().strip('\n')
self.user_id=f2.readline().strip('\n')
self.a=f.readline().strip('\n')
self.b=f1.readline().strip('\n')
f.close()
f1.close()
f2.close()
self.initUI()
def initUI(self):
self.icon=QSystemTrayIcon()
self.icon.isSystemTrayAvailable()
self.icon.setIcon( QtGui.QIcon('%s/web.png'% self.path) )
self.icon.setToolTip ( 'dubbleclick to maximize')
self.icon.show()
self.icon.activated.connect(self.activate)
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground)
self.setGeometry(300, 300, 1500, 1000)
frame = QtGui.QFrame(parent=self)
frame.setStyleSheet("QFrame {background: rgba(0,0,0,50%)}")
box=QtGui.QHBoxLayout()
self.edit = QtGui.QLineEdit()
self.edit.setStyleSheet("background: rgba(0,0,0,100%); "" font-weight : bold;" "color: rgb(250,250,250);""border:5px solid ")
def __init__(self, parent=None):
super(MainForm, self).__init__(parent)
uic.loadUi("./MainWindow/form.ui", self)
self.setWindowTitle("NFS-List")
self.setLayout(self.gridLayout)
self.setGeometry(100, 100, 640, 480)
self.listWidget.setViewMode(QtGui.QListView.IconMode)
self.listWidget.setMovement(QtGui.QListWidget.Static)
self.ipv6_enable = True # False
self.addr_ipv4 = None
self.addr_ipv6 = None
self.addr_ipv4_array = []
self.addr_ipv6_array = []
self.time = 1
self.hosts = []
self.icon = QtGui.QIcon("./MainWindow/NAS-icon.png")
self.setWindowIcon(self.icon)
#Tray
tray_menu = QtGui.QMenu(self)
show_hide_action = QAction("Show/Hide", self)
quitAction = QAction("Quit", self)
tray_menu.addAction(show_hide_action)
tray_menu.addAction(quitAction)
tray = QSystemTrayIcon(self)
tray.setIcon(self.icon)
tray.setContextMenu(tray_menu)
tray.setToolTip(self.windowTitle())
tray.show()
#
show_hide_action.triggered.connect(self.showHideWindow)
quitAction.triggered.connect(QtGui.qApp.quit)
#end tray
# self.ico.addPixmap(self.pixmap)
ifaces = QtNetwork.QNetworkInterface.allInterfaces()
for iface in ifaces:
for addr_iface in iface.addressEntries():
if addr_iface.ip() != QtNetwork.QHostAddress(QtNetwork.QHostAddress.LocalHost) and \
addr_iface.ip() != QtNetwork.QHostAddress(QtNetwork.QHostAddress.LocalHostIPv6):
if addr_iface.ip().toIPv4Address():
self.addr_ipv4_array.append(addr_iface)
if self.ipv6_enable:
if addr_iface.ip().toIPv6Address():
self.addr_ipv6_array.append(addr_iface)
if len(self.addr_ipv4_array) >= 1:
self.addr_ipv4 = self.addr_ipv4_array[0].ip().toString()
#ip data#
addr_mask = self.addr_ipv4_array[0].netmask().toString()
#addr_mask = '255.255.255.192'
__list_aprefix = addr_mask.split('.')
cidr_ipv4 = 0
bn = '0b'
baddr = '0b'
for i in __list_aprefix:
cidr_ipv4 += rpclib.bit_count(int(i))
bn += bin(int(i))[2:]
print("cidr:", cidr_ipv4)
print(bn)
#
total_ip_count = (2 ** (32 - cidr_ipv4)) - 2
print('total_ip_count:', total_ip_count)
print(self.addr_ipv4)
int_net_ipv4 = rpclib.ip2int(self.addr_ipv4) & rpclib.ip2int(addr_mask)
net_ipv4 = rpclib.int2ip(int_net_ipv4)
#abc = ClockThread(self.time, self.add_new_item)
#abc.start()
#self.add_new_item('t34', 't32')
self.scan_network = ThreadScanNetwork(10, net_ipv4, cidr_ipv4, self, 1.2)
self.scan_network.start()
self.check_host = ThreadCheckHost(self.hosts, self)
self.check_host.start()
#self.add_host({"host":"100.64.0.1","structures":[{'groups': [b'*'], 'dir': b'/srv/NFS'}]})
"""
self.listWidget.setContextMenuPolicy(QtCore.Qt.ActionsContextMenu)
self.actionInfo = QAction("Info", self.listWidget)
self.actionMount = QAction("Mount", self.listWidget)
self.listWidget.addAction(self.actionMount)
self.listWidget.addAction(self.actionInfo)
self.actionInfo.triggered.connect(self.showInfo)
self.actionMount.triggered.connect(self.my_method)
"""
self.listWidget.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.listWidget.customContextMenuRequested.connect(self.showRightMenu)
try:
_fromUtf8 = QString.fromUtf8
except AttributeError:
def _fromUtf8(s):
return s
app = QApplication(sys.argv)
app.setQuitOnLastWindowClosed(False)
m = QWidget()
d = QMainWindow(m)
t = QSystemTrayIcon(m)
t.setIcon(QIcon("icon/tray.png"))
ui = Ui_UniFileSyncPop()
ui.setupUi(d)
d.setFixedSize(d.size())
req = {"type": "request"}
confManager = ConfManager.getManager()
fts = confManager.getValue("common", "folders")
ui.nameLabel.setText(confManager.getValue("UI", "username"))
sys.exit(0)
except dbus.exceptions.DBusException:
QMessageBox.critical(None, "Can't connect",
"""Can't connect to pyUmlaut0r daemon.\nYou should first start a daemon by calling:\n'pyUmlaut0r.py -d'.""")
print "can't connect to daemon"
sys.exit(1)
#set process name
utils.setProcessName("pyUmlaut0r")
#create trayIcon
trayIcon = QSystemTrayIcon()
trayIcon.setIcon(QIcon(":/pyUmlaut0rIcon.png"))
trayIcon.setContextMenu(utils.createMenu())
trayIcon.show()
#dbus "daemon"
DBusQtMainLoop(set_as_default = True)
class DBusInterface(dbus.service.Object):
def __init__(self):
busName = dbus.service.BusName('org.documentroot.umlaut0r', \
bus = dbus.SessionBus())
dbus.service.Object.__init__(self, busName, '/umlaut0r')
@dbus.service.method('org.documentroot.umlaut0r', in_signature='s')
def toClipboard(self, s):
utils.toClipboard(s)
class Qt4SysTrayIcon:
def __init__(self):
self.snapshots = snapshots.Snapshots()
self.config = self.snapshots.config
if len(sys.argv) > 1:
if not self.config.set_current_profile(sys.argv[1]):
logger.warning("Failed to change Profile_ID %s" % sys.argv[1],
self)
self.qapp = qt4tools.create_qapplication(self.config.APP_NAME)
import icon
self.icon = icon
self.qapp.setWindowIcon(icon.BIT_LOGO)
self.status_icon = QSystemTrayIcon(icon.BIT_LOGO)
#self.status_icon.actionCollection().clear()
self.contextMenu = QMenu()
self.menuProfileName = self.contextMenu.addAction(
_('Profile: "%s"') % self.config.get_profile_name())
qt4tools.set_font_bold(self.menuProfileName)
self.contextMenu.addSeparator()
self.menuStatusMessage = self.contextMenu.addAction(_('Done'))
self.menuProgress = self.contextMenu.addAction('')
self.menuProgress.setVisible(False)
self.contextMenu.addSeparator()
self.startBIT = self.contextMenu.addAction(icon.BIT_LOGO,
_('Start BackInTime'))
QObject.connect(self.startBIT, SIGNAL('triggered()'), self.onStartBIT)
self.status_icon.setContextMenu(self.contextMenu)
self.pixmap = icon.BIT_LOGO.pixmap(24)
self.progressBar = QProgressBar()
self.progressBar.setMinimum(0)
self.progressBar.setMaximum(100)
self.progressBar.setValue(0)
self.progressBar.setTextVisible(False)
self.progressBar.resize(24, 6)
self.progressBar.render(self.pixmap,
sourceRegion=QRegion(0, -14, 24, 6),
flags=QWidget.RenderFlags(
QWidget.DrawChildren))
self.first_error = self.config.is_notify_enabled()
self.popup = None
self.last_message = None
self.timer = QTimer()
QObject.connect(self.timer, SIGNAL('timeout()'), self.update_info)
self.ppid = os.getppid()
def prepare_exit(self):
self.timer.stop()
if not self.status_icon is None:
self.status_icon.hide()
self.status_icon = None
if not self.popup is None:
self.popup.deleteLater()
self.popup = None
self.qapp.processEvents()
def run(self):
self.status_icon.show()
self.timer.start(500)
logger.info("[qt4systrayicon] begin loop", self)
self.qapp.exec_()
logger.info("[qt4systrayicon] end loop", self)
self.prepare_exit()
def update_info(self):
if not tools.is_process_alive(self.ppid):
self.prepare_exit()
self.qapp.exit(0)
return
message = self.snapshots.get_take_snapshot_message()
if message is None and self.last_message is None:
message = (0, _('Working...'))
if not message is None:
if message != self.last_message:
self.last_message = message
self.menuStatusMessage.setText('\n'.join(tools.wrap_line(self.last_message[1],\
size = 80,\
delimiters = '',\
new_line_indicator = '') \
))
self.status_icon.setToolTip(self.last_message[1])
pg = progress.ProgressFile(self.config)
if pg.isFileReadable():
pg.load()
percent = pg.get_int_value('percent')
if percent != self.progressBar.value():
self.progressBar.setValue(percent)
self.progressBar.render(self.pixmap,
sourceRegion=QRegion(0, -14, 24, 6),
flags=QWidget.RenderFlags(
QWidget.DrawChildren))
self.status_icon.setIcon(QIcon(self.pixmap))
self.menuProgress.setText(' | '.join(self.getMenuProgress(pg)))
self.menuProgress.setVisible(True)
else:
self.status_icon.setIcon(self.icon.BIT_LOGO)
self.menuProgress.setVisible(False)
def getMenuProgress(self, pg):
d = (('sent', _('Sent:')), \
('speed', _('Speed:')),\
('eta', _('ETA:')) )
for key, txt in d:
value = pg.get_str_value(key, '')
if not value:
continue
yield txt + ' ' + value
def onStartBIT(self):
profileID = self.config.get_current_profile()
cmd = [
'backintime-qt4',
]
if not profileID == '1':
cmd += ['--profile-id', profileID]
proc = subprocess.Popen(cmd)
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 Example(QtGui.QMainWindow):
def __init__(self):
super(Example, self).__init__()
self.path = sys.path[0]
f = open("%s/ACCESS_KEY" % self.path, "r")
f1 = open("%s/ACCESS_SECRET" % self.path, "r")
f2 = open("%s/user_info" % self.path)
self.user_name = f2.readline().strip("\n")
self.user_id = f2.readline().strip("\n")
self.a = f.readline().strip("\n")
self.b = f1.readline().strip("\n")
f.close()
f1.close()
f2.close()
self.initUI()
def initUI(self):
self.icon = QSystemTrayIcon()
self.icon.isSystemTrayAvailable()
self.icon.setIcon(QtGui.QIcon("%s/me.jpg" % self.path))
self.icon.setToolTip("dubbleclick untuk maximize")
self.icon.show()
self.icon.activated.connect(self.activate)
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground)
self.setGeometry(150, 150, 500, 200)
frame = QtGui.QFrame(parent=self)
frame.setStyleSheet("QFrame {background: rgba(0,0,0,50%)}")
box = QtGui.QHBoxLayout()
self.edit = QtGui.QLineEdit()
self.edit.setStyleSheet(
"background: rgba(0,0,0,100%); " " font-weight : bold;" "color: rgb(250,250,250);" "border:5px solid "
)
self.edit.setToolTip("Tolong <b>Massukan tweet Anda di sini </b> ")
self.edit.returnPressed.connect(self.returnPressed)
box.addWidget(self.edit)
frame.setLayout(box)
qbtn1 = QtGui.QPushButton("keluar", self)
qbtn1.clicked.connect(self.close)
qbtn1.setStyleSheet(
"background: rgba(0,0,0,100%); " " font-weight : bold;" "color: rgb(250,250,250);" "border:5px solid "
)
box.addWidget(qbtn1)
self.statusBar().setStyleSheet(
"background: rgba(0,0,0,100%);" " font-weight : bold;" "color: rgb(250,250,250)"
)
self.statusBar().showMessage("Tekan enter untuk mengirim twitter, ESC untuk minimize")
self.setCentralWidget(frame)
self.setWindowIcon(QtGui.QIcon("%s/me.jpg" % self.path))
self.setWindowTitle("Twitter Client With PyQt4")
self.center()
self.show()
self.twitter_auth()
def twitter_auth(self):
CONSUMER_KEY = "gYMpKX6YWDP5rBwvCcriQ"
CONSUMER_SECRET = "ulK4WA6gtB5FekyPYRrOXVCxeqvwP66leFfNq5DY"
ACCESS_KEY = self.a
ACCESS_SECRET = self.b
self.auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
self.auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)
def keyPressEvent(self, e):
if e.key() == QtCore.Qt.Key_Escape:
print "Escape wass pressed "
self.icon.show()
self.hide()
def activate(self, reason):
print reason
if reason == 2:
self.show()
def center(self):
qr = self.frameGeometry()
cp = QtGui.QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def returnPressed(self):
path = sys.path[0]
tweet = self.edit.text()
api = tweepy.API(self.auth)
self.statusBar().showMessage("Mengirim . .. ")
api.update_status(tweet)
self.statusBar().showMessage("Twitter Anda terkirim ! ")
n = pynotify.Notification(
" @ %s " % self.user_name, "twitter Anda terkirim ", "%s/%s.jpg" % (path, self.user_id)
)
n.set_hint("x", 200)
n.set_hint("y", 400)
pynotify.init("n")
n.show()
self.statusBar().showMessage("Tekan enter untuk mengirim dan tekan ESC untuk minimize ")
self.edit.clear()
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 MainWindow(QMainWindow):
__connManager = None
__activeClient = -1
def __init__(self, manager, parent = None):
QMainWindow.__init__(self, parent)
self.__activeClient = -1
self.__connManager = manager
self.setWindowTitle(self.tr("Boinc gui"))
self.createActions()
self.createMenu()
self.createMainWin()
self.createTrayIcon()
self.readSettings()
self.statusBar().showMessage(self.tr("Ready"), 3000)
self.queueThread = ProcessQueeueThread(self.__connManager.queue(), self)
self.queueThread.start()
self.__connManager.loadConnections()
self.connect(self.centralWidget, SIGNAL('showStatusBarMsg(QString)'), self.__showStatusBarMsg)
def readSettings(self):
settings = QSettings()
settings.beginGroup("MainWindow")
self.resize(settings.value("size", QVariant(QSize(800, 500))).toSize());
settings.endGroup()
def writeSettings(self):
settings = QSettings()
settings.beginGroup("MainWindow")
settings.setValue("size", QVariant(self.size()));
settings.endGroup()
def closeEvent(self, event):
if self.__trayIcon.isVisible():
event.ignore()
self.hide()
def __showStatusBarMsg(self, msg):
self.statusBar().showMessage(msg, 3000)
def connManager(self):
return self.__connManager
def __del__(self):
self.writeSettings()
self.queueThread.stop()
self.__connManager.queue().put("")
self.queueThread.wait()
def createMainWin(self):
self.centralWidget = mainWidget(self.__connManager)
self.connect(self.centralWidget, SIGNAL('clientChanged(int)'), self.changeClient)
self.setCentralWidget(self.centralWidget)
self.setWindowIcon(QIcon(QPixmap(":boinc.png")))
def createTrayIcon(self):
self.__trayIcon = QSystemTrayIcon(self)
self.__trayIcon.setIcon(QIcon(QPixmap(":boinc.png")))
self.__trayIconMenu = QMenu(self);
self.__trayIconMenu.addAction(self.quitAction)
self.__trayIcon.setContextMenu(self.__trayIconMenu)
self.connect(self.__trayIcon, SIGNAL('activated(QSystemTrayIcon::ActivationReason)'), self.iconActivated)
self.__trayIcon.show()
def iconActivated(self, dovod):
if dovod == QSystemTrayIcon.Trigger:
if self.isVisible():
self.hide()
else:
self.show()
def changeClient(self, client):
self.__activeClient = client
if client == -1:
self.remClientAction.setEnabled(False);
else:
self.remClientAction.setEnabled(True);
def createActions(self):
self.addClientAction = QAction(self.tr("&Add Client"), self)
self.remClientAction = QAction(self.tr("&Remove Client"), self)
self.quitAction = QAction(self.tr("&Quit"), self)
#pridavame klavesove skratky
self.quitAction.setShortcut(QKeySequence(self.tr("Ctrl+Q")))
self.remClientAction.setEnabled(False);
#prepojime akcie so slotmi
self.connect(self.addClientAction, SIGNAL("triggered()"), self.showWizard)
self.connect(self.remClientAction, SIGNAL("triggered()"), self.removeClient)
self.connect(self.quitAction, SIGNAL("triggered()"), qApp, SLOT("quit()"))
def removeClient(self):
if self.__activeClient != -1:
btn = QMessageBox.question(self, self.tr("Remove Client"), self.tr("Are you sure that you want to remove client?"), QMessageBox.Yes|QMessageBox.No)
if btn == QMessageBox.Yes:
self.__connManager.removeConnection(self.__activeClient)
def createMenu(self):
fileMenu = self.menuBar().addMenu(self.tr("&File"))
fileMenu.addAction(self.addClientAction)
fileMenu.addAction(self.remClientAction)
fileMenu.addAction(self.quitAction)
def showWizard(self):
self.wizardWin = addClientWizard(self)
self.connect(self.wizardWin, SIGNAL("wizardFinished(bool, QString, QString, int, QString)"), self.processWizard)
self.wizardWin.setModal(True)
self.wizardWin.show()
def processWizard(self, local, path, host, port, password):
self.__connManager.addConnection(local, path, host, port, password)
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 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()
try:
_fromUtf8 = QString.fromUtf8
except AttributeError:
def _fromUtf8(s):
return s
app = QApplication(sys.argv)
app.setQuitOnLastWindowClosed(False)
m = QWidget()
d = QMainWindow(m)
t = QSystemTrayIcon(m)
t.setIcon(QIcon('icon/tray.png'))
ui = Ui_UniFileSyncPop()
ui.setupUi(d)
d.setFixedSize(d.size())
req = {'type': 'request'}
confManager = ConfManager.getManager()
fts = confManager.getValue('common', 'folders')
ui.nameLabel.setText(confManager.getValue('UI', 'username'))
i = 0
class Example(QtGui.QWidget):
def __init__(self):
super(Example, self).__init__()
self.initUI()
def openApex(self):
if self.call_id:
webbrowser.open("http://tca-db1.astrakhan.businesscar.ru:8080/apex/f?p=999:1:0::NO:1:P1_ID_CUSTOMER:"+self.customer_id)
def openCrm(self):
if self.customer_id:
webbrowser.open("http://tca-crm/sugar/index.php?action=ajaxui#ajaxUILoc=index.php%3Fmodule%3DCalls%26offset%3D15%26stamp%3D1395146164095815300%26return_module%3DCalls%26action%3DDetailView%26record%3D"+self.call_id)
def initUI(self):
self.icon=QSystemTrayIcon()
r=self.icon.isSystemTrayAvailable()
self.customer_id=""
self.call_id = ""
self.icon.setIcon( QtGui.QIcon('w:\icon.png') )
self.icon.show()
self.setGeometry(350, 30, 640, 480)
self.setWindowIcon(QtGui.QIcon('w:\icon.png'))
self.setWindowTitle(u'CallCenter')
self.show()
self.icon.activated.connect(self.activate)
self.show()
self.icon.menu = QtGui.QMenu()
exitAction = self.icon.menu.addAction(u"Выход")
self.icon.setContextMenu(self.icon.menu)
self.connect(exitAction, QtCore.SIGNAL('triggered()'),QtGui.qApp, QtCore.SLOT('quit()'))
general_groupbox = QtGui.QGroupBox(u"Общая информация",self)
general_groupbox.show()
self.title_label = RedLabel(u"Название:")
surname_label = QtGui.QLabel(u"Фамилия:")
name_label = QtGui.QLabel(u"Имя:")
secondName_label = QtGui.QLabel(u"Отчество:")
clientType_label = RedLabel(u"Тип клиента:")
gender_label = RedLabel(u"Пол:")
burthday_label = RedLabel(u"Дата рождения:")
regDate_label = QtGui.QLabel(u"Дата рег-ции:")
phone_label = QtGui.QLabel(u"Тел.:")
mobilePhone_label = QtGui.QLabel(u"Моб. тел.:")
fax_label = QtGui.QLabel(u"Факс:")
indexCity_label = QtGui.QLabel(u"Индекс\Город:")
address_label = QtGui.QLabel(u"Адрес:")
self.phone_text = LineEdit()
mobilePhone_text = LineEdit()
fax_text = LineEdit()
indexCity_text = LineEdit()
address_text = LineEdit()
self.title_text = LineEdit()
surname_text = LineEdit()
name_text = LineEdit()
secondName_text = LineEdit()
clientType_text = LineEdit()
clientCode_text = LineEdit()
brunch_text = LineEdit()
transport_text = LineEdit()
paymentType_text = LineEdit()
maxSale_text = LineEdit()
gender_text = LineEdit()
burthday_text = LineEdit()
regDate_text = LineEdit()
lastVisit_text = LineEdit()
general_layoutBox = QtGui.QGridLayout(self)
general_layoutBox.setSpacing(10)
general_layoutBox.setColumnMinimumWidth(0,0)
general_layoutBox.addWidget(self.title_label,0,0)
general_layoutBox.addWidget(self.title_text,0,1)
general_layoutBox.addWidget(surname_label)
general_layoutBox.addWidget(surname_text)
general_layoutBox.addWidget(name_label)
general_layoutBox.addWidget(name_text)
general_layoutBox.addWidget(secondName_label)
general_layoutBox.addWidget(secondName_text)
general_layoutBox.addWidget(clientType_label)
general_layoutBox.addWidget(clientType_text)
general_layoutBox.addWidget(gender_label)
general_layoutBox.addWidget(gender_text)
general_layoutBox.addWidget(burthday_label)
general_layoutBox.addWidget(burthday_text)
general_layoutBox.addWidget(regDate_label)
general_layoutBox.addWidget(regDate_text)
general_groupbox.setLayout(general_layoutBox)
personal_groupbox = QtGui.QGroupBox(u"Персональные настройки",self)
personal_groupbox.show()
self.apex_button = QtGui.QPushButton(u"Подробно")
self.apex_button.resize(100,50)
self.apex_button.hide()
self.connect(self.apex_button, QtCore.SIGNAL('clicked()'), self.openApex)
self.crm_button = QtGui.QPushButton(u"CRM")
self.crm_button.resize(100,50)
self.crm_button.hide()
self.connect(self.crm_button, QtCore.SIGNAL('clicked()'), self.openCrm)
grid = QtGui.QGridLayout(self)
grid.addWidget(lastVisit_text,0,0)
grid.addWidget(self.apex_button)
grid.addWidget(self.crm_button)
# grid.addStretch(1)
personal_groupbox.setLayout(grid)
address_layoutBox = QtGui.QGridLayout(self)
address_layoutBox.setSpacing(10)
address_layoutBox.setColumnMinimumWidth(0,0)
address_layoutBox.addWidget(phone_label,0,0)
address_layoutBox.addWidget(self.phone_text,0,1)
address_layoutBox.addWidget(mobilePhone_label)
address_layoutBox.addWidget(mobilePhone_text)
address_layoutBox.addWidget(fax_label)
address_layoutBox.addWidget(fax_text)
address_layoutBox.addWidget(indexCity_label)
address_layoutBox.addWidget(indexCity_text)
address_layoutBox.addWidget(address_label)
address_layoutBox.addWidget(address_text)
address_groupbox = QtGui.QGroupBox(u"Адрес",self)
address_groupbox.setLayout( address_layoutBox)
address_groupbox.show()
vertbox = QtGui.QGridLayout(self)
vertbox.setColumnMinimumWidth(1,0)
vertbox.addWidget(general_groupbox,0,0)
vertbox.addWidget(personal_groupbox,0,1,1,50)
vertbox.addWidget(address_groupbox,1,0,10,50)
self.udpSocket = QtNetwork.QUdpSocket()
self.udpSocket.bind(14541)
self.udpSocket.readyRead.connect(self.recieveCall)
def recieveCall(self):
# self.title_text.setText(self.udpSocket.readDatagram())
while self.udpSocket.hasPendingDatagrams():
datagram, host, port = self.udpSocket.readDatagram(self.udpSocket.pendingDatagramSize())
try:
datagram = str(datagram, encoding='ascii')
except TypeError:
pass
data = datagram.split(',')
phone = data[0]
self.customer_id = data[1]
self.call_id = data[2]
self.phone_text.setText(phone)
self.apex_button.show()
self.crm_button.show()
self.title_text.setText(self.getCustomer(self.customer_id))
def getCustomer(self,customer_id):
db = MySQLdb.connect(host="10.36.100.245",user="******", passwd="tcaadmin36", db="sugarcrm")
cursormsql = db.cursor()
db.set_character_set('utf8')
cursormsql.execute('SET NAMES utf8;')
cursormsql.execute('SET CHARACTER SET utf8;')
cursormsql.execute('SET character_set_connection=utf8;')
cursormsql.execute("""SELECT name FROM accounts WHERE id = %s""" ,(customer_id,))
results = cursormsql.fetchone()
return unicode(results[0],"utf-8")
# webbrowser.open("http://tca-db1.astrakhan.businesscar.ru:8080/apex/f?p=999:1:0::NO:1:P1_ID_CUSTOMER:"+self.customer_id)
def closeEvent(self, event):
reply = QtGui.QMessageBox.question(self, u'Сообщение',u"Вы действительно хотите выйти?", QtGui.QMessageBox.Yes |
QtGui.QMessageBox.No, QtGui.QMessageBox.No)
if reply == QtGui.QMessageBox.Yes:
event.accept()
else:
self.icon.show()
self.hide()
event.ignore()
def activate(self,reason ):
# print reason
if reason==2:
self.show()
def __icon_activated(self, reason):
if reason == QtGui.QSystemTrayIcon.DoubleClick:
self.show()
class MainUI(QMainWindow):
"""Main UI."""
def __init__(self, app_quit):
super(MainUI, self).__init__()
self.app_quit = app_quit
self.wifi = WifiInterfaces()
logger.debug("Main UI started ok")
self.sti = None
self.load_icons()
self.iconize()
self.wifi.connect_signals(self.refresh_menu_items, self.update_connected_state)
#QtCore.QTimer.singleShot(1500, self.timer)
#def timer(self):
#print("Hello madafaka")
#QtCore.QTimer.singleShot(1500, self.start)
def open_about_dialog(self):
"""Show the about dialog."""
QMessageBox.about(self, "WeFreed networks Inc.", ABOUT_TEXT)
def icon_for_signal(self, signal):
level_index = bisect(SIGNAL_BREAKPOINTS, signal.level)
if signal.has_db_passwords():
icons = self.icons['wefree']
else:
if signal.encrypted:
lock = 'lock-'
else:
lock = ''
if not signal.encrypted or signal.has_password():
icons = self.icons[lock+'signals']
else:
icons = self.icons['lock-signals-unknown']
return icons[SIGNALS_IMGS[level_index]]
def build_menu(self, signals):
"""Build the menu."""
def action_cmp(a,b):
aText = a.text().upper()
bText = b.text().upper()
if aText == bText: return 0
if aText < bText: return -1
return 1
menu = QMenu(self)
connected = False
# the signals
signal_actions = []
for signal in signals:
icon = self.icon_for_signal(signal)
if signal.is_connected():
connected = True
when_triggered = (lambda sign: lambda:self.please_connect(sign))(signal)
action = QAction(icon, signal.ssid, self, triggered = when_triggered)
signal_actions.append(action)
signal_actions.sort(cmp = action_cmp)
menu.addActions(signal_actions)
self.update_connected_state(connected)
# the bottom part
menu.addSeparator()
menu.addAction(QAction("Share...", self, triggered=self.share_keys))
menu.addAction(QAction("Update Database", self, triggered=self.update_database))
menu.addAction(QAction("Rescan", self, triggered=self.rescan_networks))
menu.addAction(QAction("Quit", self, triggered=self.app_quit))
menu.addAction(QAction("WTF?", self, triggered=self.open_about_dialog))
return menu
def please_connect(self, signal):
logger.debug("Requested connection %s" % signal.ssid)
if not signal.has_password() and signal.encrypted:
self.get_password_for(signal)
else:
self.wifi.connect(signal)
def get_password_for(self, signal):
logger.debug("Need password for %s" % signal.ssid)
d = AddPasswordDialog(self, self.wifi, signal)
d.show()
def share_keys(self):
to_commit = self.wifi.get_known_networks()
to_commit = ShareOwnPasswords(self, to_commit).exec_()
for ap in to_commit:
PM.add_new_ap(ap)
PM.report_success_ap(ap, auto_location = False)
def rescan_networks(self):
self.wifi.force_rescan()
def refresh_menu_items(self, *args):
"""Refresh."""
signals = self.wifi.get_signals()
menu = self.build_menu(signals)
self.sti.setContextMenu(menu)
bssids = [signal.bssid for signal in signals]
GEO.refresh_seen_bssids(bssids)
update_done_signal = QtCore.pyqtSignal()
def update_database(self):
class UpdateFromServerTask(QtCore.QThread):
update_done_signal = self.update_done_signal
def run(self):
PM.get_passwords_from_server()
self.update_done_signal.emit()
self.update_done_signal.connect(self.update_database_done)
self.update_task = UpdateFromServerTask()
self.update_task.start()
def update_database_done(self):
self.refresh_menu_items()
self.update_task = None
def load_icons(self):
self.icons = dict()
self.icons['wefree'] = dict()
self.icons['signals'] = dict()
self.icons['lock-signals'] = dict()
self.icons['lock-signals-unknown'] = dict()
for strength in SIGNALS_IMGS:
self.icons['wefree'][strength] = QIcon(":/imgs/wefree-192.%d.png" % strength)
self.icons['signals'][strength] = QIcon(":/imgs/signals.%d.png" % strength)
self.icons['lock-signals'][strength] = QIcon(":/imgs/lock-signals.%d.png" % strength)
self.icons['lock-signals-unknown'][strength] = QIcon(":/imgs/lock-signals-unknown.%d.png" % strength)
def iconize(self):
"""Show a system tray icon with a small icon."""
self.sti = QSystemTrayIcon(self.icons['wefree'][0], self)
if not self.sti.isSystemTrayAvailable():
logger.warning("System tray not available.")
return
self.refresh_menu_items()
self.sti.show()
def update_connected_state(self, connected):
if connected:
self.sti.setIcon(self.icons['wefree'][100])
else:
self.sti.setIcon(self.icons['wefree'][0])
class Qt4SysTrayIcon:
def __init__( self ):
self.snapshots = snapshots.Snapshots()
self.config = self.snapshots.config
self.decode = None
if len( sys.argv ) > 1:
if not self.config.set_current_profile(sys.argv[1]):
logger.warning("Failed to change Profile_ID %s"
%sys.argv[1], self)
self.qapp = qt4tools.create_qapplication(self.config.APP_NAME)
translator = qt4tools.get_translator()
self.qapp.installTranslator(translator)
self.qapp.setQuitOnLastWindowClosed(False)
import icon
self.icon = icon
self.qapp.setWindowIcon(icon.BIT_LOGO)
self.status_icon = QSystemTrayIcon(icon.BIT_LOGO)
#self.status_icon.actionCollection().clear()
self.contextMenu = QMenu()
self.menuProfileName = self.contextMenu.addAction(_('Profile: "%s"') % self.config.get_profile_name())
qt4tools.set_font_bold(self.menuProfileName)
self.contextMenu.addSeparator()
self.menuStatusMessage = self.contextMenu.addAction(_('Done'))
self.menuProgress = self.contextMenu.addAction('')
self.menuProgress.setVisible(False)
self.contextMenu.addSeparator()
self.btnDecode = self.contextMenu.addAction(icon.VIEW_SNAPSHOT_LOG, _('decode paths'))
self.btnDecode.setCheckable(True)
self.btnDecode.setVisible(self.config.get_snapshots_mode() == 'ssh_encfs')
QObject.connect(self.btnDecode, SIGNAL('toggled(bool)'), self.onBtnDecode)
self.openLog = self.contextMenu.addAction(icon.VIEW_LAST_LOG, _('View Last Log'))
QObject.connect(self.openLog, SIGNAL('triggered()'), self.onOpenLog)
self.startBIT = self.contextMenu.addAction(icon.BIT_LOGO, _('Start BackInTime'))
QObject.connect(self.startBIT, SIGNAL('triggered()'), self.onStartBIT)
self.status_icon.setContextMenu(self.contextMenu)
self.pixmap = icon.BIT_LOGO.pixmap(24)
self.progressBar = QProgressBar()
self.progressBar.setMinimum(0)
self.progressBar.setMaximum(100)
self.progressBar.setValue(0)
self.progressBar.setTextVisible(False)
self.progressBar.resize(24, 6)
self.progressBar.render(self.pixmap, sourceRegion = QRegion(0, -14, 24, 6), flags = QWidget.RenderFlags(QWidget.DrawChildren))
self.first_error = self.config.is_notify_enabled()
self.popup = None
self.last_message = None
self.timer = QTimer()
QObject.connect( self.timer, SIGNAL('timeout()'), self.update_info )
self.ppid = os.getppid()
def prepare_exit( self ):
self.timer.stop()
if not self.status_icon is None:
self.status_icon.hide()
self.status_icon = None
if not self.popup is None:
self.popup.deleteLater()
self.popup = None
self.qapp.processEvents()
def run( self ):
self.status_icon.show()
self.timer.start( 500 )
logger.info("[qt4systrayicon] begin loop", self)
self.qapp.exec_()
logger.info("[qt4systrayicon] end loop", self)
self.prepare_exit()
def update_info( self ):
if not tools.is_process_alive( self.ppid ):
self.prepare_exit()
self.qapp.exit(0)
return
message = self.snapshots.get_take_snapshot_message()
if message is None and self.last_message is None:
message = ( 0, _('Working...') )
if not message is None:
if message != self.last_message:
self.last_message = message
if self.decode:
message = (message[0], self.decode.log(message[1]))
self.menuStatusMessage.setText('\n'.join(tools.wrap_line(message[1],\
size = 80,\
delimiters = '',\
new_line_indicator = '') \
))
self.status_icon.setToolTip(message[1])
pg = progress.ProgressFile(self.config)
if pg.isFileReadable():
pg.load()
percent = pg.get_int_value('percent')
if percent != self.progressBar.value():
self.progressBar.setValue(percent)
self.progressBar.render(self.pixmap, sourceRegion = QRegion(0, -14, 24, 6), flags = QWidget.RenderFlags(QWidget.DrawChildren))
self.status_icon.setIcon(QIcon(self.pixmap))
self.menuProgress.setText(' | '.join(self.getMenuProgress(pg)) )
self.menuProgress.setVisible(True)
else:
self.status_icon.setIcon(self.icon.BIT_LOGO)
self.menuProgress.setVisible(False)
def getMenuProgress(self, pg):
d = (('sent', _('Sent:')), \
('speed', _('Speed:')),\
('eta', _('ETA:')) )
for key, txt in d:
value = pg.get_str_value(key, '')
if not value:
continue
yield txt + ' ' + value
def onStartBIT(self):
profileID = self.config.get_current_profile()
cmd = ['backintime-qt4',]
if not profileID == '1':
cmd += ['--profile-id', profileID]
proc = subprocess.Popen(cmd)
def onOpenLog(self):
dlg = logviewdialog.LogViewDialog(self, systray = True)
dlg.decode = self.decode
dlg.cb_decode.setChecked(self.btnDecode.isChecked())
dlg.exec_()
def onBtnDecode(self, checked):
if checked:
self.decode = encfstools.Decode(self.config)
self.last_message = None
self.update_info()
else:
self.decode = None
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 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 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 Example(QtGui.QMainWindow):
def __init__(self):
super(Example, self).__init__()
self.path=sys.path[0]
f=open('%s/ACCESS_KEY'% self.path,'r')
f1=open('%s/ACCESS_SECRET'% self.path,'r')
f2=open('%s/user_info'% self.path)
self.user_name=f2.readline().strip('\n')
self.user_id=f2.readline().strip('\n')
self.a=f.readline().strip('\n')
self.b=f1.readline().strip('\n')
f.close()
f1.close()
f2.close()
self.initUI()
def initUI(self):
self.icon=QSystemTrayIcon()
self.icon.isSystemTrayAvailable()
self.icon.setIcon( QtGui.QIcon('%s/web.png'% self.path) )
self.icon.setToolTip ( 'dubbleclick to maximize')
self.icon.show()
self.icon.activated.connect(self.activate)
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground)
self.setGeometry(300, 300, 1500, 1000)
frame = QtGui.QFrame(parent=self)
frame.setStyleSheet("QFrame {background: rgba(0,0,0,50%)}")
box=QtGui.QHBoxLayout()
self.edit = QtGui.QLineEdit()
self.edit.setStyleSheet("background: rgba(0,0,0,100%); "" font-weight : bold;" "color: rgb(250,250,250);""border:5px solid ")
self.edit.setToolTip('please <b>Enter your tweet here </b> ')
self.edit.returnPressed.connect(self.returnPressed)
box.addWidget(self.edit)
frame.setLayout(box)
qbtn1 = QtGui.QPushButton('quit', self)
qbtn1.clicked.connect(self.close)
qbtn1.setStyleSheet( "background: rgba(0,0,0,100%); "" font-weight : bold;" "color: rgb(250,250,250);""border:5px solid ")
box.addWidget(qbtn1)
self.statusBar().setStyleSheet("background: rgba(0,0,0,100%);"" font-weight : bold;" "color: rgb(250,250,250)")
self.statusBar().showMessage('Press Enter to send Tweet and press ESC to minimize to tray ')
self.setCentralWidget(frame)
self.setWindowIcon(QtGui.QIcon('%s/web.png' % self. path))
self.setWindowTitle('Tweet Fast ')
self.center()
self.show()
self.twitter_auth()
def twitter_auth(self):
CONSUMER_KEY = 'VQLDtkDTlbAmT95m5cMsYQ'
CONSUMER_SECRET = 'bAC0BF69qiEVARJlfFJZZCDQ9mrcqofq16ilQ4OjU'
ACCESS_KEY=self.a
ACCESS_SECRET=self.b
self.auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
self.auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)
def keyPressEvent(self, e):
if e.key() == QtCore.Qt.Key_Escape:
print 'Escape wass pressed '
self.icon.show()
self.hide()
def activate(self,reason ):
print reason
if reason==2:
self.show()
def center(self):
qr = self.frameGeometry()
cp = QtGui.QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def returnPressed(self):
path=sys.path[0]
tweet = self.edit.text()
api = tweepy.API(self.auth)
self.statusBar().showMessage('Sending... ')
api.update_status(tweet)
self.statusBar().showMessage('Your Tweet was send ')
n = pynotify.Notification(" @ %s "% self.user_name , "your tweet was send ","%s/%s.jpg" % (path,self.user_id))
n.set_hint('x', 200)
n.set_hint('y', 400)
pynotify.init('n')
n.show()
self.statusBar().showMessage('Press Enter to send Tweet and press ESC to minimize to tray ')
self.edit.clear()
class MainWindow(QMainWindow, Ui_MainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setupUi(self)
self._init_menu()
self._init_actions()
self._init_models()
self.lt = ListenThread(self.add_new_device)
self._install_akmods = False
self._main_pko = PackageKitQt()
# right frame
self.comboBoxModules.currentIndexChanged.connect(self._handle_select_module)
self.buttonBoxDetails.clicked.connect(self._handle_rbb)
self.__debug_mode__ = True
self.trayIcon = QSystemTrayIcon(self)
self.trayIcon.setIcon(QIcon(":/img/gears"))
self.trayIcon.activated.connect(self._handle_tray_icon_activate)
self.hide()
def closeEvent(self, event):
event.ignore()
self.hide()
def _init_menu(self):
self.actionFileExit.triggered.connect(self._handle_exit)
self.listView.setContextMenuPolicy(Qt.ActionsContextMenu)
self.listViewActions.setContextMenuPolicy(Qt.ActionsContextMenu)
# context menu for listView
for act in self.menuDevices.actions():
self.listView.addAction(act)
# context menu for listViewActions
for act in self.menuActions.actions():
self.listViewActions.addAction(act)
def _init_actions(self):
self.actionDevicesDisable.triggered.connect(self._handle_disable_device)
self.actionDevicesDisableAll.triggered.connect(self._handle_disable_all)
self.actionActionsDelete.triggered.connect(self._handle_remove_current_action)
self.actionActionsClear.triggered.connect(self._handle_clean_actions)
self.actionActionsApply.triggered.connect(self._handle_apply_actions)
def _init_models(self):
self.model = DevicesListModel(self)
self.listView.setModel(self.model)
self.listView.selectionModel().currentChanged.connect(self._handle_select_item)
self.act_model = ActionsModel(self)
self.listViewActions.setModel(self.act_model)
self.listViewActions.selectionModel().currentChanged.connect(self._handle_action_select_item)
self.act_model.actionDeleted.connect(self.model.reset_changes)
self.model.dataChanged.connect(self._handle_data_changed_in_model)
def _init_pk(self):
if self._main_pko is None:
self._main_pko = PackageKitQt()
def add_new_device(self, dev):
self.model.add_new_device(dev)
self.show_notification()
def disen_device_notif(self, device_id, disable=False):
if disable:
self.lt.disable_device_notif(device_id)
else:
self.lt.enable_device_notif(device_id)
def show_notification(self):
# if self.isHidden():
# self.show()
self.trayIcon.setVisible(True)
def start_listen(self):
self.lt.start()
def _right_frame_apply(self, idx):
d = self.model.device_by_index(idx)
sel_cb_idx = self.comboBoxModules.currentIndex()
sel_module = str(self.comboBoxModules.itemData(sel_cb_idx).toString())
if sel_module == d.current_driver():
return
self.act_model.remove_actions_by_devid(d.device_id(), sel_module)
pkgsi = d.packages_to_install(sel_module)
pkgsr = d.packages_to_remove(sel_module)
if len(pkgsi) > 0:
self.act_model.add_new_action(d.device_id(), sel_module, pkgsi, 0)
if len(pkgsr) > 0:
rem_mds = str(", ").join(d.device_modules(sel_module))
self.act_model.add_new_action(d.device_id(), rem_mds, pkgsr, 1)
d.set_selected_driver(sel_module)
self.set_right_frame(idx)
def _current_device(self, idx=None):
cur_idx = idx
if idx is None:
cur_idx = self.listView.selectionModel().currentIndex()
return self.model.device_by_index(cur_idx)
def set_right_frame(self, idx):
self.comboBoxModules.clear()
d = self._current_device(idx)
curdrv = QString()
if d.current_driver() is None or len(d.current_driver()) == 0:
curdrv = self.tr("Not installed")
else:
curdrv = QString("- %s -" % d.current_driver())
self.comboBoxModules.addItem(curdrv, QString(d.current_driver()))
self.lineEditName.setText(d.device_name())
our_sel_idx = -1
for m in d.device_modules():
devmod = QString()
if m == d.current_driver():
continue
elif m == d.selected_driver():
devmod = QString("* %s *" % m)
our_sel_idx = self.comboBoxModules.count()
else:
devmod = QString("%s" % m)
self.comboBoxModules.addItem(devmod, QString(m))
if our_sel_idx != -1:
self.comboBoxModules.setCurrentIndex(our_sel_idx)
def _do_resolve_packages(self, pkgs, to_remove=False):
if len(pkgs) == 0:
return []
self.debug_print(pkgs)
self._init_pk()
pkc = self._main_pko.getTransaction()
pkc.SetHints()
filt = "none"
if to_remove:
filt = "installed"
pkc.SearchNames(filt, pkgs)
if pkc.has_error():
return []
pkg_ids = pkc.get_package_ids()
return pkg_ids
pkc.Resolve(filt, pkgs)
if pkc.has_error():
return []
pkg_ids = pkc.get_package_ids()
return pkg_ids
def _do_install_packages(self, pkgs):
if len(pkgs) == 0:
return
print "Begin install packages"
self._init_pk()
pkc = self._main_pko.getTransaction() # PackageKitClient()
pkc.SetHints()
pkc.InstallPackages(False, pkgs)
if pkc.has_error():
err_code, err_msg = pkc.error()
self.debug_print("Error: [%s] %s" % (err_code, err_msg))
def _do_remove_packages(self, pkgs):
if len(pkgs) == 0:
return
print "Begin remove packages"
self._init_pk()
pkc = self._main_pko.getTransaction()
pkc.RemovePackages(pkgs, True, True)
if pkc.has_error():
err_code, err_msg = pkc.error()
self.debug_print("Error: [%s] %s" % (err_code, err_msg))
def _do_only_ids(self, pkgs):
res_ids = []
if pkgs is None:
return res_ids
if len(pkgs) == 0:
return res_ids
print pkgs
for installed, id, summary in pkgs:
res_ids.append(id)
return res_ids
def _debug_print_pkg_ids(self, pkg_ids):
if pkg_ids is None:
return
elif len(pkg_ids) == 0:
return
for pkg_id in pkg_ids:
self.debug_print("+ Installed: %s" % (pkg_id))
def _do_act(self):
pkgs_to_install, pkgs_to_remove = self.act_model.get_packages(self._install_akmods)
if len(pkgs_to_install) + len(pkgs_to_remove) == 0:
QMessageBox.information(self, self.tr("Empty actions"), self.tr("Nothing to install/remove"))
return
# Resolve all packages
pkg_ids_install = self._do_resolve_packages(pkgs_to_install)
pkg_ids_remove = self._do_resolve_packages(pkgs_to_remove, True)
self.debug_print("To install: %s" % pkg_ids_install)
self.debug_print("To remove: %s" % pkg_ids_remove)
self._do_remove_packages(pkg_ids_remove)
self._do_install_packages(pkg_ids_install)
print "Packages to install:"
self._debug_print_pkg_ids(pkg_ids_install)
print "Packages to remove:"
self._debug_print_pkg_ids(pkg_ids_remove)
res = QMessageBox.question(
self,
self.tr("Operations done"),
self.tr("All operations applied. You may reboot a system. Reboot now?"),
QMessageBox.Yes and QMessageBox.No,
QMessageBox.Yes,
)
if res == QMessageBox.Yes:
print "rebooting"
def debug_print(self, msg):
if not self.__debug_mode__:
return
print (msg)
# slots
def _handle_data_changed_in_model(self, begin_idx, end_idx):
cur_idx = self.listView.selectionModel().currentIndex()
if not cur_idx.isValid():
return
cur_row = cur_idx.row()
row_range = range(begin_idx.row(), end_idx.row())
if len(row_range) == 0:
row_range = [begin_idx.row()]
if cur_row in row_range:
self.set_right_frame(cur_idx)
def _handle_remove_current_action(self):
cur_idx = self.listViewActions.selectionModel().currentIndex()
self.act_model.removeRows(cur_idx.row(), 1)
def _handle_clean_actions(self):
self.act_model.clearRows()
def _handle_disable_all(self):
devs = self.model.disable_all_devices()
self.disen_device_notif(devs, True)
self.trayIcon.hide()
def _handle_disable_device(self):
cur_idx = self.listView.selectionModel().currentIndex()
this_is_hide_item = self.model.index_is_hide(cur_idx)
need_id = self.model.index_hide(cur_idx, not this_is_hide_item)
self._handle_select_item(cur_idx, cur_idx)
self.disen_device_notif(need_id, not this_is_hide_item)
def _handle_exit(self):
self.hide()
def _handle_action_select_item(self, cur_idx, prev_idx):
self.actionActionsDelete.setEnabled(cur_idx.isValid())
def _handle_select_item(self, current_idx, prev_idx):
self.actionDevicesDisable.setEnabled(current_idx.isValid())
if not current_idx.isValid():
return
if self.model.index_is_hide(current_idx):
self.actionDevicesDisable.setText(self.tr("&Enable notification"))
else:
self.actionDevicesDisable.setText(self.tr("&Disable notification"))
self.set_right_frame(current_idx)
def _handle_rbb(self, but):
cur_idx = self.listView.selectionModel().currentIndex()
if self.buttonBoxDetails.buttonRole(but) == QDialogButtonBox.ResetRole:
self.set_right_frame(cur_idx)
elif self.buttonBoxDetails.buttonRole(but) == QDialogButtonBox.ApplyRole:
self._right_frame_apply(cur_idx)
def _handle_select_module(self, module_index):
if module_index == -1:
self.labelDetails.setText("")
return
selection_module_name = str(self.comboBoxModules.itemData(module_index).toString())
d = self._current_device()
pkgsi = d.packages_to_install(selection_module_name)
pkgsr = d.packages_to_remove(selection_module_name)
detail_html = QString("<h4>%1 </h4>").arg(self.tr("For installing this module need:"))
if len(pkgsi) > 0:
detail_html += QString("<p>%1 <ul>").arg(self.tr("Packages to install:"))
for p in pkgsi:
detail_html += QString("<li>%1</li>").arg(p)
detail_html += QString("</ul></p>")
if len(pkgsr) > 0:
detail_html += QString("<p>%1 <ul>").arg(self.tr("Packages to remove: "))
for p in pkgsr:
detail_html += QString("<li>%1</li>").arg(p)
detail_html += QString("</ul></p>")
self.labelDetails.setText(detail_html)
def _handle_apply_actions(self):
if self.act_model.pkgs_to_install_exist():
result = QMessageBox.question(
self,
self.tr("Install akmods too"),
self.tr("Do you have install also akmod (automated kernel module) packages too?"),
QMessageBox.Yes and QMessageBox.No,
QMessageBox.Yes,
)
if result == QMessageBox.Yes:
self._install_akmods = True
self.setEnabled(False)
self._do_act()
self.setEnabled(True)
def _handle_tray_icon_activate(self, reason):
if self.isHidden():
self.show()
else:
self.hide()
class GlobalSysTray(object):
def __init__(self, parent, name, icon):
object.__init__(self)
self._app = None
self._parent = parent
self._gtk_running = False
self._quit_added = False
self.act_indexes = []
self.sep_indexes = []
self.menu_indexes = []
if TrayEngine == "KDE":
self.menu = KMenu(parent)
self.menu.setTitle(name)
self.tray = KStatusNotifierItem()
self.tray.setAssociatedWidget(parent)
self.tray.setCategory(KStatusNotifierItem.ApplicationStatus)
self.tray.setContextMenu(self.menu)
self.tray.setIconByPixmap(getIcon(icon))
self.tray.setTitle(name)
self.tray.setToolTipTitle(" ")
self.tray.setToolTipIconByPixmap(getIcon(icon))
# Double-click is managed by KDE
elif TrayEngine == "AppIndicator":
self.menu = Gtk.Menu()
self.tray = AppIndicator.Indicator.new(name, icon, AppIndicator.IndicatorCategory.APPLICATION_STATUS)
self.tray.set_menu(self.menu)
# Double-click is not possible with App-Indicators
elif TrayEngine == "Qt":
self.menu = QMenu(parent)
self.tray = QSystemTrayIcon(getIcon(icon))
self.tray.setContextMenu(self.menu)
self.tray.setParent(parent)
self.tray.connect(self.tray, SIGNAL("activated(QSystemTrayIcon::ActivationReason)"), self.qt_systray_clicked)
# -------------------------------------------------------------------------------------------
def addAction(self, act_name_id, act_name_string, is_check=False):
if TrayEngine == "KDE":
act_widget = KAction(act_name_string, self.menu)
act_widget.setCheckable(is_check)
self.menu.addAction(act_widget)
elif TrayEngine == "AppIndicator":
if is_check:
act_widget = Gtk.CheckMenuItem(act_name_string)
else:
act_widget = Gtk.ImageMenuItem(act_name_string)
act_widget.set_image(None)
act_widget.show()
self.menu.append(act_widget)
elif TrayEngine == "Qt":
act_widget = QAction(act_name_string, self.menu)
act_widget.setCheckable(is_check)
self.menu.addAction(act_widget)
else:
act_widget = None
act_obj = [None, None, None, None]
act_obj[iActNameId] = act_name_id
act_obj[iActWidget] = act_widget
self.act_indexes.append(act_obj)
def addSeparator(self, sep_name_id):
if TrayEngine == "KDE":
sep_widget = self.menu.addSeparator()
elif TrayEngine == "AppIndicator":
sep_widget = Gtk.SeparatorMenuItem()
sep_widget.show()
self.menu.append(sep_widget)
elif TrayEngine == "Qt":
sep_widget = self.menu.addSeparator()
else:
sep_widget = None
sep_obj = [None, None, None]
sep_obj[iSepNameId] = sep_name_id
sep_obj[iSepWidget] = sep_widget
self.sep_indexes.append(sep_obj)
def addMenu(self, menu_name_id, menu_name_string):
if TrayEngine == "KDE":
menu_widget = KMenu(menu_name_string, self.menu)
self.menu.addMenu(menu_widget)
elif TrayEngine == "AppIndicator":
menu_widget = Gtk.MenuItem(menu_name_string)
menu_parent = Gtk.Menu()
menu_widget.set_submenu(menu_parent)
menu_widget.show()
self.menu.append(menu_widget)
elif TrayEngine == "Qt":
menu_widget = QMenu(menu_name_string, self.menu)
self.menu.addMenu(menu_widget)
else:
menu_widget = None
menu_obj = [None, None, None]
menu_obj[iMenuNameId] = menu_name_id
menu_obj[iMenuWidget] = menu_widget
self.menu_indexes.append(menu_obj)
# -------------------------------------------------------------------------------------------
def addMenuAction(self, menu_name_id, act_name_id, act_name_string, is_check=False):
i = self.get_menu_index(menu_name_id)
if i < 0: return
menu_widget = self.menu_indexes[i][iMenuWidget]
if TrayEngine == "KDE":
act_widget = KAction(act_name_string, menu_widget)
act_widget.setCheckable(is_check)
menu_widget.addAction(act_widget)
elif TrayEngine == "AppIndicator":
menu_widget = menu_widget.get_submenu()
if is_check:
act_widget = Gtk.CheckMenuItem(act_name_string)
else:
act_widget = Gtk.ImageMenuItem(act_name_string)
act_widget.set_image(None)
act_widget.show()
menu_widget.append(act_widget)
elif TrayEngine == "Qt":
act_widget = QAction(act_name_string, menu_widget)
act_widget.setCheckable(is_check)
menu_widget.addAction(act_widget)
else:
act_widget = None
act_obj = [None, None, None, None]
act_obj[iActNameId] = act_name_id
act_obj[iActWidget] = act_widget
act_obj[iActParentMenuId] = menu_name_id
self.act_indexes.append(act_obj)
def addMenuSeparator(self, menu_name_id, sep_name_id):
i = self.get_menu_index(menu_name_id)
if i < 0: return
menu_widget = self.menu_indexes[i][iMenuWidget]
if TrayEngine == "KDE":
sep_widget = menu_widget.addSeparator()
elif TrayEngine == "AppIndicator":
menu_widget = menu_widget.get_submenu()
sep_widget = Gtk.SeparatorMenuItem()
sep_widget.show()
menu_widget.append(sep_widget)
elif TrayEngine == "Qt":
sep_widget = menu_widget.addSeparator()
else:
sep_widget = None
sep_obj = [None, None, None]
sep_obj[iSepNameId] = sep_name_id
sep_obj[iSepWidget] = sep_widget
sep_obj[iSepParentMenuId] = menu_name_id
self.sep_indexes.append(sep_obj)
#def addSubMenu(self, menu_name_id, new_menu_name_id, new_menu_name_string):
#menu_index = self.get_menu_index(menu_name_id)
#if menu_index < 0: return
#menu_widget = self.menu_indexes[menu_index][1]
##if TrayEngine == "KDE":
##new_menu_widget = KMenu(new_menu_name_string, self.menu)
##menu_widget.addMenu(new_menu_widget)
##elif TrayEngine == "AppIndicator":
##new_menu_widget = Gtk.MenuItem(new_menu_name_string)
##new_menu_widget.show()
##menu_widget.get_submenu().append(new_menu_widget)
##parent_menu_widget = Gtk.Menu()
##new_menu_widget.set_submenu(parent_menu_widget)
##else:
#if (1):
#new_menu_widget = QMenu(new_menu_name_string, self.menu)
#menu_widget.addMenu(new_menu_widget)
#self.menu_indexes.append([new_menu_name_id, new_menu_widget, menu_name_id])
# -------------------------------------------------------------------------------------------
def connect(self, act_name_id, act_func):
i = self.get_act_index(act_name_id)
if i < 0: return
act_widget = self.act_indexes[i][iActWidget]
if TrayEngine == "KDE":
self.tray.connect(act_widget, SIGNAL("triggered()"), act_func)
elif TrayEngine == "AppIndicator":
act_widget.connect("activate", self.gtk_call_func, act_name_id)
elif TrayEngine == "Qt":
self.tray.connect(act_widget, SIGNAL("triggered()"), act_func)
self.act_indexes[i][iActFunc] = act_func
# -------------------------------------------------------------------------------------------
#def setActionChecked(self, act_name_id, yesno):
#index = self.get_act_index(act_name_id)
#if index < 0: return
#act_widget = self.act_indexes[index][1]
##if TrayEngine == "KDE":
##act_widget.setChecked(yesno)
##elif TrayEngine == "AppIndicator":
##if type(act_widget) != Gtk.CheckMenuItem:
##return # Cannot continue
##act_widget.set_active(yesno)
##else:
#if (1):
#act_widget.setChecked(yesno)
def setActionEnabled(self, act_name_id, yesno):
i = self.get_act_index(act_name_id)
if i < 0: return
act_widget = self.act_indexes[i][iActWidget]
if TrayEngine == "KDE":
act_widget.setEnabled(yesno)
elif TrayEngine == "AppIndicator":
act_widget.set_sensitive(yesno)
elif TrayEngine == "Qt":
act_widget.setEnabled(yesno)
def setActionIcon(self, act_name_id, icon):
i = self.get_act_index(act_name_id)
if i < 0: return
act_widget = self.act_indexes[i][iActWidget]
if TrayEngine == "KDE":
act_widget.setIcon(KIcon(icon))
elif TrayEngine == "AppIndicator":
if not isinstance(act_widget, Gtk.ImageMenuItem):
# Cannot use icons here
return
act_widget.set_image(Gtk.Image.new_from_icon_name(icon, Gtk.IconSize.MENU))
#act_widget.set_always_show_image(True)
elif TrayEngine == "Qt":
act_widget.setIcon(getIcon(icon))
def setActionText(self, act_name_id, text):
i = self.get_act_index(act_name_id)
if i < 0: return
act_widget = self.act_indexes[i][iActWidget]
if TrayEngine == "KDE":
act_widget.setText(text)
elif TrayEngine == "AppIndicator":
if isinstance(act_widget, Gtk.ImageMenuItem):
# Fix icon reset
last_icon = act_widget.get_image()
act_widget.set_label(text)
act_widget.set_image(last_icon)
else:
act_widget.set_label(text)
elif TrayEngine == "Qt":
act_widget.setText(text)
def setIcon(self, icon):
if TrayEngine == "KDE":
self.tray.setIconByPixmap(getIcon(icon))
#self.tray.setToolTipIconByPixmap(getIcon(icon))
elif TrayEngine == "AppIndicator":
self.tray.set_icon(icon)
elif TrayEngine == "Qt":
self.tray.setIcon(getIcon(icon))
def setToolTip(self, text):
if TrayEngine == "KDE":
self.tray.setToolTipSubTitle(text)
elif TrayEngine == "AppIndicator":
# ToolTips are disabled in App-Indicators by design
pass
elif TrayEngine == "Qt":
self.tray.setToolTip(text)
# -------------------------------------------------------------------------------------------
#def removeAction(self, act_name_id):
#index = self.get_act_index(act_name_id)
#if index < 0: return
#act_widget = self.act_indexes[index][1]
#parent_menu_widget = self.get_parent_menu_widget(self.act_indexes[index][2])
##if TrayEngine == "KDE":
##parent_menu_widget.removeAction(act_widget)
##elif TrayEngine == "AppIndicator":
##act_widget.hide()
##parent_menu_widget.remove(act_widget)
##else:
#if (1):
#parent_menu_widget.removeAction(act_widget)
#self.act_indexes.pop(index)
#def removeSeparator(self, sep_name_id):
#index = self.get_sep_index(sep_name_id)
#if index < 0: return
#sep_widget = self.sep_indexes[index][1]
#parent_menu_widget = self.get_parent_menu_widget(self.sep_indexes[index][2])
##if TrayEngine == "KDE":
##parent_menu_widget.removeAction(sep_widget)
##elif TrayEngine == "AppIndicator":
##sep_widget.hide()
##parent_menu_widget.remove(sep_widget)
##else:
#if (1):
#parent_menu_widget.removeAction(sep_widget)
#self.sep_indexes.pop(index)
#def removeMenu(self, menu_name_id):
#index = self.get_menu_index(menu_name_id)
#if index < 0: return
#menu_widget = self.menu_indexes[index][1]
#parent_menu_widget = self.get_parent_menu_widget(self.menu_indexes[index][2])
##if TrayEngine == "KDE":
##parent_menu_widget.removeAction(menu_widget.menuAction())
##elif TrayEngine == "AppIndicator":
##menu_widget.hide()
##parent_menu_widget.remove(menu_widget.get_submenu())
##else:
#if (1):
#parent_menu_widget.removeAction(menu_widget.menuAction())
#self.remove_actions_by_menu_name_id(menu_name_id)
#self.remove_separators_by_menu_name_id(menu_name_id)
#self.remove_submenus_by_menu_name_id(menu_name_id)
# -------------------------------------------------------------------------------------------
#def clearAll(self):
##if TrayEngine == "KDE":
##self.menu.clear()
##elif TrayEngine == "AppIndicator":
##for child in self.menu.get_children():
##self.menu.remove(child)
##else:
#if (1):
#self.menu.clear()
#self.act_indexes = []
#self.sep_indexes = []
#self.menu_indexes = []
#def clearMenu(self, menu_name_id):
#menu_index = self.get_menu_index(menu_name_id)
#if menu_index < 0: return
#menu_widget = self.menu_indexes[menu_index][1]
##if TrayEngine == "KDE":
##menu_widget.clear()
##elif TrayEngine == "AppIndicator":
##for child in menu_widget.get_submenu().get_children():
##menu_widget.get_submenu().remove(child)
##else:
#if (1):
#menu_widget.clear()
#list_of_submenus = [menu_name_id]
#for x in range(0, 10): # 10x level deep, should cover all cases...
#for this_menu_name_id, menu_widget, parent_menu_id in self.menu_indexes:
#if parent_menu_id in list_of_submenus and this_menu_name_id not in list_of_submenus:
#list_of_submenus.append(this_menu_name_id)
#for this_menu_name_id in list_of_submenus:
#self.remove_actions_by_menu_name_id(this_menu_name_id)
#self.remove_separators_by_menu_name_id(this_menu_name_id)
#self.remove_submenus_by_menu_name_id(this_menu_name_id)
# -------------------------------------------------------------------------------------------
def getTrayEngine(self):
return TrayEngine
def isTrayAvailable(self):
if TrayEngine in ("KDE", "Qt"):
return QSystemTrayIcon.isSystemTrayAvailable()
elif TrayEngine == "AppIndicator":
# Ubuntu/Unity always has a systray
return True
else:
return False
def handleQtCloseEvent(self, event):
if self.isTrayAvailable() and self._parent.isVisible():
event.accept()
self.__hideShowCall()
return
self.close()
QMainWindow.closeEvent(self._parent, event)
# -------------------------------------------------------------------------------------------
def show(self):
if not self._quit_added:
self._quit_added = True
if TrayEngine != "KDE":
self.addSeparator("_quit")
self.addAction("show", self._parent.tr("Minimize"))
self.addAction("quit", self._parent.tr("Quit"))
self.setActionIcon("quit", "application-exit")
self.connect("show", self.__hideShowCall)
self.connect("quit", self.__quitCall)
if TrayEngine == "KDE":
self.tray.setStatus(KStatusNotifierItem.Active)
elif TrayEngine == "AppIndicator":
self.tray.set_status(AppIndicator.IndicatorStatus.ACTIVE)
elif TrayEngine == "Qt":
self.tray.show()
def hide(self):
if TrayEngine == "KDE":
self.tray.setStatus(KStatusNotifierItem.Passive)
elif TrayEngine == "AppIndicator":
self.tray.set_status(AppIndicator.IndicatorStatus.PASSIVE)
elif TrayEngine == "Qt":
self.tray.hide()
def close(self):
if TrayEngine == "KDE":
self.menu.close()
elif TrayEngine == "AppIndicator":
if self._gtk_running:
self._gtk_running = False
Gtk.main_quit()
elif TrayEngine == "Qt":
self.menu.close()
def exec_(self, app):
self._app = app
if TrayEngine == "AppIndicator":
self._gtk_running = True
return Gtk.main()
else:
return app.exec_()
# -------------------------------------------------------------------------------------------
def get_act_index(self, act_name_id):
for i in range(len(self.act_indexes)):
if self.act_indexes[i][iActNameId] == act_name_id:
return i
else:
print("systray.py - Failed to get action index for %s" % act_name_id)
return -1
def get_sep_index(self, sep_name_id):
for i in range(len(self.sep_indexes)):
if self.sep_indexes[i][iSepNameId] == sep_name_id:
return i
else:
print("systray.py - Failed to get separator index for %s" % sep_name_id)
return -1
def get_menu_index(self, menu_name_id):
for i in range(len(self.menu_indexes)):
if self.menu_indexes[i][iMenuNameId] == menu_name_id:
return i
else:
print("systray.py - Failed to get menu index for %s" % menu_name_id)
return -1
#def get_parent_menu_widget(self, parent_menu_id):
#if parent_menu_id != None:
#menu_index = self.get_menu_index(parent_menu_id)
#if menu_index >= 0:
#return self.menu_indexes[menu_index][1]
#else:
#print("systray.py::Failed to get parent Menu widget for", parent_menu_id)
#return None
#else:
#return self.menu
#def remove_actions_by_menu_name_id(self, menu_name_id):
#h = 0
#for i in range(len(self.act_indexes)):
#act_name_id, act_widget, parent_menu_id, act_func = self.act_indexes[i - h]
#if parent_menu_id == menu_name_id:
#self.act_indexes.pop(i - h)
#h += 1
#def remove_separators_by_menu_name_id(self, menu_name_id):
#h = 0
#for i in range(len(self.sep_indexes)):
#sep_name_id, sep_widget, parent_menu_id = self.sep_indexes[i - h]
#if parent_menu_id == menu_name_id:
#self.sep_indexes.pop(i - h)
#h += 1
#def remove_submenus_by_menu_name_id(self, submenu_name_id):
#h = 0
#for i in range(len(self.menu_indexes)):
#menu_name_id, menu_widget, parent_menu_id = self.menu_indexes[i - h]
#if parent_menu_id == submenu_name_id:
#self.menu_indexes.pop(i - h)
#h += 1
# -------------------------------------------------------------------------------------------
def gtk_call_func(self, gtkmenu, act_name_id):
i = self.get_act_index(act_name_id)
if i < 0: return None
return self.act_indexes[i][iActFunc]
def qt_systray_clicked(self, reason):
if reason in (QSystemTrayIcon.DoubleClick, QSystemTrayIcon.Trigger):
self.__hideShowCall()
# -------------------------------------------------------------------------------------------
def __hideShowCall(self):
if self._parent.isVisible():
self.setActionText("show", self._parent.tr("Restore"))
self._parent.hide()
if self._app:
self._app.setQuitOnLastWindowClosed(False)
else:
self.setActionText("show", self._parent.tr("Minimize"))
if self._parent.isMaximized():
self._parent.showMaximized()
else:
self._parent.showNormal()
if self._app:
self._app.setQuitOnLastWindowClosed(True)
QTimer.singleShot(500, self.__raiseWindow)
def __quitCall(self):
if self._app:
self._app.setQuitOnLastWindowClosed(True)
self._parent.hide()
self._parent.close()
def __raiseWindow(self):
self._parent.activateWindow()
self._parent.raise_()
class MainWindow(QMainWindow,Ui_MainWindow):
def __init__(self,parent=None):
QMainWindow.__init__(self,parent)
self.setupUi(self)
self.textshorturl.setEnabled(False)
self.convertprogress.hide()
self.trayIcon = QSystemTrayIcon()
self.trayIcon.setIcon(QIcon("/usr/share/pixmaps/nixiconsvg.svg"))
trayIconMenu = QMenu()
self.appabout = trayIconMenu.addAction("About")
self.appexit = trayIconMenu.addAction("Exit")
self.trayIcon.setContextMenu(trayIconMenu)
self.connect(self.trayIcon,SIGNAL("activated(QSystemTrayIcon::ActivationReason)"),self.iconActivated)
self.connect(self.buttonurlconvert,SIGNAL('clicked()'),self.converturl)
self.connect(self.appexit,SIGNAL('triggered()'),self.close)
self.connect(self.appabout,SIGNAL('triggered()'),self.showabout)
self.connect(self.actionAbout,SIGNAL('triggered()'),self.showabout)
self.connect(self.buttonreset,SIGNAL('clicked()'),self.resetall)
self.connect(self.actionNew,SIGNAL('triggered()'),self.resetall)
def iconActivated(self,dovod):
if dovod == QSystemTrayIcon.Trigger:
if self.isVisible():
self.hide()
else:
self.show()
def resetall(self):
self.texturl.setText("")
self.textshorturl.setText("")
self.textshorturl.setEnabled(False)
self.buttonurlconvert.setEnabled(True)
self.comboservice.setCurrentIndex(0)
self.convertprogress.hide()
def converturl(self):
url=str(self.texturl.text())
url=url.strip()
if url=="":
QMessageBox.warning(self,"Error","Please Enter the valid URL")
else:
self.convertprogress.show()
self.convertprogress.setValue(10)
self.textshorturl.setEnabled(True)
self.convertprogress.setValue(30)
self.currentservice=self.comboservice.currentText()
self.convertprogress.setValue(50)
self.buttonurlconvert.setEnabled(False)
if self.currentservice == "TinyURL":
try:
self.textshorturl.setText(str(tinyurl.create_one(url)))
self.convertprogress.setValue(100)
self.buttonurlconvert.setEnabled(True)
except:
QMessageBox.warning(self,"Error","Host can not be resolved")
elif self.currentservice == "google":
try:
self.textshorturl.setText(str(google.shorten(url)))
self.convertprogress.setValue(100)
self.buttonurlconvert.setEnabled(True)
self.textshorturl.copy()
except:
QMessageBox.warning(self,"Error","Host can not be resolved")
elif self.currentservice == "bit.ly":
try:
a=bitly.Api()
self.textshorturl.setText(str(a.shorten(url)))
self.convertprogress.setValue(100)
self.buttonurlconvert.setEnabled(True)
except:
QMessageBox.warning(self,"Error","Host can not be resolved")
def showEvent(self,event):
self.show()
self.trayIcon.hide()
event.ignore()
def closeEvent(self,event):
reply = QMessageBox.question(self, 'Message',"Are you sure to quit?", QMessageBox.Yes | QMessageBox.No,QMessageBox.No)
if reply == QMessageBox.Yes:
self.trayIcon.hide()
event.accept()
else:
self.hide()
self.trayIcon.show()
event.ignore()
def showabout(self):
ab=About()
ab.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 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")
