def main():
logging.info("Hello! 👋")
exitcode = 0
try:
menu = QMenu()
# Add Tray
tray = QSystemTrayIcon()
tray.setIcon(QIcon(os.path.join(BASE_PATH, "icon.png")))
tray.setVisible(True)
tray.setContextMenu(menu)
# Proxy
m_proxy = QAction("Proxy: Disabled")
m_proxy.setShortcut('Ctrl+P')
m_proxy.setCheckable(True)
m_proxy.setDisabled(True)
m_proxy.triggered.connect(lambda: current['proxy'].disable())
menu.addAction(m_proxy)
proxy_group = QActionGroup(menu)
for item in PROFILE.get_items('Proxy'):
proxy = Extension(item, 'proxy', m_proxy)
proxy_group.addAction(proxy.QAction)
menu.addAction(proxy.QAction)
if item[0] == selected['proxy']:
proxy.select(manual=True)
# Bypass
menu.addSeparator()
m_bypass = QAction("Bypass: Disabled")
m_bypass.setShortcut('Ctrl+B')
m_bypass.setCheckable(True)
m_bypass.setDisabled(True)
m_bypass.triggered.connect(lambda: current['bypass'].disable())
menu.addAction(m_bypass)
bypass_group = QActionGroup(menu)
for item in PROFILE.get_items('Bypass'):
bypass = Extension(item, 'bypass', m_bypass)
bypass_group.addAction(bypass.QAction)
menu.addAction(bypass.QAction)
if item[0] == selected['bypass']:
bypass.select(manual=True)
# Capture
menu.addSeparator()
m_capture = QAction("Capture: Disabled")
m_capture.setShortcut('Ctrl+C')
m_capture.setCheckable(True)
m_capture.setDisabled(True)
m_dashboard = QAction("Open Dashboard...")
m_dashboard.setShortcut('Ctrl+D')
m_dashboard.setDisabled(True)
m_capture.triggered.connect(lambda: current['capture'].disable())
menu.addAction(m_capture)
capture_group = QActionGroup(menu)
for item in PROFILE.get_items('Capture'):
capture = Extension(item, 'capture', m_capture, m_dashboard)
capture_group.addAction(capture.QAction)
menu.addAction(capture.QAction)
if item[0] == selected['capture']:
capture.select(manual=True)
menu.addAction(m_dashboard)
# Common
m_setting = QAction("Open Setting File")
m_setting.setShortcut('Ctrl+O')
m_setting.triggered.connect(lambda: subprocess.run(["open", SETTING_FILE]))
m_profile = QAction("Open Profile Folder")
m_profile.setShortcut('Ctrl+P')
m_profile.triggered.connect(lambda: subprocess.run(["open", PROFILE_PATH]))
m_log = QAction("Open Log Folder")
m_log.setShortcut('Ctrl+L')
m_log.triggered.connect(lambda: subprocess.run(["open", LOG_PATH]))
m_extension = QAction("Open Extension Folder")
m_extension.setShortcut('Ctrl+E')
m_extension.triggered.connect(lambda: subprocess.run(["open", EXT_PATH]))
m_copy_shell = QAction("Copy Shell Command")
m_copy_shell.setShortcut('Ctrl+S')
m_set_system = QAction("As System Proxy: " + PORT)
m_set_system.setShortcut('Ctrl+A')
m_set_system.triggered.connect(lambda: set_proxy_menu(m_set_system))
m_copy_shell.triggered.connect(copy_shell)
m_set_system.setCheckable(True)
if system:
m_set_system.setChecked(True)
# set_proxy()
threading.Thread(target=set_proxy).start()
menu.addSeparator()
menu.addAction(m_set_system)
menu.addSeparator()
menu.addAction(m_setting)
menu.addAction(m_profile)
menu.addAction(m_log)
menu.addAction(m_extension)
menu.addAction(m_copy_shell)
menu.addSeparator()
m_update = QAction("Check Update")
m_update.setShortcut("Ctrl+U")
m_update.triggered.connect(lambda: show_url("https://github.com/deepjia/v2net/releases"))
m_quit = QAction('Quit V2Net (' + VERSION + ')')
m_quit.setShortcut('Ctrl+Q')
m_quit.triggered.connect(APP.quit)
menu.addAction(m_update)
menu.addAction(m_quit)
# sys.exit(app.exec_())
exitcode = APP.exec_()
finally:
quit_app(exitcode)
def __init__(self, tray_icon_name = None, **kwargs):
plugin_path = ""
if sys.platform == "win32":
if hasattr(sys, "frozen"):
plugin_path = os.path.join(os.path.dirname(os.path.abspath(sys.executable)), "PyQt5", "plugins")
Logger.log("i", "Adding QT5 plugin path: %s" % (plugin_path))
QCoreApplication.addLibraryPath(plugin_path)
else:
import site
for dir in site.getsitepackages():
QCoreApplication.addLibraryPath(os.path.join(dir, "PyQt5", "plugins"))
elif sys.platform == "darwin":
plugin_path = os.path.join(Application.getInstallPrefix(), "Resources", "plugins")
if plugin_path:
Logger.log("i", "Adding QT5 plugin path: %s" % (plugin_path))
QCoreApplication.addLibraryPath(plugin_path)
os.environ["QSG_RENDER_LOOP"] = "basic"
super().__init__(sys.argv, **kwargs)
self.setAttribute(Qt.AA_UseDesktopOpenGL)
major_version, minor_version, profile = OpenGLContext.detectBestOpenGLVersion()
if major_version is None and minor_version is None and profile is None:
Logger.log("e", "Startup failed because OpenGL version probing has failed: tried to create a 2.0 and 4.1 context. Exiting")
QMessageBox.critical(None, "Failed to probe OpenGL",
"Could not probe OpenGL. This program requires OpenGL 2.0 or higher. Please check your video card drivers.")
sys.exit(1)
else:
Logger.log("d", "Detected most suitable OpenGL context version: %s" % (
OpenGLContext.versionAsText(major_version, minor_version, profile)))
OpenGLContext.setDefaultFormat(major_version, minor_version, profile = profile)
self._plugins_loaded = False # Used to determine when it's safe to use the plug-ins.
self._main_qml = "main.qml"
self._engine = None
self._renderer = None
self._main_window = None
self._theme = None
self._shutting_down = False
self._qml_import_paths = []
self._qml_import_paths.append(os.path.join(os.path.dirname(sys.executable), "qml"))
self._qml_import_paths.append(os.path.join(Application.getInstallPrefix(), "Resources", "qml"))
self.parseCommandLine()
Logger.log("i", "Command line arguments: %s", self._parsed_command_line)
try:
self._splash = self._createSplashScreen()
except FileNotFoundError:
self._splash = None
else:
if self._splash:
self._splash.show()
self.processEvents()
signal.signal(signal.SIGINT, signal.SIG_DFL)
# This is done here as a lot of plugins require a correct gl context. If you want to change the framework,
# these checks need to be done in your <framework>Application.py class __init__().
i18n_catalog = i18nCatalog("uranium")
self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Loading plugins..."))
self._loadPlugins()
self._plugin_registry.checkRequiredPlugins(self.getRequiredPlugins())
self.pluginsLoaded.emit()
self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Updating configuration..."))
upgraded = UM.VersionUpgradeManager.VersionUpgradeManager.getInstance().upgrade()
if upgraded:
# Preferences might have changed. Load them again.
# Note that the language can't be updated, so that will always revert to English.
preferences = Preferences.getInstance()
try:
preferences.readFromFile(Resources.getPath(Resources.Preferences, self._application_name + ".cfg"))
except FileNotFoundError:
pass
self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Loading preferences..."))
try:
file_name = Resources.getPath(Resources.Preferences, self.getApplicationName() + ".cfg")
Preferences.getInstance().readFromFile(file_name)
except FileNotFoundError:
pass
self.getApplicationName()
Preferences.getInstance().addPreference("%s/recent_files" % self.getApplicationName(), "")
self._recent_files = []
file_names = Preferences.getInstance().getValue("%s/recent_files" % self.getApplicationName()).split(";")
for file_name in file_names:
if not os.path.isfile(file_name):
continue
self._recent_files.append(QUrl.fromLocalFile(file_name))
JobQueue.getInstance().jobFinished.connect(self._onJobFinished)
# Initialize System tray icon and make it invisible because it is used only to show pop up messages
self._tray_icon = None
self._tray_icon_widget = None
if tray_icon_name:
self._tray_icon = QIcon(Resources.getPath(Resources.Images, tray_icon_name))
self._tray_icon_widget = QSystemTrayIcon(self._tray_icon)
self._tray_icon_widget.setVisible(False)
def __init__(self):
super(MainWindow, self).__init__()
#Instantiate secondary windows, set up UI from ui files:
self.editWindow = EditWindow()
self.editWindow.setModal(True)
self.optionsWindow = OptionsWindow()
self.optionsWindow.setModal(True)
self.aboutWindow = AboutWindow()
self.aboutWindow.setModal(True)
self.setupUi(self)
#System settings:
self.readMainWindowSettings()
self.readOptionsSettings()
self.loadTable()
#Some UI elements not implemented in Qt Designer:
self.editWindow.intervalErrLabel.setHidden(True)
self.editWindow.intervalErrLabel.setStyleSheet(
"QLabel { color : red; }")
self.editWindow.webpageErrLabel.setHidden(True)
self.editWindow.webpageErrLabel.setStyleSheet(
"QLabel { color : red; }")
#Set up SystemTrayIcon:
self.trayIcon = QSystemTrayIcon(self)
trayMenu = QMenu(self)
trayShowAction = trayMenu.addAction("Show Window")
trayPageAction = trayMenu.addAction("Open Last Alerted Page")
trayMenu.addSeparator()
trayExitAction = trayMenu.addAction("Exit")
self.trayAlertPage = ""
trayExitAction.triggered.connect(lambda: self.close())
trayShowAction.triggered.connect(lambda: self.activateWindow())
trayShowAction.triggered.connect(lambda: self.raise_())
trayPageAction.triggered.connect(lambda: self.openPage())
self.trayIcon.activated.connect(lambda: self.activateWindow())
self.trayIcon.activated.connect(lambda: self.raise_())
self.trayIcon.messageClicked.connect(lambda: self.openPage())
self.trayIcon.setContextMenu(trayMenu)
self.trayIcon.setIcon(QIcon(QPixmap("binoculars.png")))
self.trayIcon.show()
#Signals, slots, connections:
self.newButton.clicked.connect(lambda: self.addNewAlert())
self.editButton.clicked.connect(lambda: self.showEdit())
self.deleteButton.clicked.connect(lambda: self.deleteAlert())
self.runButton.clicked.connect(lambda: self.toggleAlert())
self.logButton.clicked.connect(lambda: self.showLog())
self.actionAbout.triggered.connect(lambda: self.showAbout())
self.actionOptions.triggered.connect(lambda: self.showOptions())
self.actionNew.triggered.connect(lambda: self.addNewAlert())
self.actionSave.triggered.connect(lambda: self.saveTable())
self.actionExit.triggered.connect(lambda: self.close())
self.alertTableWidget.itemSelectionChanged.connect(
lambda: self.enableTableActions())
self.alertTableWidget.doubleClicked.connect(lambda: self.showEdit())
self.editWindow.editDialog.accepted.connect(lambda: self.applyEdit())
self.editWindow.intervalLineEdit.textEdited.connect(
lambda: self.checkIntervalInput())
self.editWindow.webpageLineEdit.textEdited.connect(
lambda: self.checkWebpageInput())
self.optionsWindow.soundDirButton.clicked.connect(
lambda: self.chooseSoundDir())
self.optionsWindow.logDirButton.clicked.connect(
lambda: self.chooseLogDir())
self.optionsWindow.optionsDialog.accepted.connect(
lambda: self.writeOptionsSettings())
#Deactivate all alerts as contingency:
self.deactivateAlerts()
#Test Button Signal/Slot:
self.actionTest.triggered.connect(lambda: self.runTest())
def startRemotePykib(self):
logging.info("Pykib Remote Browser Daemon Mode")
#Create Temp Session Token if Option is set
if (self.args.useTemporarySessionToken):
logging.info("Temporary Session Token is used:")
characters = string.ascii_letters + string.digits
self.args.remoteBrowserSessionToken = ''.join(
random.choice(characters) for i in range(128))
logging.info(" Token: " + self.args.remoteBrowserSessionToken)
token_path = tempfile.gettempdir()
if (self.args.temporarySessionTokenPath):
token_path = self.args.temporarySessionTokenPath
token_path = token_path.replace(
"\\", "/") + "/.pykibTemporarySessionToken"
with open(token_path, "w") as text_file:
text_file.write(self.args.remoteBrowserSessionToken)
logging.info(" Storing Token under: " + token_path)
self.app.setQuitOnLastWindowClosed(False)
# Creating a Tray App
icon = QIcon(os.path.join(self.dirname, 'icons/pykib.png'))
tray = QSystemTrayIcon()
tray.setIcon(icon)
tray.setVisible(True)
tray.setToolTip("Rangee Remote Browser Daemon")
# Create the menu
menu = QMenu()
# Add a Quit option to the menu.
quit = QAction("Close Rangee Remote Browser Daemon")
quit.triggered.connect(sys.exit)
menu.addAction(quit)
# Build Configuration Array fpr Plugin
config = {
"remotingList": self.args.remotingList.split(" "),
"allowUserBasedRemoting": self.args.allowUserBasedRemoting,
"remoteBrowserMoveInterval": self.args.remoteBrowserMoveInterval,
"remoteDaemonProtocolVersion":
self.args.remoteDaemonProtocolVersion,
}
# Create an Start the Websocket Server Thread
websocketServer = pykib_base.remotePykibWebsocketServer.RemotePykibWebsocketServer(
config, self.args.remoteBrowserSessionToken,
self.args.remoteBrowserPort)
websocketServer.daemon = True # Daemonize thread
websocketServer.configureInstance.connect(self.configureInstance)
websocketServer.closeInstance.connect(self.closeInstance)
websocketServer.activateInstance.connect(self.activateInstance)
websocketServer.moveInstance.connect(self.moveInstance)
websocketServer.changeTabWindow.connect(self.changeTabWindow)
websocketServer.start()
# Add the menu to the tray
tray.setContextMenu(menu)
sys.exit(self.app.exec_())
def _init_tray(self):
self.tray = QSystemTrayIcon(self.tray_icon(), None)
self.tray.setToolTip('Electrum')
self.tray.activated.connect(self.tray_activated)
self.build_tray_menu()
self.tray.show()
def __init__(self):
super(mywindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# Соединения кнопок меню
self.ui.exit.triggered.connect(qApp.quit)
self.ui.ports.triggered.connect(self.ports_open)
self.ui.graph.triggered.connect(self.graph_open)
self.plots = [self.ui.MplWidget_1,
self.ui.MplWidget_2,
self.ui.MplWidget_3,
self.ui.MplWidget_4,
self.ui.MplWidget_5,
self.ui.MplWidget_6,
self.ui.MplWidget_7,
self.ui.MplWidget_8,
self.ui.MplWidget_9,
self.ui.MplWidget_10]
# Инициализация навигационных баров для графиков
self.plotNavs = [NavigationToolbar(self.plots[0].canvas, self),
NavigationToolbar(self.plots[1].canvas, self),
NavigationToolbar(self.plots[2].canvas, self),
NavigationToolbar(self.plots[3].canvas, self),
NavigationToolbar(self.plots[4].canvas, self),
NavigationToolbar(self.plots[5].canvas, self),
NavigationToolbar(self.plots[6].canvas, self),
NavigationToolbar(self.plots[7].canvas, self),
NavigationToolbar(self.plots[8].canvas, self),
NavigationToolbar(self.plots[9].canvas, self)]
for navBar in self.plotNavs:
self.addToolBar(QtCore.Qt.BottomToolBarArea, navBar)
navBar.toggleViewAction().trigger()
navBar.toggleViewAction().trigger()
self.plotNavs[0].toggleViewAction().trigger()
self.ui.tabWidget.currentChanged.connect(self.tab_changed)
self.update_tab_graph(0)
# QThreads for serial port
try:
with open('port_configuration.cfg', 'r') as f:
lines = f.readlines()
f.close()
except FileNotFoundError:
print('File port_configuration.cfg not found')
self.worker1 = SerialWorker(1, lines[0][:-1], lines[1][:-1])
self.worker2 = SerialWorker(2, lines[5][:-1], lines[6][:-1])
self.worker3 = SerialWorker(3, lines[10][:-1], lines[11][:-1])
self.worker4 = SerialWorker(4, lines[15][:-1], lines[16][:-1])
self.worker5 = SerialWorker(5, lines[20][:-1], lines[21][:-1])
self.worker6 = SerialWorker(6, lines[25][:-1], lines[26][:-1])
self.worker7 = SerialWorker(7, lines[30][:-1], lines[31][:-1])
self.worker8 = SerialWorker(8, lines[35][:-1], lines[36][:-1])
self.worker9 = SerialWorker(9, lines[40][:-1], lines[41][:-1])
self.worker10 = SerialWorker(10, lines[45][:-1], lines[46][:-1])
self.worker1.moveToThread(self.thread1)
self.thread1.started.connect(self.worker1.task)
self.thread1.start()
self.worker2.moveToThread(self.thread2)
self.thread2.started.connect(self.worker2.task)
self.thread2.start()
self.worker3.moveToThread(self.thread3)
self.thread3.started.connect(self.worker3.task)
self.thread3.start()
self.worker4.moveToThread(self.thread4)
self.thread4.started.connect(self.worker4.task)
self.thread4.start()
self.worker5.moveToThread(self.thread5)
self.thread5.started.connect(self.worker5.task)
self.thread5.start()
self.worker6.moveToThread(self.thread6)
self.thread6.started.connect(self.worker6.task)
self.thread6.start()
self.worker7.moveToThread(self.thread7)
self.thread7.started.connect(self.worker7.task)
self.thread7.start()
self.worker8.moveToThread(self.thread8)
self.thread8.started.connect(self.worker8.task)
self.thread8.start()
self.worker9.moveToThread(self.thread9)
self.thread9.started.connect(self.worker9.task)
self.thread9.start()
self.worker10.moveToThread(self.thread10)
self.thread10.started.connect(self.worker10.task)
self.thread10.start()
# Инициализируем QSystemTrayIcon
self.tray_icon = QSystemTrayIcon(self)
self.tray_icon.setIcon(QtGui.QIcon('lines.png'))
show_action = QAction("Показать", self)
quit_action = QAction("Выход", self)
hide_action = QAction("Спрятать", self)
show_action.triggered.connect(self.show)
hide_action.triggered.connect(self.hide)
quit_action.triggered.connect(qApp.quit)
tray_menu = QMenu()
tray_menu.addAction(show_action)
tray_menu.addAction(hide_action)
tray_menu.addAction(quit_action)
self.tray_icon.setContextMenu(tray_menu)
self.tray_icon.show()
from PyQt5.QtWidgets import QApplication, QSystemTrayIcon from PyQt5.QtGui import QIcon from window import Window import os, sys icon = QIcon(os.path.dirname(os.path.abspath(sys.argv[0])) + '/icon.svg') app = QApplication([]) app.setWindowIcon(icon) #set system tray icon sysicon = QSystemTrayIcon(icon) sysicon.setIcon(icon) sysicon.show() window = Window() window.addIndexPage() window.addNewPasswordPage() window.addlistPasswordsPage() window.show() sysicon.activated.connect(window.toggleTray) app.exec()
def __init__(self, app):
super().__init__()
self.app = app
self.platform = get_platform()
self.setWindowFlags(Qt.FramelessWindowHint)
self.setupUi(self)
# Read icons
self.icon_app = QIcon(":/icons/app.svg")
self.icon_star = QIcon(":/icons/star.png")
self.icon_trash = QIcon(":/icons/delete.png")
self.icon_quit = QIcon(":/icons/quit.png")
self.icon_fake = QIcon(":/icons/fake.svg")
# Read settings
self.settings = QSettings('b3d_version_manager', 'settings')
is_register_blend = self.settings.value('is_register_blend', type=bool)
self.is_run_minimized = self.settings.value('is_run_minimized',
type=bool)
is_run_on_startup = self.settings.value('is_run_on_startup', type=bool)
root_folder = self.settings.value('root_folder')
if (not root_folder) or (not os.path.isdir(root_folder)):
exe_path = os.path.dirname(sys.executable)
self.settings.setValue('root_folder', exe_path)
# Custom title bar
self.btnWiki.clicked.connect(lambda: webbrowser.open(
"https://github.com/DotBow/Blender-Version-Manager/wiki"))
self.title.setText("%s %s" % (QApplication.applicationName(),
QApplication.applicationVersion()))
self.btnClose.clicked.connect(self.hide)
self.btnMinimize.clicked.connect(self.showMinimized)
# Custom menu bar
self.actionToggleRegisterBlend.setChecked(is_register_blend)
self.actionToggleRegisterBlend.triggered.connect(
self.toggle_register_blend)
self.actionToggleRunMinimized.setChecked(self.is_run_minimized)
self.actionToggleRunMinimized.triggered.connect(
self.toggle_run_minimized)
self.actionToggleRunOnStartup.setChecked(is_run_on_startup)
self.actionToggleRunOnStartup.triggered.connect(
self.toggle_run_on_startup)
self.menubar.hide()
self.btnSettings.setMenu(self.menuFile)
self.menuFile.installEventFilter(self)
# Root folder layout
self.labelRootFolder.setText(self.settings.value('root_folder'))
self.btnSetRootFolder.clicked.connect(self.set_root_folder)
self.btnOpenRootFolder.clicked.connect(self.open_root_folder)
# Tray layout
self.blender_action = QAction(self.icon_star, "Blender ", self)
show_action = QAction("Show", self)
hide_action = QAction("Hide", self)
quit_action = QAction(self.icon_quit, "Quit", self)
self.blender_action.triggered.connect(self.open_latest_b3d)
show_action.triggered.connect(self.bring_to_front)
hide_action.triggered.connect(self.hide)
quit_action.triggered.connect(self.quit)
self.tray_menu = QMenu()
self.tray_menu.setStyleSheet(self.menuFile.styleSheet())
self.tray_menu.addAction(self.blender_action)
self.tray_menu.addAction(show_action)
self.tray_menu.addAction(hide_action)
self.tray_menu.addAction(quit_action)
self.tray_icon = QSystemTrayIcon(self.icon_app, self)
self.tray_icon.setToolTip("Blender Version Manager")
self.tray_icon.setContextMenu(self.tray_menu)
self.tray_icon.messageClicked.connect(self.bring_to_front)
self.tray_icon.activated.connect(self.onTrayIconActivated)
self.tray_icon.show()
# Version layout
self.btnUpdate.clicked.connect(self.update)
self.set_task_visible(False)
self.zeroBuildsWarning.hide()
self.layouts = []
self.collect_versions()
self.draw_list_versions()
# Custom drag behaviour
self.old_pos = self.pos()
self.pressed = False
# Update task
self.is_update_running = False
self.start_uptodate_thread()
self.taskbar_progress = None
self.left_click_timer = QTimer(self)
self.left_click_timer.setSingleShot(True)
self.left_click_timer.timeout.connect(self.bring_to_front)
"https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=and1989%40gmail%2ecom&lc=IT&item_name=Andrea%20Esposito&item_number=SerraAutoLogin¤cy_code=EUR&bn=PP%2dDonationsBF%3abtn_donate_LG%2egif%3aNonHosted",
new=2)
startTimer()
if firstRun:
LogManager.log("FirstRun procedure starting...")
changeUsername()
changePassword()
doLoginNow(None)
LogManager.log("FirstRun procedure Ended")
else:
if loginAtStartup == 'True':
doLoginNow(None)
trayIcon = QSystemTrayIcon(QIcon(icon), wParent)
# Actions
loginAction = QAction("Do Login Now", wParent, triggered=doLoginNow)
setUserAction = QAction("Set Username", wParent, triggered=changeUsername)
setPswAction = QAction("Set Password", wParent, triggered=changePassword)
setUrlAction = QAction("Set Serra URL", wParent, triggered=changeUrl)
setStartupLoginAction = QAction("Set Login at Startup",
wParent,
triggered=changeLoginAtStartup)
setIntervalAction = QAction("Set Login Interval",
wParent,
triggered=changeTime)
showLogAction = QAction("Show Log", wParent, triggered=showLog)
def __init__(self):
QMainWindow.__init__(self)
self.navigation_stack = []
self.feedback_dialog_is_open = False
self.tribler_started = False
self.tribler_settings = None
self.debug_window = None
self.core_manager = CoreManager()
self.pending_requests = {}
self.pending_uri_requests = []
self.download_uri = None
self.dialog = None
self.new_version_dialog = None
self.start_download_dialog_active = False
self.request_mgr = None
self.search_request_mgr = None
self.search_suggestion_mgr = None
self.selected_torrent_files = []
self.vlc_available = True
self.has_search_results = False
self.last_search_query = None
self.last_search_time = None
self.start_time = time.time()
self.exception_handler_called = False
sys.excepthook = self.on_exception
uic.loadUi(get_ui_file_path('mainwindow.ui'), self)
TriblerRequestManager.window = self
# Load dynamic widgets
uic.loadUi(get_ui_file_path('torrent_channel_list_container.ui'),
self.channel_page_container)
self.channel_torrents_list = self.channel_page_container.items_list
self.channel_torrents_detail_widget = self.channel_page_container.details_tab_widget
self.channel_torrents_detail_widget.initialize_details_widget()
self.channel_torrents_list.itemClicked.connect(
self.channel_page.clicked_item)
uic.loadUi(get_ui_file_path('torrent_channel_list_container.ui'),
self.search_page_container)
self.search_results_list = self.search_page_container.items_list
self.search_torrents_detail_widget = self.search_page_container.details_tab_widget
self.search_torrents_detail_widget.initialize_details_widget()
self.search_results_list.itemClicked.connect(
self.on_channel_item_click)
self.search_results_list.itemClicked.connect(
self.search_results_page.clicked_item)
def on_state_update(new_state):
self.loading_text_label.setText(new_state)
self.core_manager.core_state_update.connect(on_state_update)
self.magnet_handler = MagnetHandler(self.window)
QDesktopServices.setUrlHandler("magnet", self.magnet_handler,
"on_open_magnet_link")
QCoreApplication.setOrganizationDomain("nl")
QCoreApplication.setOrganizationName("TUDelft")
QCoreApplication.setApplicationName("Tribler")
QCoreApplication.setAttribute(Qt.AA_UseHighDpiPixmaps)
self.read_settings()
self.debug_pane_shortcut = QShortcut(QKeySequence("Ctrl+d"), self)
self.debug_pane_shortcut.activated.connect(
self.clicked_menu_button_debug)
# Remove the focus rect on OS X
for widget in self.findChildren(QLineEdit) + self.findChildren(
QListWidget) + self.findChildren(QTreeWidget):
widget.setAttribute(Qt.WA_MacShowFocusRect, 0)
self.menu_buttons = [
self.left_menu_button_home, self.left_menu_button_search,
self.left_menu_button_my_channel,
self.left_menu_button_subscriptions,
self.left_menu_button_video_player,
self.left_menu_button_downloads, self.left_menu_button_discovered
]
self.video_player_page.initialize_player()
self.search_results_page.initialize_search_results_page()
self.settings_page.initialize_settings_page()
self.subscribed_channels_page.initialize()
self.edit_channel_page.initialize_edit_channel_page()
self.downloads_page.initialize_downloads_page()
self.home_page.initialize_home_page()
self.loading_page.initialize_loading_page()
self.discovering_page.initialize_discovering_page()
self.discovered_page.initialize_discovered_page()
self.trust_page.initialize_trust_page()
self.stackedWidget.setCurrentIndex(PAGE_LOADING)
# Create the system tray icon
if QSystemTrayIcon.isSystemTrayAvailable():
self.tray_icon = QSystemTrayIcon()
self.tray_icon.setIcon(
QIcon(QPixmap(get_image_path('tribler.png'))))
self.tray_icon.show()
else:
self.tray_icon = None
self.hide_left_menu_playlist()
self.left_menu_button_debug.setHidden(True)
self.top_menu_button.setHidden(True)
self.left_menu.setHidden(True)
self.trust_button.setHidden(True)
self.settings_button.setHidden(True)
self.add_torrent_button.setHidden(True)
self.top_search_bar.setHidden(True)
# Set various icons
self.top_menu_button.setIcon(QIcon(get_image_path('menu.png')))
self.search_completion_model = QStringListModel()
completer = QCompleter()
completer.setModel(self.search_completion_model)
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.item_delegate = QStyledItemDelegate()
completer.popup().setItemDelegate(self.item_delegate)
completer.popup().setStyleSheet("""
QListView {
background-color: #404040;
}
QListView::item {
color: #D0D0D0;
padding-top: 5px;
padding-bottom: 5px;
}
QListView::item:hover {
background-color: #707070;
}
""")
self.top_search_bar.setCompleter(completer)
# Toggle debug if developer mode is enabled
self.window().left_menu_button_debug.setHidden(not get_gui_setting(
self.gui_settings, "debug", False, is_bool=True))
self.core_manager.start()
self.core_manager.events_manager.received_search_result_channel.connect(
self.search_results_page.received_search_result_channel)
self.core_manager.events_manager.received_search_result_torrent.connect(
self.search_results_page.received_search_result_torrent)
self.core_manager.events_manager.torrent_finished.connect(
self.on_torrent_finished)
self.core_manager.events_manager.new_version_available.connect(
self.on_new_version_available)
self.core_manager.events_manager.tribler_started.connect(
self.on_tribler_started)
self.core_manager.events_manager.low_storage_signal.connect(
self.on_low_storage)
# Install signal handler for ctrl+c events
def sigint_handler(*_):
self.close_tribler()
signal.signal(signal.SIGINT, sigint_handler)
self.installEventFilter(self.video_player_page)
self.show()
def initUI(self):
self._TaskbarIconRed = QIcon('TaskbarIconRed.png')
self._TaskbarIconAmber = QIcon('TaskbarIconAmber.png')
self._TaskbarIconGreen = QIcon('TaskbarIconGreen.png')
self._TaskbarIconBlue = QIcon('TaskbarIconBlue.png')
self.setWindowIcon(self._TaskbarIconBlue)
self._TrayIconRed = QIcon('TrayIconRed.png')
self._TrayIconAmber = QIcon('TrayIconAmber.png')
self._TrayIconGreen = QIcon('TrayIconGreen.png')
self._TrayIconBlue = QIcon('TrayIconBlue.png')
self._Tray = QSystemTrayIcon(self._TrayIconBlue, self)
self._Tray.show()
grid = QGridLayout()
grid.setVerticalSpacing(30)
grid.setHorizontalSpacing(50)
self.setLayout(grid)
#position is a grid of (y, x) coords
# position = (y, x)
self._Settings = SettingsWindow(self.User)
self._Title = QLabel()
self._Title.setText('BipBot UI')
grid.addWidget(self._Title, 0, 0, 1, 4)
self._NameArea = QLineEdit()
self._NameArea.setPlaceholderText('Name')
self._NameArea.textChanged.connect(self.update_name)
grid.addWidget(self._NameArea, 1, 0, 1, 4)
self._GuildsDrop = QComboBox()
self._GuildsDrop.currentIndexChanged.connect(
self.show_channels_of_guild, self._GuildsDrop.currentIndex())
grid.addWidget(self._GuildsDrop, 2, 0, 1, 4)
self._GuildsTooltip = QLabel()
self._GuildsTooltip.setText('Guilds')
grid.addWidget(self._GuildsTooltip, 2, 4, 1, 2)
self._ChannelsDrop = QComboBox()
self._ChannelsDrop.currentIndexChanged.connect(
self.show_channel_settings, self._ChannelsDrop.currentIndex())
grid.addWidget(self._ChannelsDrop, 2, 6, 1, 4)
self._ChannelsTooltip = QLabel()
self._ChannelsTooltip.setText('Channels')
grid.addWidget(self._ChannelsTooltip, 2, 10, 1, 3)
self._NewGuildArea = QLineEdit()
self._NewGuildArea.setPlaceholderText('Guild ID')
grid.addWidget(self._NewGuildArea, 3, 0, 1, 4)
self._NewGuildButton = QPushButton()
self._NewGuildButton.setText('Add')
self._NewGuildButton.clicked.connect(self.add_guild)
grid.addWidget(self._NewGuildButton, 3, 4, 1, 2)
self._ChannelBipNumberLabel = QLabel()
self._ChannelBipNumberLabel.setText('Required to bip:')
grid.addWidget(self._ChannelBipNumberLabel, 3, 6, 1, 3)
self._ChannelBigBipNumber = QLineEdit()
self._ChannelBigBipNumber.setValidator(QIntValidator())
self._ChannelBigBipNumber.setPlaceholderText('Big')
self._ChannelBigBipNumber.textChanged.connect(self.bigbip_change)
grid.addWidget(self._ChannelBigBipNumber, 3, 9, 1, 2)
self._ChannelSmolBipNumber = QLineEdit()
self._ChannelSmolBipNumber.setValidator(QIntValidator())
self._ChannelSmolBipNumber.setPlaceholderText('Smol')
self._ChannelSmolBipNumber.textChanged.connect(self.smolbip_change)
grid.addWidget(self._ChannelSmolBipNumber, 3, 11, 1, 2)
self._RemoveCurrentGuild = QPushButton()
self._RemoveCurrentGuild.setText('Remove Selected Guild')
self._RemoveCurrentGuild.clicked.connect(
self.remove_guild, self._GuildsDrop.currentIndex())
grid.addWidget(self._RemoveCurrentGuild, 4, 0, 1, 6)
self._IgnoreChannelTooltip = QLabel()
self._IgnoreChannelTooltip.setText('Ignore Selected Channel')
grid.addWidget(self._IgnoreChannelTooltip, 4, 6, 1, 4)
self._IgnoreChannelBox = QCheckBox()
self._IgnoreChannelBox.stateChanged.connect(self.ignore_channel_press)
grid.addWidget(self._IgnoreChannelBox, 4, 10, 1, 2)
picture = QPixmap('settings-cog.png')
settings_height = self.frameGeometry().height()
settings_width = self.frameGeometry().width()
self._SettingsButton = QPicButton(
picture, QRect(0, 0, settings_height / 9, settings_width / 16))
self._SettingsButton.clicked.connect(self._Settings.open)
grid.addWidget(self._SettingsButton, 5, 10, 1, 2)
self._channelIDArea = QLineEdit()
self._excludesArea = QLineEdit()
#self.setGeometry(300, 300, 300, 220)
self.setWindowTitle('BipApp')
def __init__(self,
device_name=None,
container_path=None,
key_file=None,
mount_point=None):
""" Command line arguments checks are done here to be able to display a graphical dialog with error messages .
If no arguments were supplied on the command line a setup dialog will be shown.
All commands will be executed from a separate worker process with administrator privileges that gets initialized here.
:param device_name: The device mapper name
:type device_name: str/unicode or None
:param container_path: The path of the container file
:type container_path: str/unicode or None
:param key_file: The path of an optional key file
:type key_file: str/unicode or None
:param mount_point: The path of an optional mount point
:type mount_point: str/unicode or None
"""
super(MainWindow, self).__init__()
self.luks_device_name = device_name
self.encrypted_container = container_path
self.key_file = key_file
self.mount_point = mount_point
self.worker = None
self.is_waiting_for_worker = False
self.is_unlocked = False
self.is_initialized = False
self.has_tray = QSystemTrayIcon.isSystemTrayAvailable()
# L10n: program name - translatable for startmenu titlebar etc
self.setWindowTitle(_('luckyLUKS'))
self.setWindowIcon(
QIcon.fromTheme(
'dialog-password',
QApplication.style().standardIcon(QStyle.SP_DriveHDIcon)))
# check if cryptsetup and sudo are installed
not_installed_msg = _(
'{program_name} executable not found!\nPlease install, eg for Debian/Ubuntu\n`apt-get install {program_name}`'
)
if not utils.is_installed('cryptsetup'):
show_alert(self,
not_installed_msg.format(program_name='cryptsetup'),
critical=True)
if not utils.is_installed('sudo'):
show_alert(self,
not_installed_msg.format(program_name='sudo'),
critical=True)
# quick sanity checks before asking for passwd
if os.getuid() == 0:
show_alert(
self,
_('Graphical programs should not be run as root!\nPlease call as normal user.'
),
critical=True)
if self.encrypted_container and not os.path.exists(
self.encrypted_container):
show_alert(
self,
_('Container file not accessible\nor path does not exist:\n\n{file_path}'
).format(file_path=self.encrypted_container),
critical=True)
# only either encrypted_container or luks_device_name supplied
if bool(self.encrypted_container) != bool(self.luks_device_name):
show_alert(
self,
_('Invalid arguments:\n'
'Please call without any arguments\n'
'or supply both container and name.\n\n'
'<b>{executable} -c CONTAINER -n NAME [-m MOUNTPOINT]</b>\n\n'
'CONTAINER = Path of the encrypted container file\n'
'NAME = A (unique) name to identify the unlocked container\n'
'Optional: MOUNTPOINT = where to mount the encrypted filesystem\n\n'
'If automatic mounting is configured on your system,\n'
'explicitly setting a mountpoint is not required\n\n'
'For more information, visit\n'
'<a href="{project_url}">{project_url}</a>').format(
executable=os.path.basename(sys.argv[0]),
project_url=PROJECT_URL),
critical=True)
# spawn worker process with root privileges
try:
self.worker = utils.WorkerMonitor(self)
# start communication thread
self.worker.start()
except utils.SudoException as se:
show_alert(self, format_exception(se), critical=True)
return
# if no arguments supplied, display dialog to gather this information
if self.encrypted_container is None and self.luks_device_name is None:
from luckyLUKS.setupUI import SetupDialog
sd = SetupDialog(self)
if sd.exec_() == QDialog.Accepted:
self.luks_device_name = sd.get_luks_device_name()
self.encrypted_container = sd.get_encrypted_container()
self.mount_point = sd.get_mount_point()
self.key_file = sd.get_keyfile()
self.is_unlocked = True # all checks in setup dialog -> skip initializing state
else:
# user closed dialog -> quit program
# and check if a keyfile create thread has to be stopped
# the worker process terminates itself when its parent dies
if hasattr(sd,
'create_thread') and sd.create_thread.isRunning():
sd.create_thread.terminate()
QApplication.instance().quit()
return
# center window on desktop
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
# widget content
main_grid = QGridLayout()
main_grid.setSpacing(10)
icon = QLabel()
icon.setPixmap(
QIcon.fromTheme(
'dialog-password',
QApplication.style().standardIcon(
QStyle.SP_DriveHDIcon)).pixmap(32))
main_grid.addWidget(icon, 0, 0)
main_grid.addWidget(QLabel('<b>' + _('Handle encrypted container') +
'</b>\n'),
0,
1,
alignment=Qt.AlignCenter)
main_grid.addWidget(QLabel(_('Name:')), 1, 0)
main_grid.addWidget(QLabel(
'<b>{dev_name}</b>'.format(dev_name=self.luks_device_name)),
1,
1,
alignment=Qt.AlignCenter)
main_grid.addWidget(QLabel(_('File:')), 2, 0)
main_grid.addWidget(QLabel(self.encrypted_container),
2,
1,
alignment=Qt.AlignCenter)
if self.key_file is not None:
main_grid.addWidget(QLabel(_('Key:')), 3, 0)
main_grid.addWidget(QLabel(self.key_file),
3,
1,
alignment=Qt.AlignCenter)
if self.mount_point is not None:
main_grid.addWidget(QLabel(_('Mount:')), 4, 0)
main_grid.addWidget(QLabel(self.mount_point),
4,
1,
alignment=Qt.AlignCenter)
main_grid.addWidget(QLabel(_('Status:')), 5, 0)
self.label_status = QLabel('')
main_grid.addWidget(self.label_status, 5, 1, alignment=Qt.AlignCenter)
self.button_toggle_status = QPushButton('')
self.button_toggle_status.setMinimumHeight(34)
self.button_toggle_status.clicked.connect(self.toggle_container_status)
main_grid.setRowMinimumHeight(6, 10)
main_grid.addWidget(self.button_toggle_status, 7, 1)
widget = QWidget()
widget.setLayout(main_grid)
widget.setContentsMargins(10, 10, 10, 10)
self.setCentralWidget(widget)
# tray popup menu
if self.has_tray:
tray_popup = QMenu(self)
tray_popup.addAction(
QIcon.fromTheme(
'dialog-password',
QApplication.style().standardIcon(QStyle.SP_DriveHDIcon)),
self.luks_device_name).setEnabled(False)
tray_popup.addSeparator()
self.tray_toggle_action = QAction(
QApplication.style().standardIcon(QStyle.SP_DesktopIcon),
_('Hide'), self)
self.tray_toggle_action.triggered.connect(self.toggle_main_window)
tray_popup.addAction(self.tray_toggle_action)
quit_action = QAction(
QApplication.style().standardIcon(
QStyle.SP_MessageBoxCritical), _('Quit'), self)
quit_action.triggered.connect(self.tray_quit)
tray_popup.addAction(quit_action)
# systray
self.tray = QSystemTrayIcon(self)
self.tray.setIcon(
QIcon.fromTheme(
'dialog-password',
QApplication.style().standardIcon(QStyle.SP_DriveHDIcon)))
self.tray.setContextMenu(tray_popup)
self.tray.activated.connect(self.toggle_main_window)
self.tray.show()
self.init_status()
def __init__(self):
self.snapshots = snapshots.Snapshots()
self.config = self.snapshots.config
self.decode = None
if len(sys.argv) > 1:
if not self.config.setCurrentProfile(sys.argv[1]):
logger.warning("Failed to change Profile_ID %s" % sys.argv[1],
self)
self.qapp = qttools.createQApplication(self.config.APP_NAME)
translator = qttools.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.profileName())
qttools.setFontBold(self.menuProfileName)
self.contextMenu.addSeparator()
self.menuStatusMessage = self.contextMenu.addAction(_('Done'))
self.menuProgress = self.contextMenu.addAction('')
self.menuProgress.setVisible(False)
self.contextMenu.addSeparator()
self.btnPause = self.contextMenu.addAction(icon.PAUSE,
_('Pause snapshot process'))
action = lambda: os.kill(self.snapshots.pid(), signal.SIGSTOP)
self.btnPause.triggered.connect(action)
self.btnResume = self.contextMenu.addAction(
icon.RESUME, _('Resume snapshot process'))
action = lambda: os.kill(self.snapshots.pid(), signal.SIGCONT)
self.btnResume.triggered.connect(action)
self.btnResume.setVisible(False)
self.btnStop = self.contextMenu.addAction(icon.STOP,
_('Stop snapshot process'))
self.btnStop.triggered.connect(self.onBtnStop)
self.contextMenu.addSeparator()
self.btnDecode = self.contextMenu.addAction(icon.VIEW_SNAPSHOT_LOG,
_('decode paths'))
self.btnDecode.setCheckable(True)
self.btnDecode.setVisible(self.config.snapshotsMode() == 'ssh_encfs')
self.btnDecode.toggled.connect(self.onBtnDecode)
self.openLog = self.contextMenu.addAction(icon.VIEW_LAST_LOG,
_('View Last Log'))
self.openLog.triggered.connect(self.onOpenLog)
self.startBIT = self.contextMenu.addAction(icon.BIT_LOGO,
_('Start BackInTime'))
self.startBIT.triggered.connect(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.notify()
self.popup = None
self.last_message = None
self.timer = QTimer()
self.timer.timeout.connect(self.updateInfo)
def __init__(self, icon):
QtCore.QThread.__init__(self)
self.menu = QMenu()
self.icon = QSystemTrayIcon(QtGui.QIcon(icon))
self.flag_exit = True
self.first = True
def createTrayIcon(self):
self.trayIcon = QSystemTrayIcon(self)
self.trayIcon.setIcon(QIcon("images/trash.png"))
def __init__(self, app):
super().__init__()
self.app = app
self.setupUi(self)
# Read Icons
self.app_icon = QIcon(":/icons/app.svg")
self.star_icon = QIcon(":/icons/star.svg")
self.star_inv_icon = QIcon(":/icons/star_inv.svg")
self.trash_icon = QIcon(":/icons/delete.svg")
self.quit_icon = QIcon(":/icons/quit_inv.svg")
self.fake_icon = QIcon(":/icons/fake.svg")
# Read Settings
self.settings = QSettings('b3d_version_manager', 'settings')
self.is_run_minimized = self.settings.value(
'is_run_minimized', type=bool)
is_run_on_startup = self.settings.value(
'is_run_on_startup', type=bool)
root_folder = self.settings.value('root_folder')
if (not root_folder) or (not os.path.isdir(root_folder)):
exe_path = os.path.dirname(sys.executable)
self.settings.setValue('root_folder', exe_path)
# Custom Title Bar
self.btnClose.clicked.connect(self.close)
self.btnMinimize.clicked.connect(self.showMinimized)
# Custom Menu Bar
self.actionToggleRunMinimized.setChecked(self.is_run_minimized)
self.actionToggleRunMinimized.triggered.connect(
self.toggle_run_minimized)
self.actionToggleRunOnStartup.setChecked(is_run_on_startup)
self.actionToggleRunOnStartup.triggered.connect(
self.toggle_run_on_startup)
self.actionClearTempFolder.triggered.connect(self.clear_temp_folder)
self.actionQuit.triggered.connect(self.quit)
self.menubar.hide()
self.btnFile.setMenu(self.menuFile)
# Root Folder Layout
self.labelRootFolder.setText(self.settings.value('root_folder'))
self.btnSetRootFolder.clicked.connect(self.set_root_folder)
self.btnOpenRootFolder.clicked.connect(
lambda: os.startfile(self.settings.value('root_folder')))
# Tray Layout
self.blender_action = QAction(self.star_inv_icon, "Blender", self)
show_action = QAction("Show", self)
hide_action = QAction("Hide", self)
quit_action = QAction(self.quit_icon, "Quit", self)
show_action.triggered.connect(self.bring_to_front)
hide_action.triggered.connect(self.hide)
quit_action.triggered.connect(self.quit)
self.tray_menu = QMenu()
self.tray_menu.addAction(self.blender_action)
self.tray_menu.addSeparator()
self.tray_menu.addAction(show_action)
self.tray_menu.addAction(hide_action)
self.tray_menu.addAction(quit_action)
self.tray_icon = QSystemTrayIcon(self.app_icon, self)
self.tray_icon.setContextMenu(self.tray_menu)
self.tray_icon.messageClicked.connect(self.bring_to_front)
self.tray_icon.activated.connect(
lambda btn: self.bring_to_front() if btn == 3 else False)
self.tray_icon.show()
# Version Layout
self.btnUpdate.clicked.connect(self.update)
self.set_task_visible(False)
self.draw_list_versions()
# Custom Drag Behaviour
self.old_pos = self.pos()
self.pressed = False
# Update Task
self.is_update_running = False
self.uptodate_silent = False
self.uptodate_thread = CheckForUpdates(self)
self.uptodate_thread.new_version_obtained.connect(
self.show_new_version)
self.uptodate_thread.start()
show_ui()
song_queue = SongQueue()
image_queue = ImageQueue()
# Command Handler
command_handler = CommandHandler(sp, song_queue)
# UI
ui = Ui(sp, command_handler)
# Create icon
icon = QIcon(f"{ASSETS_DIR}img{sep}logo_small.png")
# Create tray
tray = QSystemTrayIcon()
tray.setIcon(icon)
tray.setVisible(True)
tray.setToolTip("Spotlightify")
# Create menu
menu = QMenu()
open_ui = QAction("Open")
open_ui.triggered.connect(show_ui)
menu.addAction(open_ui)
exit_ = QAction("Exit")
exit_.triggered.connect(lambda: PlaybackManager(sp, song_queue).exit_app())
menu.addAction(exit_)
listener_thread = Thread(target=listener, daemon=True, args=(open_ui,))
# return x
def pretty(html):
return BeautifulSoup(html, features='lxml').prettify()
if __name__ == '__main__':
client = CachedHttpClient(HttpClient(), 'cache')
golden_dict_proxy = GoldenDictProxy(client, 'localhost', 5660)
golden_dict_proxy.serve_background()
app = QApplication(sys.argv)
window = MainWindow(app)
tray = QSystemTrayIcon(QIcon(dirname(__file__) + '/ordbok_uib_no.png'),
app)
menu = QMenu()
show = QAction('Show')
hide = QAction('Hide')
quit = QAction('Quit')
show.triggered.connect(window.show)
hide.triggered.connect(window.hide)
quit.triggered.connect(window.close)
menu.addAction(show)
menu.addAction(hide)
menu.addAction(quit)
tray.setContextMenu(menu)
tray.activated.connect(window.onTrayActivated)
tray.show()
dog.observe(window.activate)
def __init__(self, parent=None):
super(MainWindow, self).__init__()
self.statusBar().showMessage("Move Dial to Deform Microphone Voice !.")
self.setWindowTitle(__doc__)
self.setMinimumSize(240, 240)
self.setMaximumSize(480, 480)
self.resize(self.minimumSize())
self.setWindowIcon(QIcon.fromTheme("audio-input-microphone"))
self.tray = QSystemTrayIcon(self)
self.center()
QShortcut("Ctrl+q", self, activated=lambda: self.close())
self.menuBar().addMenu("&File").addAction("Quit", lambda: exit())
self.menuBar().addMenu("Sound").addAction(
"STOP !", lambda: call('killall rec', shell=True))
windowMenu = self.menuBar().addMenu("&Window")
windowMenu.addAction("Hide", lambda: self.hide())
windowMenu.addAction("Minimize", lambda: self.showMinimized())
windowMenu.addAction("Maximize", lambda: self.showMaximized())
windowMenu.addAction("Restore", lambda: self.showNormal())
windowMenu.addAction("FullScreen", lambda: self.showFullScreen())
windowMenu.addAction("Center", lambda: self.center())
windowMenu.addAction("Top-Left", lambda: self.move(0, 0))
windowMenu.addAction("To Mouse", lambda: self.move_to_mouse_position())
# widgets
group0 = QGroupBox("Voice Deformation")
self.setCentralWidget(group0)
self.process = QProcess(self)
self.process.error.connect(
lambda: self.statusBar().showMessage("Info: Process Killed", 5000))
self.control = QDial()
self.control.setRange(-10, 20)
self.control.setSingleStep(5)
self.control.setValue(0)
self.control.setCursor(QCursor(Qt.OpenHandCursor))
self.control.sliderPressed.connect(
lambda: self.control.setCursor(QCursor(Qt.ClosedHandCursor)))
self.control.sliderReleased.connect(
lambda: self.control.setCursor(QCursor(Qt.OpenHandCursor)))
self.control.valueChanged.connect(
lambda: self.control.setToolTip("<b>" + str(self.control.value())))
self.control.valueChanged.connect(lambda: self.statusBar().showMessage(
"Voice deformation: " + str(self.control.value()), 5000))
self.control.valueChanged.connect(self.run)
self.control.valueChanged.connect(lambda: self.process.kill())
# Graphic effect
self.glow = QGraphicsDropShadowEffect(self)
self.glow.setOffset(0)
self.glow.setBlurRadius(99)
self.glow.setColor(QColor(99, 255, 255))
self.control.setGraphicsEffect(self.glow)
self.glow.setEnabled(False)
# Timer to start
self.slider_timer = QTimer(self)
self.slider_timer.setSingleShot(True)
self.slider_timer.timeout.connect(self.on_slider_timer_timeout)
# an icon and set focus
QLabel(self.control).setPixmap(
QIcon.fromTheme("audio-input-microphone").pixmap(32))
self.control.setFocus()
QVBoxLayout(group0).addWidget(self.control)
self.menu = QMenu(__doc__)
self.menu.addAction(__doc__).setDisabled(True)
self.menu.setIcon(self.windowIcon())
self.menu.addSeparator()
self.menu.addAction(
"Show / Hide", lambda: self.hide()
if self.isVisible() else self.showNormal())
self.menu.addAction("STOP !", lambda: call('killall rec', shell=True))
self.menu.addSeparator()
self.menu.addAction("Quit", lambda: exit())
self.tray.setContextMenu(self.menu)
self.make_trayicon()
def setup_ui(self):
self.setAttribute(Qt.WA_DeleteOnClose)
self.setWindowIcon(QIcon(IconsHub.Xyplayer))
self.setFocusPolicy(Qt.NoFocus)
self.setObjectName(app_name)
self.setWindowFlags(Qt.MSWindowsFixedSizeDialogHint
| Qt.FramelessWindowHint)
self.setMaximumSize(
QSize(Configures.WindowWidth, Configures.WindowHeight))
self.setGeometry(
(Configures.DesktopSize.width() - Configures.WindowWidth) // 2,
(Configures.DesktopSize.height() - Configures.WindowHeight) // 2,
Configures.WindowWidth, Configures.WindowHeight)
self.setAttribute(Qt.WA_QuitOnClose, True)
self.dragPosition = QPoint(0, 0)
self.mousePressedFlag = False
#title_widgets
self.titleIconLabel = QLabel()
pixmap = QPixmap(IconsHub.Xyplayer)
self.titleIconLabel.setFixedSize(18, 18)
self.titleIconLabel.setScaledContents(True)
self.titleIconLabel.setPixmap(pixmap)
self.titleLabel = QLabel("XYPLAYER")
self.titleLabel.setObjectName('titleLabel')
self.titleLabel.setFixedHeight(30)
self.titleLabel.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.titleLabel.setObjectName('titleLabel')
self.minButton = PushButton()
self.minButton.setToolTip(self.tr('最小化'))
self.minButton.setFocusPolicy(Qt.NoFocus)
self.closeButton = PushButton()
self.closeButton.setToolTip(self.tr('关闭主面板'))
self.closeButton.setFocusPolicy(Qt.NoFocus)
self.aboutButton = PushButton()
self.aboutButton.setToolTip(self.tr('关于'))
self.aboutButton.setFocusPolicy(Qt.NoFocus)
self.preferenceButton = PushButton()
self.preferenceButton.setToolTip(self.tr('选项'))
self.preferenceButton.setFocusPolicy(Qt.NoFocus)
self.minButton.loadPixmap(IconsHub.MinButton)
self.closeButton.loadPixmap(IconsHub.CloseButton)
self.aboutButton.loadPixmap(IconsHub.AboutButton)
self.preferenceButton.loadPixmap(IconsHub.PreferenceButton)
#管理页面
self.managePage = manage_page.ManagePage()
#播放器
self.playbackPanel = playback_panel.PlaybackPanel()
self.mainPageButton = QToolButton(self, clicked=self.show_lyric_text)
self.mainPageButton.setToolTip('返回歌词页面')
self.mainPageButton.hide()
self.mainPageButton.setGeometry(625, 5, 30, 30)
self.mainPageButton.setObjectName('homeButton')
self.mainPageButton.setFocusPolicy(Qt.NoFocus)
self.mainPageButton.setIcon(QIcon(IconsHub.Home))
self.mainPageButton.setIconSize(QSize(20, 20))
self.pageLabel = QLabel(self)
self.pageLabel.setObjectName('pageLabel')
self.pageLabel.hide()
self.pageLabel.setGeometry(660, 5, 100, 30)
self.searchBox = search_page.SearchBox(self)
self.searchBox.setGeometry(180, 6, 280, 28)
#综合布局
titleLayout = QHBoxLayout()
titleLayout.setContentsMargins(3, 0, 0, 0)
titleLayout.setSpacing(0)
titleLayout.addWidget(self.titleIconLabel)
titleLayout.addSpacing(2)
titleLayout.addWidget(self.titleLabel)
titleLayout.addStretch()
titleLayout.addWidget(self.aboutButton)
titleLayout.addWidget(self.preferenceButton)
titleLayout.addWidget(self.minButton)
titleLayout.addWidget(self.closeButton)
#主堆栈框
self.mainStack = QStackedWidget()
mainLayout = QVBoxLayout(self)
mainLayout.setSpacing(2)
mainLayout.setContentsMargins(3, 0, 3, 0)
mainLayout.addLayout(titleLayout)
mainLayout.addWidget(self.managePage)
mainLayout.addWidget(self.playbackPanel)
#创建托盘图标
self.trayIcon = QSystemTrayIcon(self)
self.trayIcon.setIcon(QIcon(IconsHub.Xyplayer))
self.showDesktopLyricAction = QAction(
QIcon(IconsHub.DesktopLyric),
"开启桌面歌词",
self,
triggered=self.playbackPanel.show_desktop_lyric)
trayMenu = QMenu()
trayMenu.addAction(self.showMainWindowAction)
trayMenu.addAction(self.showDesktopLyricAction)
trayMenu.addSeparator()
trayMenu.addAction(self.playbackPanel.get_previous_button_action())
trayMenu.addAction(self.playbackPanel.get_play_button_action())
trayMenu.addAction(self.playbackPanel.get_next_button_action())
trayMenu.addAction(self.playbackPanel.get_stop_button_action())
trayMenu.addSeparator()
trayMenu.addAction(self.playmodeRandomAction)
trayMenu.addAction(self.playmodeOrderAction)
trayMenu.addAction(self.playmodeSingleAction)
trayMenu.addSeparator()
trayMenu.addAction(self.exitNowAction)
self.trayIcon.setContextMenu(trayMenu)
self.trayIcon.show()
def __init__(self, parent=None):
super(SystemTrayIcon, self).__init__(parent)
self.setAttribute(Qt.WA_DeleteOnClose)
self.settings = QSettings()
self.language = self.settings.value('Language') or ''
self.temp_decimal_bool = self.settings.value('Decimal') or False
# initialize the tray icon type in case of first run: issue#42
self.tray_type = self.settings.value('TrayType') or 'icon&temp'
cond = conditions.WeatherConditions()
self.temporary_city_status = False
self.conditions = cond.trans
self.clouds = cond.clouds
self.wind = cond.wind
self.wind_dir = cond.wind_direction
self.wind_codes = cond.wind_codes
self.inerror = False
self.tentatives = 0
self.baseurl = 'http://api.openweathermap.org/data/2.5/weather?id='
self.accurate_url = 'http://api.openweathermap.org/data/2.5/find?q='
self.forecast_url = ('http://api.openweathermap.org/data/2.5/forecast/'
'daily?id=')
self.day_forecast_url = ('http://api.openweathermap.org/data/2.5/'
'forecast?id=')
self.wIconUrl = 'http://openweathermap.org/img/w/'
apikey = self.settings.value('APPID') or ''
self.appid = '&APPID=' + apikey
self.forecast_icon_url = self.wIconUrl
self.timer = QTimer(self)
self.timer.timeout.connect(self.refresh)
self.menu = QMenu()
self.citiesMenu = QMenu(self.tr('Cities'))
if os.environ.get('DESKTOP_SESSION') == 'ubuntu':
# Missing left click on Unity environment issue 63
self.panelAction = QAction(
QCoreApplication.translate(
"Tray context menu", "Toggle Window",
"Open/closes the application window"), self)
self.panelAction.setIcon(QIcon(':/panel'))
self.menu.addAction(self.panelAction)
self.panelAction.triggered.connect(self.showpanel)
self.tempCityAction = QAction(self.tr('&Temporary city'), self)
self.refreshAction = QAction(self.tr('&Update'), self)
self.settingsAction = QAction(self.tr('&Settings'), self)
self.aboutAction = QAction(self.tr('&About'), self)
self.exitAction = QAction(self.tr('Exit'), self)
self.exitAction.setIcon(QIcon(':/exit'))
self.aboutAction.setIcon(QIcon(':/info'))
self.refreshAction.setIcon(QIcon(':/refresh'))
self.settingsAction.setIcon(QIcon(':/configure'))
self.tempCityAction.setIcon(QIcon(':/tempcity'))
self.citiesMenu.setIcon(QIcon(':/bookmarks'))
self.menu.addAction(self.settingsAction)
self.menu.addAction(self.refreshAction)
self.menu.addMenu(self.citiesMenu)
self.menu.addAction(self.tempCityAction)
self.menu.addAction(self.aboutAction)
self.menu.addAction(self.exitAction)
self.settingsAction.triggered.connect(self.config)
self.exitAction.triggered.connect(qApp.quit)
self.refreshAction.triggered.connect(self.manual_refresh)
self.aboutAction.triggered.connect(self.about)
self.tempCityAction.triggered.connect(self.tempcity)
self.systray = QSystemTrayIcon()
self.systray.setContextMenu(self.menu)
self.systray.activated.connect(self.activate)
self.systray.setIcon(QIcon(':/noicon'))
self.systray.setToolTip(self.tr('Searching weather data...'))
self.notification = ''
self.notification_temp = 0
self.notifications_id = ''
self.systray.show()
# The dictionnary has to be intialized here. If there is an error
# the program couldn't become functionnal if the dictionnary is
# reinitialized in the weatherdata method
self.weatherDataDico = {}
# The traycolor has to be initialized here for the case when we cannot
# reach the tray method (case: set the color at first time usage)
self.traycolor = ''
self.refresh()
def __init__(self, ctx):
super().__init__()
self.ctx = ctx
uic.loadUi(self.ctx.get_resource("MainWindow.ui"), self)
# QDialogs
self.track_window = TrackNumberWindow(self.ctx)
self.info_window = InfoWindow(self.ctx)
self.contacts_window = ContactsWindow(self.ctx)
self.sync_settings_window = SyncSettingsWindow(self.ctx)
self.app_setting_window = SettingsWindow(self.ctx)
self.archive_window = ArchiveWindow(self.ctx)
# Если запустить апу и не войти в настройки, то проверка статуса чекбокса трея не сработает
# TODO я не знаю, куда это засунуть, пока пусть будет здесь
with session_scope() as session:
user = session.query(User).first()
self.app_setting_window.TrayCheckBox.setChecked(
user.system_tray_status)
# System tray icon setup
self.tray_icon = QSystemTrayIcon()
self.tray_icon.setIcon(
QtGui.QIcon(ctx.get_resource("ui_imgs/icon.png")))
self.tray_icon.show()
self.tray_icon.setContextMenu(self.build_tray_icon_menu())
self.tray_icon.activated.connect(self.tray_icon_activated_handler)
# Status bar setup
self.statusbar.setStyleSheet("color: black")
self.statusbar.showMessage("App started")
"""
Top widget buttons
"""
# Buttons icons set
green_plus = self.ctx.get_resource("ui_imgs/green_plus.png")
red_minus = self.ctx.get_resource("ui_imgs/red_minus.png")
grey_arrow = self.ctx.get_resource("ui_imgs/grey_arrow.png")
# Prepare central buttons
self.AddButton.setIcon(QIcon(green_plus))
self.AddButton.clicked.connect(self.new_track_click)
self.RemoveButton.setIcon(QIcon(red_minus))
self.RemoveButton.clicked.connect(self.remove_track_click)
self.UpdateButton.setIcon(QIcon(grey_arrow))
self.UpdateButton.clicked.connect(self.update_track_click)
self.ArchiveButton.clicked.connect(self.archive_track_click)
# Prepare top bar buttons
self.InfoAction.triggered.connect(self.info_window_show)
self.ContactsAction.triggered.connect(self.contacts_window_show)
self.SyncSettingsAction.triggered.connect(
self.sync_settings_window_show)
self.SettingsAction.triggered.connect(self.app_settings_window_show)
self.ArchiveAction.triggered.connect(self.app_archive_window_show)
# Startup events
self.fill_main_tree()
# Threads
self.threadpool = QThreadPool() # prepare thread pool
self.track_window.finished_trigger.connect(self.track_code_added)
# create and and start auto-update thread
self.auto_update_tracks_thread = TrackAutoUpdateThread()
self.auto_update_tracks_thread.signals.change_statusbar.connect(
self.manual_status_set)
self.auto_update_tracks_thread.signals.message_set.connect(
self.manual_message_set)
self.auto_update_tracks_thread.signals.update_table.connect(
self.fill_main_tree)
self.auto_update_tracks_thread.start()
# Main table
self.selected_numbers = [
] # contains list of user selected rows track numbers IDX
self.clicked_row = None # contains user clicked row track number IDX
logger.info("Main window configured")
def init_desktop_app():
app = Application([])
app.setQuitOnLastWindowClosed(False)
def sigint_handler(*args):
"""Handler for the SIGINT signal."""
quit_specter(app)
# fix termination ctrl+c
signal.signal(signal.SIGINT, sigint_handler)
# This is the place to uncomment if we ever have issues like
# https://github.com/cryptoadvance/specter-desktop/issues/373 again
# So maybe let's keep it in here.
# import psutil
# print("-----------------------------------------------------------------------")
# print(psutil.Process().memory_maps())
# print("-----------------------------------------------------------------------")
# Create the icon
icon = QIcon(os.path.join(
resource_path('icons'),
'icon.png'
))
# Create the tray
tray = QSystemTrayIcon()
tray.setIcon(icon)
tray.setVisible(True)
# Create webview
view = WebView(tray)
# Create the menu
menu = QMenu()
start_specterd_menu = QAction("Start Specter{} daemon".format(
' HWIBridge' if settings.value(
"remote_mode", defaultValue=False, type=bool
) else ''
))
start_specterd_menu.triggered.connect(lambda: watch_specterd(menu, view))
menu.addAction(start_specterd_menu)
open_webview_menu = QAction("Open Specter App")
open_webview_menu.triggered.connect(lambda: open_webview(view))
menu.addAction(open_webview_menu)
open_specter_menu = QAction("Open in the browser")
open_specter_menu.triggered.connect(open_specter_window)
menu.addAction(open_specter_menu)
toggle_specterd_status(menu)
open_settings_menu = QAction("Preferences")
open_settings_menu.triggered.connect(open_settings)
menu.addAction(open_settings_menu)
# Add a Quit option to the menu.
quit = QAction("Quit")
quit.triggered.connect(lambda: quit_specter(app))
menu.addAction(quit)
# Add the menu to the tray
tray.setContextMenu(menu)
app.setWindowIcon(icon)
# Setup settings
first_time = settings.value('first_time', defaultValue=True, type=bool)
if first_time:
settings.setValue('first_time', False)
settings.setValue('remote_mode', False)
settings.setValue('specter_url', "http://localhost:25441/")
open_settings()
# start server
global specterd_thread
# add hwibridge to args
if settings.value("remote_mode", defaultValue=False, type=bool):
sys.argv.append("--hwibridge")
# start thread
specterd_thread = threading.Thread(target=server)
specterd_thread.daemon = True
specterd_thread.start()
watch_specterd(menu, view)
sys.exit(app.exec_())
def __init__(self, argv):
super().__init__(argv)
icon = QIcon(":/icon.png")
self.setQuitOnLastWindowClosed(False) # Run without windows.
self.setWindowIcon(icon)
self.account_setting_dialog = None
self.worker = Worker()
self.worker_thread = QThread()
self.worker.moveToThread(self.worker_thread)
# For convenience.
worker = self.worker
config = worker.config
acc = worker.account
# Set up tray menu.
self.tray = QSystemTrayIcon(icon, self)
self.tray_menu = QMenu()
# Status section.
self.status_action = self.add_unabled_action()
self.status_changed(worker.account.status)
self.status = acc.status
self.last_session = None
# Account info section.
self.tray_menu.addSeparator()
self.username_action = self.add_unabled_action()
self.usage_action = self.add_unabled_action()
self.balance_action = self.add_unabled_action()
self.refresh_username(config['username'])
self.refresh_account_info(None, None)
# Sessions section.
self.sessions = []
self.session_menus = []
self.last_check = None
self.tray_menu.addSeparator()
self.sessions_title_action = self.add_unabled_action()
self.last_check_action = self.add_unabled_action()
self.refresh_sessions([])
# Actions.
self.tray_menu.addSeparator()
self.tray_menu.addAction('上线').triggered.connect(acc.login)
self.tray_menu.addAction('下线').triggered.connect(acc.logout)
self.tray_menu.addAction('现在刷新').triggered.connect(acc.update_all)
# Config section.
self.tray_menu.addSeparator()
self.auto_manage_action = self.tray_menu.addAction('自动管理')
self.auto_manage_action.setCheckable(True)
self.auto_manage_action.setChecked(config['auto_manage'])
self.auto_manage_action.toggled.connect(worker.auto_manage_changed)
self.account_setting_action = self.tray_menu.addAction('账号设置...')
self.account_setting_action.triggered.connect(self.account_setting)
# About.
self.tray_menu.addSeparator()
self.tray_menu.addAction('关于').triggered.connect(self.show_about)
# Quit.
self.tray_menu.addSeparator()
self.tray_menu.addAction('退出').triggered.connect(self.quit)
self.tray.setContextMenu(self.tray_menu)
self.tray.show()
# Connect signals.
self.start_worker.connect(worker.setup)
self.username_changed.connect(self.refresh_username)
self.username_changed.connect(worker.username_changed)
self.update_all.connect(acc.update_all)
acc.status_changed.connect(self.status_changed)
acc.info_updated.connect(self.refresh_account_info)
acc.last_session_updated.connect(self.last_session_changed)
acc.sessions_updated.connect(self.refresh_sessions)
# About to show.
self.tray_menu.aboutToShow.connect(self.update_time)
self.tray_menu.aboutToShow.connect(self.refresh_status)
def __init__(self):
super(MainApp, self).__init__()
uic.loadUi(f'autoZoomGUI.ui', self)
global trayIcon
self.setWindowIcon(QIcon('img/Zoom-App-Icon.png'))
self.setWindowTitle('Auto Zoom')
# ##########################
quit = QAction("Quit", self)
quit.triggered.connect(self.closeEvent)
# ##########################
# hidden icon Start
trayIcon = QSystemTrayIcon(QIcon("img/Zoom-App-Icon.png"), parent=self)
trayIcon.setToolTip("Open Auto Zoom")
self.setFixedSize(514, 497)
trayIcon.show()
def showMessage():
trayIcon.showMessage("Auto Zoom", "The program is running in the background, when you close the program stops completely",QIcon("img/Zoom-App-Icon.png"), msecs = 10000)
menu = QMenu()
# Exit start
# Exit end
# Show start
showAction = menu.addAction("Show")
exitAction = menu.addAction("Exit")
showAction.triggered.connect(self.show)
exitAction.triggered.connect(self.Exit)
# End Show
trayIcon.setContextMenu(menu)
# ### ### ###
######## #######
self.connect_db()
self.show_data()
self.tabWidget.tabBar().setVisible(False)
self.pushButton_2.clicked.connect(self.Show_All)
self.pushButton_3.clicked.connect(self.Back)
self.pushButton_4.clicked.connect(self.save)
self.pushButton_5.clicked.connect(self.delete)
self.pushButton.clicked.connect(self.run)
self.pushButton_11.clicked.connect(self.Browse)
self.pushButton_12.clicked.connect(self.Browse1)
self.pushButton.setIcon(QIcon('img/play.png'))
#self.pushButton_6.setIcon(QIcon('img/Setting.png'))
stylesheet = """
QPushButton{
background-color: #19232D;
border: 1px solid #32414B;
}
QPushButton:hover {
background-color: #505F69;}
QPushButton:pressed {
background-color: #19232D;}
QPushButton:default {
border-color: navy; /* make the default button prominent */
}
"""
self.pushButton_6.setStyleSheet(stylesheet+ "QPushButton{border-image : url('img//setting.png');}")
self.pushButton_7.setStyleSheet(stylesheet+ "QPushButton{border-image : url('img//back.png');}")
self.pushButton_6.clicked.connect(self.OSetting)
self.pushButton_7.clicked.connect(self.CSetting)
self.pushButton_8.clicked.connect(self.run_mous_info)
self.pushButton_9.clicked.connect(self.SaveSetting)
self.pushButton_10.clicked.connect(self.Default)
img = QPixmap("img//open Zoom E.png")
self.label_11.setPixmap(img)
self.label_11.resize(img.width(), img.height())
img1 = QPixmap("img//chat1.png")
self.label_17.setPixmap(img1)
self.label_17.resize(img1.width(), img1.height())
self.MassageOpen()
self.TimeNow()
def initUI(self):
self.setWindowTitle("TurboClock")
self.resize(400, 300)
self.setWindowIcon(QIcon('Images//clock.png'))
self.icon = QSystemTrayIcon(self)
self.icon.setIcon(QIcon('Images//clock.png'))
self.icon.setVisible(True)
self.lcdNumber = QLCDNumber()
self.lcdNumber.setNumDigits(8)
self.btnStartPause = QPushButton('', self)
self.btnStartPause.setIcon(QIcon('Images//play_icon.png'))
self.btnStartPause.clicked.connect(self.manageStartPauseClickedEvent)
self.btnDutyDetails = QPushButton('Duty details...')
self.btnDutyDetails.clicked.connect(self.manageDutyDetailsClickedEvent)
self.btnAddTfsTask = QPushButton('', self)
self.btnAddTfsTask.setIcon(QIcon('Images//plus_icon.png'))
self.btnAddTfsTask.clicked.connect(self.manageEditTasksOptions)
self.progressBar = QProgressBar()
self.progressBar.setValue(0)
self.dutyTimeCompLbl = QLabel()
self.currTaskItemRow = 0
self.taskTFSCb = QComboBox(self)
self.initTFSTaskCombobox()
mainLayout = QVBoxLayout(self)
layoutTimer = QVBoxLayout()
layoutTimer.addWidget(self.lcdNumber)
fieldsInputLayout = QHBoxLayout()
layoutInputCodes = QVBoxLayout()
layoutInputCodes.addWidget(self.taskTFSCb)
layoutAddBtn = QVBoxLayout()
layoutAddBtn.addWidget(self.btnAddTfsTask)
fieldsInputLayout.addLayout(layoutInputCodes)
fieldsInputLayout.addLayout(layoutAddBtn)
layoutDutyStat = QHBoxLayout()
layoutDutyStat.addWidget(self.dutyTimeCompLbl)
layoutProgressBar = QHBoxLayout()
layoutProgressBar.addWidget(self.progressBar)
mainLayout.addLayout(layoutTimer)
mainLayout.addLayout(fieldsInputLayout)
mainLayout.addWidget(self.btnStartPause)
mainLayout.addWidget(self.btnDutyDetails)
mainLayout.addWidget(self.progressBar)
mainLayout.addLayout(layoutDutyStat)
self.timer = QTimer(self)
self.deltaTimer = 0
self.currTimeLCD = QTime(0, 0, 0)
self.currTimeDuty = QTime(0, 0, 0)
self.timer.timeout.connect(self.incrementTimer)
self.updateTimeLCD()
self.updateDutyTimeDisp()
self.updateProgressBarDisplay()
self.startTime = 0
self.stopTime = 0
self.editTasksGUI = EditTasksOptionsGUI(self, self.backlogMgr)
def startSplashWindowPhase(self) -> None:
super().startSplashWindowPhase()
self._package_manager.initialize()
# Read preferences here (upgrade won't work) to get the language in use, so the splash window can be shown in
# the correct language.
try:
preferences_filename = Resources.getPath(Resources.Preferences,
self._app_name + ".cfg")
self._preferences.readFromFile(preferences_filename)
except FileNotFoundError:
Logger.log(
"i",
"Preferences file not found, ignore and use default language '%s'",
self._default_language)
signal.signal(signal.SIGINT, signal.SIG_DFL)
# This is done here as a lot of plugins require a correct gl context. If you want to change the framework,
# these checks need to be done in your <framework>Application.py class __init__().
i18n_catalog = i18nCatalog("uranium")
self._configuration_error_message = ConfigurationErrorMessage(
self,
i18n_catalog.i18nc("@info:status",
"Your configuration seems to be corrupt."),
lifetime=0,
title=i18n_catalog.i18nc("@info:title", "Configuration errors"))
# Remove, install, and then loading plugins
self.showSplashMessage(
i18n_catalog.i18nc("@info:progress", "Loading plugins..."))
# Remove and install the plugins that have been scheduled
self._plugin_registry.initializeBeforePluginsAreLoaded()
self._loadPlugins()
self._plugin_registry.checkRequiredPlugins(self.getRequiredPlugins())
self.pluginsLoaded.emit()
self.showSplashMessage(
i18n_catalog.i18nc("@info:progress", "Updating configuration..."))
with self._container_registry.lockFile():
VersionUpgradeManager.getInstance().upgrade()
# Load preferences again because before we have loaded the plugins, we don't have the upgrade routine for
# the preferences file. Now that we have, load the preferences file again so it can be upgraded and loaded.
try:
preferences_filename = Resources.getPath(Resources.Preferences,
self._app_name + ".cfg")
with open(preferences_filename, "r", encoding="utf-8") as f:
serialized = f.read()
# This performs the upgrade for Preferences
self._preferences.deserialize(serialized)
self._preferences.setValue("general/plugins_to_remove", "")
self._preferences.writeToFile(preferences_filename)
except FileNotFoundError:
Logger.log(
"i",
"The preferences file cannot be found, will use default values"
)
# Force the configuration file to be written again since the list of plugins to remove maybe changed
self.showSplashMessage(
i18n_catalog.i18nc("@info:progress", "Loading preferences..."))
try:
self._preferences_filename = Resources.getPath(
Resources.Preferences, self._app_name + ".cfg")
self._preferences.readFromFile(self._preferences_filename)
except FileNotFoundError:
Logger.log(
"i",
"The preferences file '%s' cannot be found, will use default values",
self._preferences_filename)
self._preferences_filename = Resources.getStoragePath(
Resources.Preferences, self._app_name + ".cfg")
# FIXME: This is done here because we now use "plugins.json" to manage plugins instead of the Preferences file,
# but the PluginRegistry will still import data from the Preferences files if present, such as disabled plugins,
# so we need to reset those values AFTER the Preferences file is loaded.
self._plugin_registry.initializeAfterPluginsAreLoaded()
# Preferences: recent files
self._preferences.addPreference("%s/recent_files" % self._app_name, "")
file_names = self._preferences.getValue("%s/recent_files" %
self._app_name).split(";")
for file_name in file_names:
if not os.path.isfile(file_name):
continue
self._recent_files.append(QUrl.fromLocalFile(file_name))
# Initialize System tray icon and make it invisible because it is used only to show pop up messages
self._tray_icon = None
if self._tray_icon_name:
self._tray_icon = QIcon(
Resources.getPath(Resources.Images, self._tray_icon_name))
self._tray_icon_widget = QSystemTrayIcon(self._tray_icon)
self._tray_icon_widget.setVisible(False)
def trayMenu(self):
"""显示系统托盘"""
tray = QSystemTrayIcon(self)
tray.setIcon(QIcon(str(self.imgDir / settings.TRAY_ICON)))
tray.show()
def initUI(self):
menu = QMenu()
# Use Buddha in place of smiley face
# iconPath = pyInstallerResourcePath('exit-gray.png')
iconPath = pyInstallerResourcePath('meditate.png')
self.trayIcon = QSystemTrayIcon(self)
supported = self.trayIcon.supportsMessages()
self.trayIcon.setIcon(QIcon(iconPath))
self.trayIcon.setContextMenu(menu)
self.trayIcon.showMessage('a', 'b')
self.trayIcon.show()
self.postureIcon = QSystemTrayIcon(self)
self.postureIcon.setIcon(QIcon(pyInstallerResourcePath('posture.png')))
self.postureIcon.setContextMenu(menu)
self.postureIcon.show()
exitAction = QAction("&Quit Sensei",
self,
shortcut="Ctrl+Q",
triggered=self.closeEvent)
preferencesAction = QAction("&Preferences...",
self,
triggered=self.showApp)
# preferencesAction.setStatusTip('Sensei Preferences')
aboutAction = QAction("&About Sensei", self, triggered=self.aboutEvent)
menu.addAction(aboutAction)
menu.addSeparator()
menu.addAction(preferencesAction)
menu.addSeparator()
menu.addAction(exitAction)
optionsMenu = menu.addMenu('&Options')
soundToggleAction = QAction("Toggle Sound",
self,
triggered=self.toggleSound)
optionsMenu.addAction(soundToggleAction)
# TODO: Add settings panel.
# changeSettings = QAction(QIcon('exit.png'), "&Settings", self, shortcut="Cmd+,", triggered=self.changeSettings)
# changeSettings.setStatusTip('Change Settings')
# menu.addAction(changeSettings)
self.pbar = QProgressBar(self)
self.pbar.setGeometry(30, 40, 200, 25)
self.pbarValue = 0
self.setGeometry(300, 300, 290, 150)
self.setWindowTitle('Posture Monitor')
self.startButton = QPushButton('Calibrate', self)
self.startButton.move(30, 60)
self.startButton.clicked.connect(self.calibrate)
self.stopButton = QPushButton('Stop', self)
self.stopButton.move(30, 60)
self.stopButton.clicked.connect(self.endCalibration)
self.stopButton.hide()
self.settingsButton = QPushButton('Settings', self)
self.settingsButton.move(140, 60)
self.settingsButton.clicked.connect(self.settings)
self.doneButton = QPushButton('Done', self)
self.doneButton.move(30, 60)
self.doneButton.hide()
self.doneButton.clicked.connect(self.minimize)
# TODO: Create QWidget panel for Settings with MONITOR_DELAY
# and SENSITIVITY options.
# layout = QFormLayout()
# self.le = QLineEdit()
self.instructions = QLabel(self)
self.instructions.move(40, 20)
self.instructions.setText('Sit upright and click \'Calibrate\'')
self.instructions.setGeometry(40, 20, 230, 25)
if not supported:
self.instructions.setText(
'Error: Notification is not available on your system.')
self.show()
def __init__(self):
super().__init__()
icon = QIcon(DeWidgetsIcon)
# setup window
self.setWindowTitle(lang['MAIN']['title'])
self.setFixedSize(520, 262)
self.setWindowFlags(Qt.WindowMinimizeButtonHint |
Qt.WindowCloseButtonHint)
self.setWindowIcon(icon)
# setup vars
self.help_window = None
self.settings_win = None
self.edit_window = None
# setup list
self.list = QListWidget(self)
self.list.setGeometry(QRect(0, 0, 281, 231))
self.list.setSpacing(2)
self.list.itemClicked.connect(self._list_click)
self.list.itemDoubleClicked.connect(self._list_double_click)
self.list.setContextMenuPolicy(Qt.CustomContextMenu)
self.list.customContextMenuRequested.connect(self._show_list_menu)
# setup list context menu
self.list_menu = QMenu(self)
load_action = self.list_menu.addAction(QIcon(LOAD),
lang['LIST_MENU']['load'])
load_action.setToolTip(lang['LIST_MENU']['load_tt'])
load_action.triggered.connect(self._load_not_placed)
unload_action = self.list_menu.addAction(QIcon(UNLOAD),
lang['LIST_MENU']['unload'])
unload_action.setToolTip(lang['LIST_MENU']['unload_tt'])
unload_action.triggered.connect(self._unload_not_placed)
self.list_menu.addSeparator()
reload_action = self.list_menu.addAction(QIcon(RELOAD),
lang['LIST_MENU']['reload'])
reload_action.setToolTip(lang['LIST_MENU']['reload_tt'])
reload_action.triggered.connect(self._reload)
# setup 'Add' button
self.add_button = QPushButton(lang['MAIN']['add_button'], self)
self.add_button.setToolTip(lang['MAIN']['add_button_tt'])
self.add_button.setGeometry(QRect(300, 5, 94, 27))
self.add_button.clicked.connect(self._add_widget)
# setup 'Delete' button
self.del_button = QPushButton(lang['MAIN']['del_button'], self)
self.del_button.setToolTip(lang['MAIN']['del_button_tt'])
self.del_button.setGeometry(QRect(410, 5, 94, 27))
self.del_button.clicked.connect(self._show_del)
# setup 'Configure' button
self.wset_button = QPushButton(lang['MAIN']['wset_button'], self)
self.wset_button.setToolTip((lang['MAIN']['wset_button_tt']))
self.wset_button.setGeometry(QRect(300, 35, 94, 27))
self.wset_button.clicked.connect(self._show_widget_settings)
# setup 'Edit' button
self.edit_button = QPushButton(lang['MAIN']['edit_button'], self)
self.edit_button.setToolTip(lang['MAIN']['edit_button_tt'])
self.edit_button.setGeometry(QRect(410, 35, 94, 27))
self.edit_button.clicked.connect(self._show_edit)
# setup 'edit mode' checkbox
self.edit_mode_checkbox = QCheckBox(lang['MAIN']['edit_mode'], self)
self.edit_mode_checkbox.setToolTip(lang['MAIN']['edit_mode_tt'])
self.edit_mode_checkbox.setGeometry(QRect(300, 75, 240, 20))
self.edit_mode_checkbox.clicked.connect(self._edit_mode)
self.edit_mode_checkbox.setChecked(
bool(strtobool(settings['MAIN']['edit_mode'])))
# setup 'Add new' button
self.new_button = QPushButton(lang['MAIN']['new_button'], self)
self.new_button.setToolTip(lang['MAIN']['new_button_tt'])
self.new_button.setGeometry(QRect(355, 130, 94, 27))
self.new_button.clicked.connect(self._show_add_new)
# setup 'Settings' button
self.settings_button = QPushButton(lang['MAIN']['settings_button'],
self)
self.settings_button.setToolTip(lang['MAIN']['settings_button_tt'])
self.settings_button.setGeometry(QRect(300, 160, 94, 27))
self.settings_button.clicked.connect(self._show_settings)
# setup 'Help' button
self.help_button = QPushButton(lang['MAIN']['help_button'], self)
self.help_button.setToolTip(lang['MAIN']['help_button'])
self.help_button.setGeometry(QRect(410, 160, 94, 27))
self.help_button.clicked.connect(self._show_help)
# setup 'Exit' button
self.exit_button = QPushButton(lang['MAIN']['exit_button'], self)
self.exit_button.setToolTip(lang['MAIN']['exit_button_tt'])
self.exit_button.setGeometry(QRect(355, 190, 94, 27))
self.exit_button.clicked.connect(app.quit)
# setup status bar
self.status_bar = QStatusBar(self)
self.setStatusBar(self.status_bar)
self.statusBar().showMessage(lang['STATUS']['first'])
# setup tray
self.tray = QSystemTrayIcon(icon, self)
self.tray.setToolTip(lang['MAIN']['title'])
self.tray.activated.connect(self._visible)
menu = QMenu(self)
show_action = menu.addAction(QIcon(SHOW), lang['TRAY']['show_action'])
show_action.setToolTip(lang['TRAY']['show_action_tt'])
show_action.triggered.connect(self.showNormal)
hide_action = menu.addAction(QIcon(HIDE), lang['TRAY']['hide_action'])
hide_action.setToolTip(lang['TRAY']['hide_action_tt'])
hide_action.triggered.connect(self._hide_widgets)
settings_action = menu.addAction(QIcon(SETTINGS),
lang['TRAY']['settings_action'])
settings_action.setToolTip(lang['TRAY']['settings_action'])
settings_action.triggered.connect(self._show_settings)
menu.addSeparator()
exit_action = menu.addAction(QIcon(EXIT), lang['TRAY']['exit_action'])
exit_action.setToolTip(lang['TRAY']['exit_action_tt'])
exit_action.triggered.connect(app.quit)
self.tray.setContextMenu(menu)
self.tray.show()
# set enabled
self.__change_enabled()
