def __init__(self):
super().__init__()
self.dbConnector = cPl.DBConnector("timePlanner.db", "Task",
ormMapping)
self.taskStorage = cPl.TaskStorage(self.dbConnector, ormMapping)
self.currentView = "Work"
self.checkBox = QCheckBox('Minimize to Tray')
self.checkBox.setChecked(True)
self.createModels()
self.grid = QGridLayout()
self.tray_icon = QSystemTrayIcon()
self.tray_icon.setToolTip("Time Planner")
self.tray_icon.setIcon(self.style().standardIcon(
QStyle.SP_ComputerIcon))
traySignal = "activated(QSystemTrayIcon::ActivationReason)"
QObject.connect(self.tray_icon, SIGNAL(traySignal),
self.__icon_activated)
#appendFunc = anonFuncString("Total time")
appendDataFinished = [
cPl.AppendDataView(self.finishedModel, 3,
self.taskStorage.getTotalWorkTime,
workTimeFormat),
cPl.AppendDataView(self.finishedModel, 2, anonFuncString)
]
self.finishedModel.setAppendData(appendDataFinished)
self.initUI()
def __init__(self, parent: QWidget):
super().__init__(parent)
# Bold font
bold = QFont()
bold.setBold(True)
# Systray icon
icon: QIcon = QApplication.instance().windowIcon()
self._systray_icon = QSystemTrayIcon(icon, self)
self._systray_icon.setToolTip("Noteeds")
# Show action
self._show_action = QAction("&Show", self)
self._show_action.setFont(bold)
# Exit action
self._exit_action = QAction("E&xit", self)
# Menu
self._menu = QMenu(parent)
self._menu.addAction(self._show_action)
self._menu.addAction(self._exit_action)
self._systray_icon.setContextMenu(self._menu)
# Connections
self._systray_icon.activated.connect(self._activated)
self._show_action.triggered.connect(self.show_window)
self._exit_action.triggered.connect(self.exit)
def _create_tray_icon(self):
menu = QMenu()
self._mode_group = QActionGroup(menu)
self._mode_group.triggered.connect(self._mode_changed)
self._mode_off = QAction("&Off", parent=menu)
self._mode_off.setCheckable(True)
self._mode_off.setChecked(True)
self._mode_group.addAction(self._mode_off)
menu.addAction(self._mode_off)
self._mode_enabled = QAction("&Enabled", parent=menu)
self._mode_enabled.setCheckable(True)
self._mode_group.addAction(self._mode_enabled)
menu.addAction(self._mode_enabled)
self._mode_training = QAction("&Training mode", parent=menu)
self._mode_training.setCheckable(True)
self._mode_group.addAction(self._mode_training)
menu.addAction(self._mode_training)
menu.addSeparator()
menu.addAction("&Preferences", self.open_preferences)
menu.addSeparator()
menu.addAction("E&xit", self.exit)
pixmap = QPixmap(32, 32)
pixmap.fill(Qt.white)
icon = QIcon(pixmap)
self._tray_icon = QSystemTrayIcon(parent=self)
self._tray_icon.setContextMenu(menu)
self._tray_icon.setIcon(icon)
self._tray_icon.show()
def __init__(self):
self.app = QApplication([])
self.app.setQuitOnLastWindowClosed(False)
self.indicator = QSystemTrayIcon()
self.indicator.setIcon(QIcon(self._get_file('./icons/icon.png')))
self.indicator.setContextMenu(self._build_menu())
self.indicator.setVisible(True)
self.indicator.setToolTip('OFF')
self.indicator.activated.connect(self._click_indicator)
self.logs_dialog = QTextEdit()
self.logs_dialog.setWindowTitle(f'{self.APP_NAME} - Logs')
self.logs_dialog.setFixedSize(440, 440)
self.logs_dialog.setReadOnly(True)
self.logs_dialog.setWindowIcon(
QIcon(self._get_file('./icons/icon.png')))
self.vpn_config = '/etc/openfortivpn/config'
self.vpn_process = None
self.vpn_logs_file = NamedTemporaryFile(delete=False)
self.vpn_thread = VPNThread(self.vpn_logs_file)
self.vpn_thread.status.connect(self._update_vpn_status)
self.vpn_thread.log.connect(self.logs_dialog.append)
self.app_update_thread = AppUpdateThread(self._get_file('./version'))
self.app_update_thread.update_available.connect(
self._show_update_notification)
self.app_update_thread.start()
class SystemTray(QSystemTrayIcon):
def __init__(self, app):
super(SystemTray, self).__init__()
self.app = app
self.systemTray = QSystemTrayIcon(
QIcon(f"{sys.argv[0]}/assets/app_icon.png"))
self.trayMenu = QMenu()
self.systemTray.setContextMenu(self.trayMenu)
self.menu_title_setup()
self.open_action_setup()
self.exit_action_setup()
self.systemTray.show()
def menu_title_setup(self):
self.trayMenu.menuTitle = self.trayMenu.addAction("Saharah Paper")
self.trayMenu.menuTitle.setEnabled(False)
self.trayMenu.addSeparator()
def open_action_setup(self):
self.trayMenu.openAction = self.trayMenu.addAction("Settings")
self.trayMenu.openAction.triggered.connect(self.handle_open)
def handle_open(self):
self.app.mainWindow.show()
def exit_action_setup(self):
self.trayMenu.exitAction = self.trayMenu.addAction("Exit")
self.trayMenu.exitAction.triggered.connect(self.app.quit)
def __init__(self, parent=None):
QSystemTrayIcon.__init__(self, parent)
# タスクトレイアイコン クリックメニュー登録
menu = QMenu(parent)
qt_action = menu.addAction("Status")
qt_action.triggered.connect(self.Message)
menu.addSeparator()
quit_action = menu.addAction("&Quit")
quit_action.triggered.connect(self.Quit)
# タスクトレイアイコン クリックメニュー設定
self.setContextMenu(menu)
# 初期アイコン設定
self.setIcon(QIcon(str(Path(script_path / 'icon.jpg').resolve())))
# run competitive companion server
if not shutil.which('node'):
QMessageBox.critical(None, "error", "node not found",
QMessageBox.Ok)
sys.exit()
# elif socket.socket(socket.AF_INET, socket.SOCK_STREAM).connect_ex(('127.0.0.1', 8080)) != 0:
# QMessageBox.critical(None, "error", "port:8080 is alreday in use", QMessageBox.Ok)
# sys.exit()
else:
self.proc = subprocess.Popen(
['node', str(Path(script_path / 'index.js').resolve())])
def __init__(self, *args):
logging.debug('MainWindow creation')
QMainWindow.__init__(self, *args)
self.ui = Ui_MainWindow()
logging.debug('MainWindow ui setup')
self.ui.setupUi(self)
self.instanceManager = InstanceManager(InstanceManager.getStoredKey())
self.readConfig()
self.setupModels()
self.ui.treeView.activated.connect(self.updatePasswordsModel)
self.ui.tableView.activated.connect(self.udpateDetailTabs)
self.ui.actionQuit.triggered.connect(self.closeReally)
self.ui.actionPreferences.triggered.connect(self.openPreferences)
self.ui.actionRefresh.triggered.connect(self.refreshInstances)
# Init QSystemTrayIcon
icon = QIcon.fromTheme('dialog-passwords',
QIcon(':/icons/dialog-password.svg'))
self.trayIcon = QSystemTrayIcon(icon, self)
systrayMenu = QMenu(self)
systrayMenu.addAction(self.ui.actionRefresh)
systrayMenu.addAction(self.ui.actionQuit)
self.trayIcon.setContextMenu(systrayMenu)
self.trayIcon.show()
self.trayIcon.activated.connect(self.handleSystray)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# self.Lock=threading.RLock()
self.ip = "0.0.0.0"
self.app = QApplication(sys.argv)
self.wMain = QWidget()
self.tray = QSystemTrayIcon(self.wMain)
def __init__(self, icon, parent=None):
QSystemTrayIcon.__init__(self, icon, parent)
self.start_item: QAction = None
self.stop_item: QAction = None
self.setToolTip("Simple Clash vpn GUI")
self.create_menu(parent)
def downfin(self):
self.notify_icon = QSystemTrayIcon()
self.notify_icon.setVisible(True)
self.notify_icon.showMessage(
'Download Finalizado',
u'O download da sua música foi realizado com sucesso.',
QSystemTrayIcon.Information, 3000)
self.manage_interface(True)
def __init__(self, icon, parent=None):
QSystemTrayIcon.__init__(self, icon, parent)
self.menu = QMenu(parent)
restoreAction = self.menu.addAction("Restaurar Janela")
exitAction = self.menu.addAction("Exit")
self.setContextMenu(self.menu)
QObject.connect(restoreAction, SIGNAL("triggered()"), self.restore)
QObject.connect(exitAction, SIGNAL("triggered()"), self.exit)
def __init__(self, icon, parent=None):
QSystemTrayIcon.__init__(self, icon, parent)
self.menu = BaseMenu()
self.setContextMenu(self.menu)
# Set up Ctrl+C handling.
# Could be done differently - see https://coldfix.eu/2016/11/08/pyqt-boilerplate/#keyboardinterrupt-ctrl-c
# But this way is simpler and a little faster.
signal.signal(signal.SIGINT, signal.SIG_DFL)
class IPtray(object):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# self.Lock=threading.RLock()
self.ip = "0.0.0.0"
self.app = QApplication(sys.argv)
self.wMain = QWidget()
self.tray = QSystemTrayIcon(self.wMain)
def Ui(self):
self.sub_getIP()
self.actExit = QAction("退出")
self.actExit.triggered.connect(self.forceEx)
self.tray.setIcon(QIcon(".\icon\ip.png"))
self.tray.setVisible(True)
self.trayMenu = QMenu()
self.trayMenu.addAction(self.actExit)
self.tray.setContextMenu(self.trayMenu)
# print("showing message")
self.tray.showMessage("IP", "你的IP是" + self.ip)
self.sub_setToolTip() #getIP运行比较慢, setToolTip放在后面.
sys.exit(self.app.exec_())
def forceEx(self):
sys.exit(self.app.exec_())
exit()
def getIP(self):
# self.Lock.acquire()
while 1:
try:
s = socket(AF_INET, SOCK_DGRAM)
s.connect(("114.114.114.114", 80))
self.ip = s.getsockname()[0]
finally:
s.close()
# print("exit getIP")
sleep(5)
# self.Lock.release()
def setToolTip(self):
while 1:
self.tray.setToolTip(self.ip)
# print("exit setToopTip")
sleep(5)
def sub_getIP(self):
self.subThread_getIP = Thread(target=self.getIP, daemon=True)
self.subThread_getIP.setName("sub_getIP")
# self.subThread_getIP.setDaemon = True # 设置为后台线程
self.subThread_getIP.start()
# 这个线程要一直运行
def sub_setToolTip(self):
self.subThread_setToolTip = Thread(target=self.setToolTip, daemon=True)
self.subThread_setToolTip.setName("sub_setToolTip")
# self.subThread_setToolTip.setDaemon(True) # 设置为后台线程
self.subThread_setToolTip.start()
def __init__(self, actions: SystemTrayIconActions, widget):
self.tray_icon_menu = QMenu(widget)
for action in actions:
self.tray_icon_menu.addAction(action)
self.tray_icon = QSystemTrayIcon(widget)
self.tray_icon.setContextMenu(self.tray_icon_menu)
def initUI(self):
style = self.style()
icon = style.standardIcon(QStyle.SP_TitleBarMenuButton)
self.tray_icon = QSystemTrayIcon()
self.tray_icon.setIcon(QIcon(icon))
self.setWindowIcon(QIcon(icon))
for path in QIcon.themeSearchPaths():
print("%s/%s" % (path, QIcon.themeName()))
def createTrayIcon(self):
self.trayIconMenu = QMenu(self)
self.trayIconMenu.addAction(self.minimizeAction)
self.trayIconMenu.addAction(self.maximizeAction)
self.trayIconMenu.addAction(self.restoreAction)
self.trayIconMenu.addSeparator()
self.trayIconMenu.addAction(self.quitAction)
self.trayIcon = QSystemTrayIcon(self)
self.trayIcon.setContextMenu(self.trayIconMenu)
def __init__(self):
self.icons = {
True: QIcon('icons/rotate_disabled.png'),
False: QIcon('icons/rotate_enabled.png'),
}
self.tray = QSystemTrayIcon()
self.tray.activated.connect(self.action)
self.update_status()
self.tray.show()
def availableMethods(cls) -> Dict[int, str]:
out = {
cls.METHOD_STUB: "Disabled",
cls.METHOD_TOOLTIP: "Cursor tooltip",
}
if (QSystemTrayIcon.isSystemTrayAvailable()
and QSystemTrayIcon.supportsMessages()):
out[cls.METHOD_NOTIFICATION] = "Notification"
return out
def __init__(self):
QWidget.__init__(self)
self.reminders = None
self.active_reminder = None
self.initialize_db()
self.tray_icon = QSystemTrayIcon(self)
self.tray_menu = QMenu()
self.initialize_tray_icon()
self.disambiguate_timer = QTimer(self)
self.disambiguate_timer.setSingleShot(True)
self.disambiguate_timer.timeout.connect(
self.disambiguate_timer_timeout)
self.view_reminders_button = QPushButton('View')
self.view_reminders_button.clicked.connect(
self.on_view_reminders_button_clicked)
self.new_reminder_button = QPushButton('New')
self.new_reminder_button.clicked.connect(
self.on_new_reminder_button_clicked)
self.random_reminder_button = QPushButton('Random Reminder')
self.random_reminder_button.clicked.connect(
self.on_random_reminder_button_clicked)
self.reminder_text = QLabel(self.active_reminder)
self.reminder_text.setAlignment(Qt.AlignCenter)
self.v_box = QVBoxLayout()
self.h_box1 = QHBoxLayout()
self.h_box1.addWidget(self.view_reminders_button,
alignment=Qt.AlignLeft)
self.h_box1.addWidget(self.new_reminder_button,
alignment=Qt.AlignRight)
self.h_box2 = QHBoxLayout()
self.h_box2.addWidget(self.reminder_text)
self.h_box3 = QHBoxLayout()
self.h_box3.addWidget(self.random_reminder_button,
alignment=Qt.AlignHCenter)
self.v_box.addLayout(self.h_box1)
self.v_box.addLayout(self.h_box2)
self.v_box.addLayout(self.h_box3)
self.setLayout(self.v_box)
self.popup = QMessageBox()
self.popup.setText(self.active_reminder)
self.new_reminder_window = NewReminderWindow()
self.new_reminder_window.save_button.clicked.connect(
self.on_save_clicked)
self.view_reminders_window = ViewRemindersWindow()
def __init__(self, app):
super(SystemTray, self).__init__()
self.app = app
self.systemTray = QSystemTrayIcon(
QIcon(f"{sys.argv[0]}/assets/app_icon.png"))
self.trayMenu = QMenu()
self.systemTray.setContextMenu(self.trayMenu)
self.menu_title_setup()
self.open_action_setup()
self.exit_action_setup()
self.systemTray.show()
def tray_init(self):
icon = QIcon(":/icon/icon/CTPBEE.png")
menu = QMenu()
exitAction = menu.addAction("❎ 退出")
exitAction.triggered.connect(self.quit_action)
self.tray = QSystemTrayIcon()
self.tray.setIcon(icon)
self.tray.setContextMenu(menu)
self.tray.activated.connect(self.iconActivated)
self.tray.show()
self.tray.setToolTip("bee box")
def __init__(self, parent=None):
super(Window, self).__init__(parent)
self.iconGroupBox = QGroupBox()
self.iconLabel = QLabel()
self.iconComboBox = QComboBox()
self.showIconCheckBox = QCheckBox()
self.messageGroupBox = QGroupBox()
self.typeLabel = QLabel()
self.durationLabel = QLabel()
self.durationWarningLabel = QLabel()
self.titleLabel = QLabel()
self.bodyLabel = QLabel()
self.typeComboBox = QComboBox()
self.durationSpinBox = QSpinBox()
self.titleEdit = QLineEdit()
self.bodyEdit = QTextEdit()
self.showMessageButton = QPushButton()
self.minimizeAction = QAction()
self.maximizeAction = QAction()
self.restoreAction = QAction()
self.quitAction = QAction()
self.trayIcon = QSystemTrayIcon()
self.trayIconMenu = QMenu()
self.createIconGroupBox()
self.createMessageGroupBox()
self.iconLabel.setMinimumWidth(self.durationLabel.sizeHint().width())
self.createActions()
self.createTrayIcon()
self.showMessageButton.clicked.connect(self.showMessage)
self.showIconCheckBox.toggled.connect(self.trayIcon.setVisible)
self.iconComboBox.currentIndexChanged.connect(self.setIcon)
self.trayIcon.messageClicked.connect(self.messageClicked)
self.trayIcon.activated.connect(self.iconActivated)
self.mainLayout = QVBoxLayout()
self.mainLayout.addWidget(self.iconGroupBox)
self.mainLayout.addWidget(self.messageGroupBox)
self.setLayout(self.mainLayout)
self.iconComboBox.setCurrentIndex(1)
self.trayIcon.show()
self.setWindowTitle("Systray")
self.resize(400, 300)
def __init__(self):
super().__init__()
self.settings = QSettings(self)
type_ = int(
self.settings.value("settings/tooltip", self.METHOD_NOTIFICATION))
if (QSystemTrayIcon.isSystemTrayAvailable()
and QSystemTrayIcon.supportsMessages()
and type_ == self.METHOD_NOTIFICATION):
self.notifier = TrayIconNotifier()
elif type_ == self.METHOD_TOOLTIP:
self.notifier = TooltipNotifier()
else:
self.notifier = StubNotifier()
def start(self) -> None:
if not QSystemTrayIcon.isSystemTrayAvailable():
QMessageBox.critical(None, SYSTEM_TRAY_APP_NAME,
'System tray is not available.')
sys.exit(1)
if not QSystemTrayIcon.supportsMessages():
QMessageBox.warning(
None, SYSTEM_TRAY_APP_NAME,
'The system tray does not support notification '
'("balloon") messages.')
self._tray_icon.show()
def createTrayIcon(self):
path = os.path.join(
pathlib.Path(__file__).parent.absolute(), "icons/notes.svg")
icon = QIcon(QPixmap(path))
self.trayIcon = QSystemTrayIcon(icon, self)
self.trayMenu = None
QObject.connect(self.trayIcon,
SIGNAL("activated(QSystemTrayIcon::ActivationReason)"),
self.trayIconActivated)
self.populateTrayMenu()
self.trayIcon.show()
class SystemTray(QWidget):
"""只有托盘"""
def __init__(self, config_list):
super().__init__()
self.tray = QSystemTrayIcon()
self.tray.setIcon(QIcon('icons/app.ico'))
self.add_menu(config_list)
def add_menu(self, config_list):
"""托盘菜单"""
tray_menu = QMenu()
# 添加菜单
for config in config_list:
params = config.get('params')
sys_name = params.get('name')
tray_menu.addAction(OpenAction(params, self))
stop_bat = params.get('stop_bat', None)
if stop_bat:
tray_menu.addAction(StopAction(sys_name, stop_bat, self))
tray_menu.addAction(ExitAction(self))
self.tray.setContextMenu(tray_menu)
def display(self):
"""icon的值: 0-没有图标 1-是提示 2-是警告 3-是错误"""
self.tray.show()
self.tray.showMessage(u"启动成功", '请通过右键操作')
def setup_app(app):
# Stop window closing
app.setQuitOnLastWindowClosed(False)
# Init QSystemTrayIcon
icon = QIcon("icon.png")
tray_icon = QSystemTrayIcon(app)
tray_icon.setIcon(icon)
# Add Menu Actions to App
new_action = QAction("New", app)
show_action = QAction("Show All", app)
hide_action = QAction("Hide All", app)
quit_action = QAction("Exit", app)
new_action.triggered.connect(new_note)
show_action.triggered.connect(show_all)
hide_action.triggered.connect(hide_all)
quit_action.triggered.connect(quit_app)
# Add Tray Menu
tray_menu = QMenu()
tray_menu.addAction(new_action)
tray_menu.addAction(show_action)
tray_menu.addAction(hide_action)
tray_menu.addAction(quit_action)
tray_icon.setContextMenu(tray_menu)
tray_icon.activated.connect(systemIcon)
tray_icon.show()
def __init__(self, root):
self.root = root
self.app = QApplication([])
self.icons = {
"timelapse": QIcon(resource_path('icons/timelapse.png')),
"sync": QIcon(resource_path('icons/sync.png')),
"sync_disabled": QIcon(resource_path('icons/sync_disabled.png')),
"logo": QIcon(resource_path('icons/logo.png')),
"settings": QIcon(resource_path('icons/settings.png')),
"github": QIcon(resource_path('icons/github.png'))
}
self.main_window = MainWindow(self)
self.offset_window = None
self.settings_window = None
self.messages = [[], []]
self.section_labels = [
self.main_window.ui.right_status,
self.main_window.ui.right_status_2
]
menu = QMenu('FS Time Sync')
menu.setStyleSheet("""
QMenu {
background-color: #151515;
color: #ffffff;
}
QMenu::item {
padding: 5px 10px 5px 10px;
}
QMenu::item:selected {
background-color: #ffffff;
color: #151515;
}
""")
self.tray_actions = {}
self.tray_actions["sync_now"] = menu.addAction("Sync Now")
self.tray_actions["sync_now"].triggered.connect(
lambda: self.root.sync_sim(force=True))
self.tray_actions["hide_show"] = menu.addAction("Hide")
self.tray_actions["hide_show"].triggered.connect(self.hide)
self.tray_actions["exit"] = menu.addAction("Exit")
self.tray_actions["exit"].triggered.connect(self.exit)
self.tray = QSystemTrayIcon()
self.tray.setIcon(self.icons['logo'])
self.tray.setToolTip("FS Time Sync")
self.tray.setContextMenu(menu)
self.tray.activated.connect(self.trayActivated)
self.tray.show()
def changeEvent(self, event):
# This minimizes the program to tray when Minimize button pressed
if event.type() == QEvent.WindowStateChange:
if self.windowState() & Qt.WindowMinimized:
print(QSystemTrayIcon.isSystemTrayAvailable())
if QSystemTrayIcon.isSystemTrayAvailable(
) and self.isActiveWindow():
event.ignore()
self.tray.show()
self.hide()
self.listener = keyboard.Listener(
on_release=self.on_release)
self.listener.start()
def tray_init(self):
icon = QIcon(":menu/images/bee_temp_grey.png")
menu = QMenu()
openAction = menu.addAction("🍯 界面")
settingAction = menu.addAction("⚙ 设置")
exitAction = menu.addAction("❎ 退出")
settingAction.triggered.connect(self.config_handle)
openAction.triggered.connect(self.show)
exitAction.triggered.connect(self.quit)
self.tray = QSystemTrayIcon()
self.tray.setIcon(icon)
self.tray.setContextMenu(menu)
self.tray.activated.connect(self.iconActivated)
self.tray.show()
self.tray.setToolTip("ctpbee桌面端")
def __init__(self, crypter):
super(ControlMainWindow, self).__init__(None)
self.icon = QSystemTrayIcon()
self.icon.setIcon(QtGui.QIcon('./eve_tray.png'))
self.icon.show()
self.setWindowIcon(QtGui.QIcon('./eve_tray.png'))
self.setWindowTitle('Pve Launcher')
self.ui = Ui_main_window()
self.ui.setupUi(self)
self.icon.activated.connect(self.activate)
self.account_list_model = QStringListModel()
self.ui.listView.setModel(self.account_list_model)
self.login_manager = EveLoginManager(crypter)
self.init_none_ui(crypter)
self.settings = None
self.load_settings()
self.ui.txt_client_path.setText(self.settings['eve_path'])
class MainWindow(Ui_Form):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.appname = "poliBeePsync"
self.settings_fname = 'pbs-settings.ini'
self.data_fname = 'pbs.data'
self.setupUi(self)
self.w = QWidget()
self.status_signal = MySignal()
self.status_signal.sig.connect(self.update_status_bar)
self.logging_signal = MySignal()
self.logging_signal.sig.connect(self.myStream_message)
logging_console_hdl = SignalLoggingHandler(self.logging_signal)
logger.addHandler(logging_console_hdl)
commonlogger.addHandler(logging_console_hdl)
self.about_text()
self.timer = QTimer(self)
# settings_path is a string containing the path to settings
self.settings_path = None
# settings is a dictionary of settings
self.settings = None
# load_settings() sets settings_path and settings
self.load_settings()
self.load_data()
self.timer.timeout.connect(self.syncfiles)
self.timer.start(1000 * 60 * int(self.settings['UpdateEvery']))
self.loginthread = LoginThread(self.user, self)
self.loginthread.signal_error.sig.connect(self.update_status_bar)
self.loginthread.signal_ok.sig.connect(self.update_status_bar)
self.refreshcoursesthread = RefreshCoursesThread(self.user, self)
self.refreshcoursesthread.dumpuser.sig.connect(self.dumpUser)
self.refreshcoursesthread.newcourses.sig.connect(self.addtocoursesview)
self.refreshcoursesthread.newcourses.sig.connect(self.syncnewcourses)
self.refreshcoursesthread.removable.sig.connect(self.rmfromcoursesview)
self.downloadthread = DownloadThread(self.user,
self.settings['RootFolder'],
self)
self.downloadthread.dumpuser.sig.connect(self.dumpUser)
self.downloadthread.download_signal.connect(
self.update_course_download)
self.downloadthread.initial_sizes.connect(self.setinizialsizes)
self.downloadthread.date_signal.connect(self.update_file_localtime)
self._window.userCode.setText(str(self.user.username))
self._window.userCode.editingFinished.connect(self.setusercode)
self._window.password.setText(self.user.password)
self._window.password.editingFinished.connect(self.setpassword)
self._window.trylogin.clicked.connect(self.testlogin)
self._window.courses_model = CoursesListModel(self.user.
available_courses)
self._window.coursesView.setModel(self._window.courses_model)
self._resizeview()
self._window.refreshCourses.clicked.connect(self.refreshcourses)
self._window.syncNow.clicked.connect(self.syncfiles)
if self.settings['SyncNewCourses'] == str(True):
self._window.sync_new = Qt.Checked
else:
self._window.sync_new = Qt.Unchecked
self._window.rootfolder.setText(self.settings['RootFolder'])
self._window.rootfolder.textChanged.connect(self.rootfolderslot)
self._window.addSyncNewCourses.setCheckState(self._window.sync_new)
self._window.addSyncNewCourses.stateChanged.connect(self.syncnewslot)
self._window.timerMinutes.setValue(int(self.settings['UpdateEvery']))
self._window.timerMinutes.valueChanged.connect(self.updateminuteslot)
self._window.changeRootFolder.clicked.connect(self.chooserootdir)
self._window.version_label.setText("Current version: {}."
.format(__version__))
self._window.check_version.clicked.connect(self.checknewversion)
self.trayIconMenu = QMenu()
self.trayIcon = QSystemTrayIcon(self.icon, self.w)
self.trayIcon.activated.connect(self._activate_traymenu)
self.createTray()
@Slot()
def _resizeview(self, **kwargs):
self._window.coursesView.setColumnWidth(3, 160)
self._window.coursesView.resizeColumnToContents(1)
self._window.coursesView.setColumnWidth(0, 320)
def checknewversion(self):
rawdata = requests.get('https://pypi.python.org/pypi/'
'poliBeePsync/json')
latest = json.loads(rawdata.text)['info']['version']
self._window.version_label.setTextFormat(Qt.RichText)
self._window.version_label.setOpenExternalLinks(True)
self._window.version_label.setLocale(QLocale(QLocale.English,
QLocale.UnitedStates))
self._window.version_label.setScaledContents(True)
self._window.version_label.setWordWrap(True)
if latest != __version__:
newtext = """<p>Current version: {}.<br>
Latest version: {}. </p>
<p>Visit <a
href='https://jacotsu.github.io/polibeepsync/dirhtml/index.html\
#how-to-install-upgrade-remove'>here</a> to find out how to upgrade.
""".format(__version__, latest)
else:
newtext = "Current version: {} up-to-date.".format(__version__)
self._window.version_label.setText(newtext)
def _update_time(self, folder, file, path_list):
logger.debug(f'inside {folder.name}')
for path in path_list:
logger.debug(f'namegoto: {path}')
folder_dict = {'name': path}
fakefolder = Folder(folder_dict)
logger.debug(f'contained folders: {folder.folders}')
ind = folder.folders.index(fakefolder)
goto = folder.folders[ind]
self._update_time(goto, file, path_list)
if file in folder.files:
ind = folder.files.index(file)
thisfile = folder.files[ind]
thisfile.local_creation_time = file.local_creation_time
@Slot(tuple)
def update_file_localtime(self, data, **kwargs):
course, coursefile, path = data
rootpath = os.path.join(self.settings['RootFolder'],
course.save_folder_name)
if path.startswith(rootpath):
partial = path[len(rootpath):]
path_list = filter(None, partial.split(os.path.sep))
self._update_time(course.documents, coursefile, path_list)
@Slot(Course)
def update_course_download(self, course, **kwargs):
if course in self.user.available_courses:
updating = self.user.available_courses[course.name]
updating.downloaded_size = course.downloaded_size
row = self._window.courses_model.courses.index(updating)
where = self._window.courses_model.index(row, 3)
self._window.courses_model.dataChanged.emit(where, where)
@Slot(Course)
def setinizialsizes(self, course, **kwargs):
if course in self.user.available_courses:
updating = self.user.available_courses[course.name]
updating.downloaded_size = course.downloaded_size
updating.total_file_size = course.total_file_size
row = self._window.courses_model.courses.index(updating)
where = self._window.courses_model.index(row, 3)
self._window.courses_model.dataChanged.emit(where, where)
self.dumpUser()
@Slot(list)
def syncnewcourses(self, newlist):
if self.settings['SyncNewCourses'] == 'True':
for elem in newlist:
elem.sync = True
def load_settings(self):
for path in [user_config_dir(self.appname),
user_data_dir(self.appname)]:
try:
os.makedirs(path, exist_ok=True)
except OSError:
logger.critical('OSError while calling os.makedirs.',
exc_info=True)
logger.critical(f"I couldn't create {path}.\nStart"
" poliBeePsync with --debug "
"error to get more details.")
self.settings_path = os.path.join(user_config_dir(self.appname),
self.settings_fname)
defaults = {
'UpdateEvery': '60',
'RootFolder': os.path.join(os.path.expanduser('~'), self.appname),
'SyncNewCourses': 'False'
}
self.settings = filesettings.settingsFromFile(self.settings_path,
defaults)
def load_data(self):
try:
with open(os.path.join(user_data_dir(self.appname),
self.data_fname), 'rb') as f:
self.user = pickle.load(f)
self.user.password = keyring\
.get_password('beep.metid.polimi.it',
self.user.username)
logger.info("Data has been loaded successfully.")
except (EOFError, pickle.PickleError):
logger.error('Settings corrupted', exc_info=True)
self.user = User('', '')
except FileNotFoundError:
logger.error('Settings file not found.')
self.user = User('', '')
logger.error("I couldn't find data in the"
" predefined directory. Ignore this"
"message if you're using poliBeePsync"
" for the first time.")
@Slot(str)
def update_status_bar(self, status):
self._window.statusbar.showMessage(status)
@Slot(int)
def syncnewslot(self, state):
if state == 2:
self.settings['SyncNewCourses'] = 'True'
else:
self.settings['SyncNewCourses'] = 'False'
filesettings.settingsToFile(self.settings, self.settings_path)
@Slot(int)
def updateminuteslot(self, minutes):
self.settings['UpdateEvery'] = str(minutes)
filesettings.settingsToFile(self.settings, self.settings_path)
self.timer.start(1000 * 60 * int(self.settings['UpdateEvery']))
@Slot(str)
def rootfolderslot(self, path):
self.settings['RootFolder'] = path
filesettings.settingsToFile(self.settings, self.settings_path)
@Slot()
def chooserootdir(self):
currentdir = self.settings['RootFolder']
flags = QFileDialog.DontResolveSymlinks | QFileDialog.ShowDirsOnly
newroot = QFileDialog.getExistingDirectory(None,
"Open Directory",
currentdir, flags)
if newroot != "" and str(newroot) != currentdir:
self.settings['RootFolder'] = str(newroot)
filesettings.settingsToFile(self.settings, self.settings_path)
self._window.rootfolder.setText(newroot)
# we delete the already present downloadthread and recreate it
# because otherwise it uses the old download folder. I don't know
# if there's a cleaner approach
del self.downloadthread
self.downloadthread = DownloadThread(self.user,
self.settings['RootFolder'],
self)
self.downloadthread.dumpuser.sig.connect(self.dumpUser)
self.dumpUser()
@Slot()
def setusercode(self):
newcode = self._window.userCode.text()
try:
if len(newcode) == 8:
self.user.username = newcode
logger.info(f'User code changed to {newcode}.')
keyring.set_password('beep.metid.polimi.it',
self.user.username,
self.user.password)
except OSError:
logger.critical("I couldn't save data to disk. Run"
" poliBeePsync with option --debug"
" error to get more details.")
logger.error('OSError raised while trying to write the User'
'instance to disk.', exc_info=True)
@Slot()
def setpassword(self):
newpass = self._window.password.text()
self.user.password = newpass
try:
keyring.set_password('beep.metid.polimi.it',
self.user.username,
self.user.password)
logger.info("Password changed.")
except OSError:
logger.critical("I couldn't save data to disk. Run"
" poliBeePsync with option --debug"
" error to get more details.")
logger.error('OSError raised while trying to write the User'
'instance to disk.', exc_info=True)
@Slot()
def testlogin(self):
if not self.loginthread.isRunning():
self.loginthread.exiting = False
self.loginthread.start()
self.status_signal.sig.emit("Logging in, please wait.")
@Slot(list)
def addtocoursesview(self, addlist):
for elem in addlist:
self._window.courses_model.insertRows(0, 1, elem)
@Slot(list)
def rmfromcoursesview(self, removelist):
for elem in removelist:
index = self._window.courses_model.courses.index(elem)
self._window.courses_model.removeRows(index, 1)
@Slot()
def dumpUser(self):
# we don't use the message...
with open(os.path.join(user_data_dir(self.appname),
self.data_fname), 'wb') as f:
tmp_pw = self.user.password
self.user.password = ''
pickle.dump(self.user, f)
self.user.password = tmp_pw
@Slot()
def refreshcourses(self):
self.status_signal.sig.emit('Searching for online updates...'
'this may take a while.')
if not self.loginthread.isRunning():
self.loginthread.exiting = False
self.loginthread.signal_ok.sig.connect(self.do_refreshcourses)
self.loginthread.start()
def do_refreshcourses(self):
self.loginthread.signal_ok.sig.disconnect(self.do_refreshcourses)
if not self.refreshcoursesthread.isRunning():
self.refreshcoursesthread.start()
@Slot()
def syncfiles(self):
# we delete the already present downloadthread and recreate it
# because otherwise it uses the old download folder. I don't know
# if there's a cleaner approach
del self.downloadthread
self.downloadthread = DownloadThread(self.user,
self.settings['RootFolder'],
self)
self.downloadthread.dumpuser.sig.connect(self.dumpUser)
self.refreshcoursesthread.finished.connect(self.do_syncfiles)
self.refreshcourses()
@Slot()
def do_syncfiles(self):
self.refreshcoursesthread.finished.disconnect(self.do_syncfiles)
self.status_signal.sig.emit('Started syncing.')
self.downloadthread.start()
@Slot(str)
def myStream_message(self, message):
self._window.status.moveCursor(QTextCursor.End)
self._window.status.insertPlainText(message + "\n")
def restore_window(self):
self._window.setWindowState(self.windowState() & ~Qt.WindowMinimized |
Qt.WindowActive)
self._window.show()
def createTray(self):
restoreAction = QAction("&Restore", self, triggered=self.restore_window)
quitAction = QAction("&Quit", self, triggered=qApp.quit)
self.trayIconMenu.addAction(restoreAction)
self.trayIconMenu.addAction(quitAction)
self.trayIcon.setContextMenu(self.trayIconMenu)
self.trayIcon.show()
@Slot(str)
def _activate_traymenu(self, reason):
if reason == QSystemTrayIcon.ActivationReason.DoubleClick:
self.restore_window()
else:
self.trayIconMenu.activateWindow()
self.trayIconMenu.popup(QCursor.pos())
def closeEvent(self, event):
self._window.hide()
event.ignore()
def about_text(self):
self._window.label_3 = QLabel()
self._window.label_3.setTextFormat(Qt.RichText)
self._window.label_3.setOpenExternalLinks(True)
self._window.label_3.setLocale(QLocale(QLocale.English,
QLocale.UnitedStates))
self._window.label_3.setScaledContents(True)
self._window.label_3.setWordWrap(True)
text = """
<html>
<head/>
<body>
<p>poliBeePsync is a program written by Davide Olianas,
released under GNU GPLv3+.</p>
<p>Feel free to contact me at <a
href=\"mailto:[email protected]\">[email protected]</a> for
suggestions and bug reports.</p>
<p>More information is available on the
<a href=\"http://www.davideolianas.com/polibeepsync\">
<span style=\" text-decoration: underline; color:#0000ff;\">
official website</span></a>.
</p>
</body>
</html>
"""
self._window.label_3.setText(QApplication.translate("Form", text,
None))
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.appname = "poliBeePsync"
self.settings_fname = 'pbs-settings.ini'
self.data_fname = 'pbs.data'
self.setupUi(self)
self.w = QWidget()
self.status_signal = MySignal()
self.status_signal.sig.connect(self.update_status_bar)
self.logging_signal = MySignal()
self.logging_signal.sig.connect(self.myStream_message)
logging_console_hdl = SignalLoggingHandler(self.logging_signal)
logger.addHandler(logging_console_hdl)
commonlogger.addHandler(logging_console_hdl)
self.about_text()
self.timer = QTimer(self)
# settings_path is a string containing the path to settings
self.settings_path = None
# settings is a dictionary of settings
self.settings = None
# load_settings() sets settings_path and settings
self.load_settings()
self.load_data()
self.timer.timeout.connect(self.syncfiles)
self.timer.start(1000 * 60 * int(self.settings['UpdateEvery']))
self.loginthread = LoginThread(self.user, self)
self.loginthread.signal_error.sig.connect(self.update_status_bar)
self.loginthread.signal_ok.sig.connect(self.update_status_bar)
self.refreshcoursesthread = RefreshCoursesThread(self.user, self)
self.refreshcoursesthread.dumpuser.sig.connect(self.dumpUser)
self.refreshcoursesthread.newcourses.sig.connect(self.addtocoursesview)
self.refreshcoursesthread.newcourses.sig.connect(self.syncnewcourses)
self.refreshcoursesthread.removable.sig.connect(self.rmfromcoursesview)
self.downloadthread = DownloadThread(self.user,
self.settings['RootFolder'],
self)
self.downloadthread.dumpuser.sig.connect(self.dumpUser)
self.downloadthread.download_signal.connect(
self.update_course_download)
self.downloadthread.initial_sizes.connect(self.setinizialsizes)
self.downloadthread.date_signal.connect(self.update_file_localtime)
self._window.userCode.setText(str(self.user.username))
self._window.userCode.editingFinished.connect(self.setusercode)
self._window.password.setText(self.user.password)
self._window.password.editingFinished.connect(self.setpassword)
self._window.trylogin.clicked.connect(self.testlogin)
self._window.courses_model = CoursesListModel(self.user.
available_courses)
self._window.coursesView.setModel(self._window.courses_model)
self._resizeview()
self._window.refreshCourses.clicked.connect(self.refreshcourses)
self._window.syncNow.clicked.connect(self.syncfiles)
if self.settings['SyncNewCourses'] == str(True):
self._window.sync_new = Qt.Checked
else:
self._window.sync_new = Qt.Unchecked
self._window.rootfolder.setText(self.settings['RootFolder'])
self._window.rootfolder.textChanged.connect(self.rootfolderslot)
self._window.addSyncNewCourses.setCheckState(self._window.sync_new)
self._window.addSyncNewCourses.stateChanged.connect(self.syncnewslot)
self._window.timerMinutes.setValue(int(self.settings['UpdateEvery']))
self._window.timerMinutes.valueChanged.connect(self.updateminuteslot)
self._window.changeRootFolder.clicked.connect(self.chooserootdir)
self._window.version_label.setText("Current version: {}."
.format(__version__))
self._window.check_version.clicked.connect(self.checknewversion)
self.trayIconMenu = QMenu()
self.trayIcon = QSystemTrayIcon(self.icon, self.w)
self.trayIcon.activated.connect(self._activate_traymenu)
self.createTray()
class ControlMainWindow(QMainWindow):
def __init__(self, crypter):
super(ControlMainWindow, self).__init__(None)
self.icon = QSystemTrayIcon()
self.icon.setIcon(QtGui.QIcon('./eve_tray.png'))
self.icon.show()
self.setWindowIcon(QtGui.QIcon('./eve_tray.png'))
self.setWindowTitle('Pve Launcher')
self.ui = Ui_main_window()
self.ui.setupUi(self)
self.icon.activated.connect(self.activate)
self.account_list_model = QStringListModel()
self.ui.listView.setModel(self.account_list_model)
self.login_manager = EveLoginManager(crypter)
self.init_none_ui(crypter)
self.settings = None
self.load_settings()
self.ui.txt_client_path.setText(self.settings['eve_path'])
def init_none_ui(self, crypter):
self.login_manager.load()
acc_list = []
for account_name in self.login_manager.accounts:
acc_list.append(account_name)
self.account_list_model.setStringList(acc_list)
version_thread = Thread(target=self.check_eve_version)
version_thread.start()
def load_settings(self):
try:
with open('pvesettings.json', 'r') as settings_file:
self.settings = json.load(settings_file)
except FileNotFoundError:
self.settings = dict()
self.settings['eve_path'] = ""
def save_settings(self):
with open('pvesettings.json', 'w') as settings_file:
json.dump(self.settings, settings_file)
def closeEvent(self, event):
self.login_manager.save()
self.save_settings()
def changeEvent(self, event):
if event.type() == QEvent.WindowStateChange:
if self.windowState() & Qt.WindowMinimized:
self.icon.show()
QTimer.singleShot(0, self, SLOT('hide()'))
event.ignore()
def func_launch(self):
indexes = self.ui.listView.selectedIndexes()
# i get QModelIndex here
for idx in indexes:
try:
self.login_manager.login(idx.data(), self.get_auth_code,
self.get_charname,
self.ui.txt_client_path.text(),
self.ui.cbox_server.currentText())
except Exception as e:
logger.exception('Failed to launch')
invoke_in_main_thread(QMessageBox.critical, self, "Launch Error",
e.__str__(), QMessageBox.Ok)
def func_edit(self):
indexes = self.ui.listView.selectedIndexes()
# i get QModelIndex here
for idx in indexes:
account = self.login_manager.accounts[idx.data()]
dialog = AccountDialog("Edit Account", account.login_name,
account.plain_password(self.login_manager.coder),
account.direct_x, account.profile_name)
if dialog.show():
# result = [name, password, path, dx]:
path = dialog.result[2]
if not path.endswith(os.sep):
path = path + os.sep
account = EveAccount(dialog.result[0], dialog.result[1], self.login_manager.coder,
None, None, dialog.result[3], dialog.result[2])
self.login_manager.add_account(account)
def func_add(self):
dialog = AccountDialog("Create Account")
if dialog.show():
# [name, password, profile_name, dx]
account = EveAccount(dialog.result[0], dialog.result[1], self.login_manager.coder,
None, None, dialog.result[3], dialog.result[2])
self.login_manager.add_account(account)
acc_list = self.account_list_model.stringList()
acc_list.append(account.login_name)
self.account_list_model.setStringList(acc_list)
def func_delete(self):
indexes = self.ui.listView.selectedIndexes()
# i get QModelIndex here
model = self.ui.listView.model()
for idx in indexes:
self.login_manager.del_account(idx.data())
model.removeRow(idx.row())
def func_clear_cache(self):
self.login_manager.clear_cache()
def activate(self, reason):
if reason == QSystemTrayIcon.Trigger or reason == QSystemTrayIcon.DoubleClick:
self.showNormal()
self.raise_()
self.activateWindow()
# self.setWindowState(Qt.WindowNoState)
# self.activateWindow()
def func_browse_eve(self):
folder = QDir.toNativeSeparators(
QFileDialog.getExistingDirectory(None, "Eve Directory", "", QFileDialog.ShowDirsOnly))
if not folder.endswith(os.sep):
folder += os.sep
self.ui.txt_client_path.setText(folder)
self.settings['eve_path'] = folder
def check_eve_version(self):
headers = {'User-Agent': EveLoginManager.useragent}
#version_url = "http://client.eveonline.com/patches/premium_patchinfoTQ_inc.txt"
#req = request.Request(version_url, headers=headers)
#response = request.urlopen(req)
#version_data = response.read().decode('utf-8')
#match = re.match("BUILD:(\\d+)", version_data)
server_status = EveApi.get_server_status()
if server_status.version is None:
return None
version_string = str(server_status.version)
eve_version_okay: bool = check_eve_version(
version_string,
self.ui.txt_client_path.text())
if not eve_version_okay:
invoke_in_main_thread(QtWidgets.QMessageBox.information, self, "Eve Clients out of date",
"Your eve client is out of date.", QtWidgets.QMessageBox.Ok)
def set_server_status(self, text, number):
self.ui.label_server_status.setText(
QApplication.translate("main_window", text, None)
+ "({0:d})".format(number))
def get_auth_code(self, opener, request):
"""
:param opener: urllib.request.build_opener for sending an authcode per mail
:param request: request to send using the given opener
:return: the authcode
"""
inputDialog = QInputDialog(self)
inputDialog.setInputMode(QInputDialog.TextInput)
inputDialog.setCancelButtonText("Cancel")
inputDialog.setLabelText("Please enter your Authcode")
inputDialog.setWindowTitle("TwoFactorAuth")
inputDialog.setModal(True)
response = None
if inputDialog.exec_() == QInputDialog.Rejected: # send mail
return None, None
else:
return response, inputDialog.textValue().strip()
inputDialog.setCancelButtonText("Cancel")
if inputDialog.exec_() == QInputDialog.Rejected:
return response, None
return response, inputDialog.textValue().strip()
def get_charname(self):
"""
:param mailurl: url to call for sending an authcode per mail
:return: the authcode
"""
inputDialog = QInputDialog(self)
inputDialog.setInputMode(QInputDialog.TextInput)
inputDialog.setLabelText("Please enter a Charname")
inputDialog.setWindowTitle("Charname Challange")
inputDialog.setModal(True)
if inputDialog.exec_() == QInputDialog.Rejected:
return None
return inputDialog.textValue().strip()
