def _initSystemTray(self, withMenu: bool = False): LOG.info("Initializing the system tray: available: %s, messages: %s", QSystemTrayIcon.isSystemTrayAvailable(), QSystemTrayIcon.supportsMessages()) if not QSystemTrayIcon.isSystemTrayAvailable(): return systemTrayIcon = QSystemTrayIcon(QIcon('assets/logo.png'), self._app) systemTrayIcon.setToolTip("The Deep Visualization Toolbox") systemTrayIcon.activated.connect(self.onSystemTrayActivated) if withMenu: contextMenu = QMenu() contextMenu.aboutToShow.connect(self.onSystemTrayMenuAboutToShow) actionTest = QAction('Test', contextMenu) actionTest.triggered.connect(self.onSystemTrayMenuActionTriggered) systemTrayIcon.setContextMenu(contextMenu) if QSystemTrayIcon.supportsMessages(): systemTrayIcon.\ messageClicked.connect(self.onSystemTrayMessageClicked) systemTrayIcon.show()
def is_system_tray_available(): app = QApplication.instance() if app is None: app = QApplication([]) tray = QSystemTrayIcon() is_available = tray.isSystemTrayAvailable() app.quit() else: tray = QSystemTrayIcon() is_available = tray.isSystemTrayAvailable() return is_available
def run(manager, testing=False): logger.info("Creating trayicon...") # print(QIcon.themeSearchPaths()) app = QApplication(sys.argv) # Without this, Ctrl+C will have no effect signal.signal(signal.SIGINT, exit) # Ensure cleanup happens on SIGTERM signal.signal(signal.SIGTERM, exit) timer = QtCore.QTimer() timer.start(100) # You may change this if you wish. timer.timeout.connect(lambda: None) # Let the interpreter run each 500 ms. if not QSystemTrayIcon.isSystemTrayAvailable(): QMessageBox.critical(None, "Systray", "I couldn't detect any system tray on this system. Either get one or run the ActivityWatch modules from the console.") sys.exit(1) widget = QWidget() icon = QIcon(":/logo.png") trayIcon = TrayIcon(manager, icon, widget, testing=testing) trayIcon.show() trayIcon.showMessage("ActivityWatch", "ActivityWatch is starting up...") QApplication.setQuitOnLastWindowClosed(False) # Run the application, blocks until quit return app.exec_()
def CreateTrayIcon(self): if not QSystemTrayIcon.isSystemTrayAvailable(): self.log_text = "本系统不支持托盘图标!" self.logger.SendMessage("W", 3, self.log_cate, self.log_text, "S") return QApplication.setQuitOnLastWindowClosed(False) # 点击主界面关闭按钮将不会结束程序,需要从托盘菜单退出 self.tray_icon_menu = QMenu() self.tray_icon_menu.addAction(self.action_show) self.tray_icon_menu.addAction(self.action_hide) self.tray_icon_menu.addSeparator() self.tray_icon_menu.addAction(self.action_about) self.tray_icon_menu.addAction(self.action_exit) self.tray_icon = QSystemTrayIcon() self.tray_icon.setContextMenu(self.tray_icon_menu) self.tray_icon.setToolTip(define.TRAY_POP_START_TITLE) self.tray_icon.setIcon(QIcon(define.DEF_ICON_SYSTEM_TRAY)) self.tray_icon.messageClicked.connect(self.OnTrayIconMsgClicked) self.tray_icon.activated.connect(self.OnTrayIconClicked) self.action_show.setEnabled(False) self.action_hide.setEnabled(True) self.tray_icon.show() self.is_tray_icon_loaded = True
def __init__(self, icon, controller, publisher, parent=None): super().__init__(icon, parent) self.logger = logging.getLogger(' TrayIndicator') try: if not QSystemTrayIcon.isSystemTrayAvailable(): raise EnvironmentError('System tray not available') except EnvironmentError as env_error: self.logger.critical('Error - System tray not available') message_tuple = [ _('System tray not available.'), _('Worksets relies on the system tray - the application will terminate.\n\nPlease enable the system tray and try again.' ), '', 'Critical', True ] publisher.user_message('MESSAGE', message_tuple) self.controller = controller self.publisher = publisher self.publisher.register(['UPDATED', 'INSERTED', 'REMOVED'], self, self.update_menu) self.active_mw_dialog = None self.active_settings_dialog = None self.menu = QMenu(parent) # Work around since tray.activated signal doesn't work on Ubuntu Unity self.menu.aboutToShow.connect(self.icon_activated) self.build_menu() self.setContextMenu(self.menu)
def main_gui(args: argparse.Namespace): QApplication.setAttribute(Qt.AA_EnableHighDpiScaling) app = QApplication(sys.argv) loop = QEventLoop(app) asyncio.set_event_loop(loop) # Check environment first from PyQt5.QtWidgets import QMessageBox, QSystemTrayIcon def dialog(message: str) -> None: QMessageBox.critical(None, "VirtScreen", message) if not QSystemTrayIcon.isSystemTrayAvailable(): dialog("Cannot detect system tray on this system.") sys.exit(1) check_env(args, dialog) app.setApplicationName("VirtScreen") app.setWindowIcon(QIcon(ICON_PATH)) os.environ["QT_QUICK_CONTROLS_STYLE"] = "Material" # Register the Python type. Its URI is 'People', it's v1.0 and the type # will be called 'Person' in QML. qmlRegisterType(DisplayProperty, 'VirtScreen.DisplayProperty', 1, 0, 'DisplayProperty') qmlRegisterType(Backend, 'VirtScreen.Backend', 1, 0, 'Backend') qmlRegisterType(Cursor, 'VirtScreen.Cursor', 1, 0, 'Cursor') qmlRegisterType(Network, 'VirtScreen.Network', 1, 0, 'Network') # Create a component factory and load the QML script. engine = QQmlApplicationEngine() engine.load(QUrl(MAIN_QML_PATH)) if not engine.rootObjects(): dialog("Failed to load QML") sys.exit(1) sys.exit(app.exec_()) with loop: loop.run_forever()
def show(main_window): """Show a system tray icon with a small icon.""" _fix_unity_systray() icon = QIcon(multiplatform.get_path("logos/icon-192.png")) sti = QSystemTrayIcon(icon, main_window) if not sti.isSystemTrayAvailable(): logger.warning("System tray not available.") return def showhide(_): """Show or hide the main window.""" if main_window.isVisible(): main_window.hide() else: main_window.show() _menu = QMenu(main_window) _act = _menu.addAction("Mostrar/Ocultar") _act.triggered.connect(showhide) _act = _menu.addAction("Acerca de") _act.triggered.connect(main_window.open_about_dialog) _act = _menu.addAction("Salir") _act.triggered.connect(main_window.on_close) sti.setContextMenu(_menu) sti.show()
def start_qt_app(config): import sys from PyQt5.QtWidgets import QApplication, QSystemTrayIcon, QMessageBox from quamash import QEventLoop from ui.main import Window from ui.qt_gui_connection import qSignal app = QApplication(sys.argv) loop = QEventLoop(app) asyncio.set_event_loop(loop) if not QSystemTrayIcon.isSystemTrayAvailable(): QMessageBox.critical(None, "Systray", "I couldn't detect any system tray on this system.") sys.exit(1) QApplication.setQuitOnLastWindowClosed(False) gui_connection = qSignal() window = Window(gui_connection) def closeApp(): print("Close app signal") for task in asyncio.Task.all_tasks(): print(task) task.cancel() loop.stop() gui_connection.closeApp.connect(closeApp) with loop: #asyncio.run_coroutine_threadsafe(timer(loop, config, gui_connection), loop) try: loop.run_until_complete(timer(loop, config, gui_connection)) except asyncio.CancelledError: pass
def gui(start, config_file): if start: import sys from PyQt5.QtWidgets import QSystemTrayIcon from PyQt5.QtWidgets import QMessageBox from PyQt5.QtWidgets import QApplication from bot.utils.common import make_config_file, default_config from bot.duel_links_runtime import DuelLinkRunTime from bot.dl_gui import DuelLinksGui sip.setdestroyonexit(False) app = QApplication(sys.argv) if not QSystemTrayIcon.isSystemTrayAvailable(): QMessageBox.critical(None, "Systray", "Systray not dected on system.") sys.exit(1) QApplication.setQuitOnLastWindowClosed(False) uconfig = default_config() uconfig.read(config_file) dlRuntime = setup_runtime(uconfig) dlRuntime.main() window = DuelLinksGui(dlRuntime, uconfig.get('locations', 'assets')) window.show() sys.exit(app.exec_())
def run(manager, testing=False): logger.info("Creating trayicon...") # print(QIcon.themeSearchPaths()) app = QApplication(sys.argv) # Without this, Ctrl+C will have no effect signal.signal(signal.SIGINT, exit) # Ensure cleanup happens on SIGTERM signal.signal(signal.SIGTERM, exit) timer = QtCore.QTimer() timer.start(100) # You may change this if you wish. timer.timeout.connect(lambda: None) # Let the interpreter run each 500 ms. if not QSystemTrayIcon.isSystemTrayAvailable(): QMessageBox.critical( None, "Systray", "I couldn't detect any system tray on this system. Either get one or run the ActivityWatch modules from the console." ) sys.exit(1) widget = QWidget() icon = QIcon(":/logo.png") trayIcon = TrayIcon(manager, icon, widget, testing=testing) trayIcon.show() trayIcon.showMessage("ActivityWatch", "ActivityWatch is starting up...") QApplication.setQuitOnLastWindowClosed(False) # Run the application, blocks until quit return app.exec_()
def closeEvent(self, event): if ( not settings.get_value("global/tray_enabled") or not QSystemTrayIcon.isSystemTrayAvailable() or self.close_requested or self.core_config.debug or self.force_close ): if not self.force_close: result = ask_question( self, QCoreApplication.translate(self.__class__.__name__, "Confirmation"), QCoreApplication.translate("MainWindow", "Are you sure you want to quit ?"), ) if not result: event.ignore() self.close_requested = False return event.accept() else: event.accept() if self.tray: self.tray.hide() self.stop_core() else: if self.tray and not self.tray_message_shown: self.tray.showMessage( "Parsec", QCoreApplication.translate("MainWindow", "Parsec is still running.") ) self.tray_message_shown = True event.ignore() self.hide()
def start(): # Start logging all events if '--drop' in sys.argv: drop_db() utils.start_app_logging() if sys.platform == 'win32': from server import SingleInstance single_app = SingleInstance() if single_app.already_running(): running_warning() app = QApplication(sys.argv) if not QSystemTrayIcon.isSystemTrayAvailable(): QMessageBox.critical( None, "Systray", "Could not detect a system tray on this system" ) sys.exit(1) QApplication.setQuitOnLastWindowClosed(False) osf = OSFApp() osf.start() osf.hide() sys.exit(app.exec_())
def start(): # Start logging all events if '--drop' in sys.argv: drop_db() utils.start_app_logging() if sys.platform == 'win32': from server import SingleInstance single_app = SingleInstance() if single_app.already_running(): running_warning() app = QApplication(sys.argv) if not QSystemTrayIcon.isSystemTrayAvailable(): QMessageBox.critical(None, "Systray", "Could not detect a system tray on this system") sys.exit(1) QApplication.setQuitOnLastWindowClosed(False) osf = OSFApp() osf.start() osf.hide() sys.exit(app.exec_())
def ui_main(): import sys global wsettings, wabout app = QApplication(sys.argv) systemtray_timeout = 0 # Check if DE supports system tray while not QSystemTrayIcon.isSystemTrayAvailable(): systemtray_timeout += 1 time.sleep(20) if systemtray_timeout == 5: QMessageBox.critical( None, "Mail notifier", "I couldn't detect any system tray on this system.") sys.exit(1) QApplication.setQuitOnLastWindowClosed(False) import signal signal.signal(signal.SIGTERM, signal_term_handler) wabout = About() wsettings = Settings() window = MyWindow() sys.exit(app.exec_())
def update_tray_icon(self, use_monochrome_icon): if not QSystemTrayIcon.isSystemTrayAvailable() or not self.tray_icon: return if use_monochrome_icon: self.tray_icon.setIcon(QIcon(QPixmap(get_image_path('monochrome_tribler.png')))) else: self.tray_icon.setIcon(QIcon(QPixmap(get_image_path('tribler.png')))) self.tray_icon.show()
def update_tray_icon(self, use_monochrome_icon): if not QSystemTrayIcon.isSystemTrayAvailable(): return if use_monochrome_icon: self.tray_icon.setIcon(QIcon(QPixmap(get_image_path('monochrome_tribler.png')))) else: self.tray_icon.setIcon(QIcon(QPixmap(get_image_path('tribler.png')))) self.tray_icon.show()
def on_received_downloads(self, downloads): if not downloads: return # This might happen when closing Tribler total_download = 0 total_upload = 0 self.received_downloads.emit(downloads) self.downloads = downloads download_infohashes = set() for download in downloads["downloads"]: if download["infohash"] in self.download_widgets: item = self.download_widgets[download["infohash"]] else: item = DownloadWidgetItem(self.window().downloads_list) self.download_widgets[download["infohash"]] = item item.update_with_download(download) # Update video player with download info video_infohash = self.window().video_player_page.active_infohash if video_infohash != "" and download["infohash"] == video_infohash: self.window().video_player_page.update_with_download_info( download) total_download += download["speed_down"] total_upload += download["speed_up"] download_infohashes.add(download["infohash"]) if self.window().download_details_widget.current_download is not None and \ self.window().download_details_widget.current_download["infohash"] == download["infohash"]: self.window( ).download_details_widget.current_download = download self.window().download_details_widget.update_pages() # Check whether there are download that should be removed toremove = set() for infohash, item in self.download_widgets.iteritems(): if infohash not in download_infohashes: index = self.window().downloads_list.indexOfTopLevelItem(item) toremove.add((infohash, index)) for infohash, index in toremove: self.window().downloads_list.takeTopLevelItem(index) del self.download_widgets[infohash] if QSystemTrayIcon.isSystemTrayAvailable(): self.window().tray_icon.setToolTip( "Down: %s, Up: %s" % (format_speed(total_download), format_speed(total_upload))) self.update_download_visibility() self.schedule_downloads_timer() # Update the top download management button if we have a row selected if len(self.window().downloads_list.selectedItems()) > 0: self.on_download_item_clicked()
def create_tray_icon(self): if QSystemTrayIcon.isSystemTrayAvailable(): logger.debug('System tray icon is available, showing') self.tray_icon = QSystemTrayIcon(QIcon(':/i/xnova_logo_32.png'), self) self.tray_icon.setToolTip(self.tr('XNova Commander')) self.tray_icon.activated.connect(self.on_tray_icon_activated) self.tray_icon.show() else: self.tray_icon = None
def create_tray_icon(self): if QSystemTrayIcon.isSystemTrayAvailable(): logger.debug('System tray icon is available, showing') self.tray_icon = QSystemTrayIcon(QIcon(':/i/xnova_logo_32.png'), self) self.tray_icon.setToolTip(self.tr('XNova Commander')) self.tray_icon.activated.connect(self.on_tray_icon_activated) self.tray_icon.show() else: self.tray_icon = None
def __init__(self, parent: QObject = None) -> None: super().__init__(parent) if not QSystemTrayIcon.isSystemTrayAvailable(): raise Error("No system tray available") if not QSystemTrayIcon.supportsMessages(): raise Error("System tray does not support messages") self._systray = QSystemTrayIcon(self) self._systray.setIcon(objects.qapp.windowIcon()) self._systray.messageClicked.connect(self._on_systray_clicked)
def show_in_tray_when_available(self): """Show status icon when system tray is available If available, show icon, otherwise, set a timer to check back later. This is a workaround for https://bugreports.qt.io/browse/QTBUG-61898 """ if QSystemTrayIcon.isSystemTrayAvailable(): self.tray.show() else: QtCore.QTimer.singleShot(1000, self.show_in_tray_when_available)
def isTrayAvailable(self): if TrayEngine in ("KDE", "Qt"): # Ask Qt return QSystemTrayIcon.isSystemTrayAvailable() if TrayEngine == "AppIndicator": # Ubuntu/Unity always has a systray return True return False
def delayed_start(self, event_count): if not QSystemTrayIcon.isSystemTrayAvailable(): if event_count == 5: QMessageBox.critical( None, "BuildNotify", "I couldn't detect any system tray on this system.") sys.exit(1) self.timed_event.start() if not self.ready: self.ready = True self.run_app()
def __init__(self): super().__init__() self.ui = ui.Ui_MainWidget() self.ui.setupUi(self) self.monitors = [] self.__enable = True self._start_pos = None self._end_pos = None self._is_drag = False self._press = False self._is_resize = False self._resize_direction = None self._margin = 10 self.setMouseTracking(True) self.setAttribute(Qt.WA_TranslucentBackground) self.setWindowFlag(Qt.FramelessWindowHint) self.ui.label_wintitle.setText("Brightness Ctrl v%.1f" % version) shadow = QGraphicsDropShadowEffect(self) shadow.setOffset(0, 0) shadow.setColor(Qt.black) shadow.setBlurRadius(8) self.setGraphicsEffect(shadow) self.tray_icon = None self.tray_icon_menu = None if QSystemTrayIcon.isSystemTrayAvailable(): self.tray_icon_menu = QMenu(self) restore_action = QAction("恢复主窗口", self) restore_action.triggered.connect(self.action_restore) self.tray_icon_menu.addAction(restore_action) self.tray_icon = QSystemTrayIcon(self) self.tray_icon.setContextMenu(self.tray_icon_menu) self.tray_icon.setIcon(QIcon(':/images/icon.ico')) self.tray_icon.show() self.ui.btn_exit.clicked.connect(self.slot_btn_exit) self.ui.tbtn_refresh.clicked.connect(self.slot_tbtn_refresh_clicked, Qt.DirectConnection) self.ui.btn_show_monitor_info.clicked.connect( self.slot_btn_show_monitor_info) self.ui.hsilder_brightness.valueChanged.connect( self.slot_hsilder_brightness_value_changed) self.ui.spinbox_brightness.valueChanged.connect( self.slot_spinbox_brightness_value_changed) self.ui.hsilder_contrast.valueChanged.connect( self.slot_hsilder_contrast_value_changed) self.ui.spinbox_contrast.valueChanged.connect( self.slot_spinbox_contrast_value_changed) self.tray_icon.activated.connect(self.slot_system_tray_activated) self.ui.btn_x.clicked.connect(self.close) self.ui.btn_x.setAttribute(Qt.WA_Hover, True) self.init_monitors()
def on_export_download_request_done(self, filename, data): dest_path = os.path.join(self.export_dir, filename) try: torrent_file = open(dest_path, "wb") torrent_file.write(data) torrent_file.close() except IOError as exc: ConfirmationDialog.show_error(self.window(), "Error when exporting file", "An error occurred when exporting the torrent file: %s" % str(exc)) else: if QSystemTrayIcon.isSystemTrayAvailable(): self.window().tray_icon.showMessage("Torrent file exported", "Torrent file exported to %s" % dest_path)
def main(): app = QApplication(sys.argv) if not QSystemTrayIcon.isSystemTrayAvailable(): QMessageBox.critical( None, "Systray", "I couldn't detect any system tray on this system.") sys.exit(1) QApplication.setQuitOnLastWindowClosed(False) ex = Multitool() sys.exit(app.exec_())
def main(): d = getDateTime() # Global app app = QApplication(sys.argv) QApplication.setQuitOnLastWindowClosed(False) qIcon = QIcon('icons/shotty.png') app.setWindowIcon(qIcon) shotty = ShottyFullscreen() showNotification('Shotty', 'Running in the background') tray = QSystemTrayIcon() if tray.isSystemTrayAvailable(): tray.setIcon(QIcon('icons/shotty.png')) tray.setVisible(True) tray.show() # Add a menu trayMenu = QMenu() region_screenshot_action = QAction(QIcon("icons/screenshot.png"), 'Take region screenshot') full_screenshot_action = QAction(QIcon("icons/screenshot.png"), 'Take screenshot') settings_action = QAction(QIcon("icons/settings.png"), 'Settings') about_action = QAction(QIcon("icons/info.png"), 'About') exit_action = QAction(QIcon("icons/exit.png"), 'Exit Shoty') exit_action.triggered.connect(app.exit) about_action.triggered.connect(shotty.showShottyAboutWindow) region_screenshot_action.triggered.connect(shotty.initUI) # We need to pass checked because connect passes # a bool arg as first param full_screenshot_action.triggered.connect( lambda checked, date=getDateTime( ), x1=-1, y1=-1, x2=-1, y2=-1, im=screenshot( ): shotty.saveScreenShot(date, x1, y1, x2, y2, im=im[:, :, :3])) trayMenu.addAction(region_screenshot_action) trayMenu.addAction(full_screenshot_action) trayMenu.addAction(settings_action) trayMenu.addAction(about_action) trayMenu.addAction(exit_action) tray.setContextMenu(trayMenu) else: print("[ERROR] Can't instantiate tray icon") sys.exit(app.exec_())
def main(): app = QApplication(sys.argv) if not QSystemTrayIcon.isSystemTrayAvailable(): QMessageBox.critical(QWidget(), '提示', '在这个操作系统上无法找到系统托盘') return app.exec_() QApplication.setQuitOnLastWindowClosed(False) # 创建主窗口 main_window = MainWindow() # 显示主窗口 main_window.show() return app.exec_()
def add_tray_icon(self): if not QSystemTrayIcon.isSystemTrayAvailable() or not settings.get_value( "global/tray_enabled", "true" ): return self.tray = QSystemTrayIcon(self) menu = QMenu() action = menu.addAction(QCoreApplication.translate(self.__class__.__name__, "Show window")) action.triggered.connect(self.show_top) action = menu.addAction(QCoreApplication.translate(self.__class__.__name__, "Exit")) action.triggered.connect(self.close_app) self.tray.setContextMenu(menu) self.tray.setIcon(QIcon(":/icons/images/icons/parsec.png")) self.tray.activated.connect(self.tray_activated) self.tray.show()
def run(self): with session_scope() as session: user = session.query(User).first() if not user: user = User(idx=str(uuid4())) session.add(user) self.main_window.show() # Check if DE supports system tray if not QSystemTrayIcon.isSystemTrayAvailable(): QMessageBox.critical( None, "Error", "I couldn't detect any system tray on this system.") return self.app.exec_()
def init_tray_icon(app_window): if not QSystemTrayIcon.isSystemTrayAvailable(): QMessageBox.critical( None, APP_NAME, 'System tray is not supported, app will exit' ) sys.exit(1) icon = QIcon(':/images/app.png') icon.setIsMask(True) tray_icon = QSystemTrayIcon(icon, app_window) tray_icon.activated.connect( lambda reason: tray_icon_activated(reason, app_window, tray_icon) ) tray_icon.setToolTip(APP_NAME) return tray_icon
def start(): start_logging() # will end application if an instance is already running singleton = SingleInstance(callback=running_warning) min_version = None # Then, if the current version is too old, close the program try: r = requests.get(settings.MIN_VERSION_URL, timeout=10) except requests.exceptions.ConnectionError: logger.warning('Check for minimum version requirements for OSF-Sync failed ' 'because you have no Internet connection') else: try: min_version = r.json()['min-version'] except KeyError as e: logger.exception(e) if min_version: if StrictVersion(settings.VERSION) < StrictVersion(min_version): # User error message running_warning(message='You must update to a newer version. ' 'You can find newest version at {}' .format(settings.OFFLINE_PROJECT_ON_OSF), critical=True) sys.exit(1) # Start logging all events if '--drop' in sys.argv: drop_db() app = QApplication(sys.argv) # connect QT to handle system shutdown signal from os correctly app.aboutToQuit.connect(exit_gracefully) if not QSystemTrayIcon.isSystemTrayAvailable(): QMessageBox.critical(None, 'Systray', 'Could not detect a system tray on this system') sys.exit(1) QApplication.setQuitOnLastWindowClosed(False) if not OSFOfflineQT(app).start(): return sys.exit(1) return sys.exit(app.exec_())
def start(self): settings.load_configuration() settings.set_window_manager(self.window_manager) self.window_manager.start() self.audio_manager.start() app = QApplication(sys.argv) main_window = MainWindow() if not QSystemTrayIcon.isSystemTrayAvailable(): QMessageBox.critical(None, self.APP_NAME, "I couldn't detect any system tray on this system.") sys.exit(1) app.setQuitOnLastWindowClosed(False) window = TrayWindow(main_window) sys.exit(app.exec_())
def run(manager: Manager, testing: bool = False) -> Any: logger.info("Creating trayicon...") # print(QIcon.themeSearchPaths()) app = QApplication(sys.argv) # Without this, Ctrl+C will have no effect signal.signal(signal.SIGINT, lambda *args: exit(manager)) # Ensure cleanup happens on SIGTERM signal.signal(signal.SIGTERM, lambda *args: exit(manager)) # Allow pixmaps (e.g. trayicon) to use higher DPI images to make icons less # blurry when fractional scaling is used app.setAttribute(QtCore.Qt.AA_UseHighDpiPixmaps) timer = QtCore.QTimer() timer.start(100) # You may change this if you wish. timer.timeout.connect(lambda: None) # Let the interpreter run each 500 ms. if not QSystemTrayIcon.isSystemTrayAvailable(): QMessageBox.critical( None, "Systray", "I couldn't detect any system tray on this system. Either get one or run the ActivityWatch modules from the console.", ) sys.exit(1) widget = QWidget() if sys.platform == "darwin": icon = QIcon(":/black-monochrome-logo.png") # Allow macOS to use filters for changing the icon's color icon.setIsMask(True) else: icon = QIcon(":/logo.png") trayIcon = TrayIcon(manager, icon, widget, testing=testing) trayIcon.show() QApplication.setQuitOnLastWindowClosed(False) logger.info("Initialized aw-qt and trayicon succesfully") # Run the application, blocks until quit return app.exec_()
def __init__(self): super().__init__() self._supported = QSystemTrayIcon.isSystemTrayAvailable() self._context_menu = None self._enabled = False self._trayicon = None self._state_icons = {} for state in ( 'disconnected', 'disabled', 'enabled', ): icon = QIcon(':/state-%s.svg' % state) if hasattr(icon, 'setIsMask'): icon.setIsMask(True) self._state_icons[state] = icon self._machine = None self._machine_state = 'disconnected' self._is_running = False self._update_state()
def __init__(self): super().__init__() self._supported = QSystemTrayIcon.isSystemTrayAvailable() self._context_menu = None self._enabled = False self._trayicon = None self._state_icons = {} for state in ( 'disconnected', 'disabled', 'enabled', ): icon = QIcon(':/state-%s.svg' % state) if hasattr(icon, 'setIsMask'): icon.setIsMask(True) self._state_icons[state] = icon self._machine = None self._machine_state = 'disconnected' self._is_running = False self._update_state()
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, core_args=None, core_env=None, api_port=None): QMainWindow.__init__(self) QCoreApplication.setOrganizationDomain("nl") QCoreApplication.setOrganizationName("TUDelft") QCoreApplication.setApplicationName("Tribler") QCoreApplication.setAttribute(Qt.AA_UseHighDpiPixmaps) self.gui_settings = QSettings() api_port = api_port or int(get_gui_setting(self.gui_settings, "api_port", DEFAULT_API_PORT)) dispatcher.update_worker_settings(port=api_port) self.navigation_stack = [] self.tribler_started = False self.tribler_settings = None self.debug_window = None self.core_manager = CoreManager(api_port) 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 self.token_refresh_timer = None self.shutdown_timer = None self.add_torrent_url_dialog_active = False sys.excepthook = self.on_exception uic.loadUi(get_ui_file_path('mainwindow.ui'), self) TriblerRequestManager.window = self self.tribler_status_bar.hide() self.token_balance_widget.mouseReleaseEvent = self.on_token_balance_click 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") self.debug_pane_shortcut = QShortcut(QKeySequence("Ctrl+d"), self) self.debug_pane_shortcut.activated.connect(self.clicked_menu_button_debug) self.import_torrent_shortcut = QShortcut(QKeySequence("Ctrl+o"), self) self.import_torrent_shortcut.activated.connect(self.on_add_torrent_browse_file) self.add_torrent_url_shortcut = QShortcut(QKeySequence("Ctrl+i"), self) self.add_torrent_url_shortcut.activated.connect(self.on_add_torrent_from_url) # 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.gui_settings) self.settings_page.initialize_settings_page() self.subscribed_channels_page.initialize() self.edit_channel_page.initialize_edit_channel_page(self.gui_settings) 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.gui_settings) self.channel_page.initialize_channel_page(self.gui_settings) self.trust_page.initialize_trust_page() self.token_mining_page.initialize_token_mining_page() self.stackedWidget.setCurrentIndex(PAGE_LOADING) # Create the system tray icon if QSystemTrayIcon.isSystemTrayAvailable(): self.tray_icon = QSystemTrayIcon() use_monochrome_icon = get_gui_setting(self.gui_settings, "use_monochrome_icon", False, is_bool=True) self.update_tray_icon(use_monochrome_icon) # Create the tray icon menu menu = self.create_add_torrent_menu() show_downloads_action = QAction('Show downloads', self) show_downloads_action.triggered.connect(self.clicked_menu_button_downloads) token_balance_action = QAction('Show token balance', self) token_balance_action.triggered.connect(lambda: self.on_token_balance_click(None)) quit_action = QAction('Quit Tribler', self) quit_action.triggered.connect(self.close_tribler) menu.addSeparator() menu.addAction(show_downloads_action) menu.addAction(token_balance_action) menu.addSeparator() menu.addAction(quit_action) self.tray_icon.setContextMenu(menu) 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.token_balance_widget.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)) # Start Tribler self.core_manager.start(core_args=core_args, core_env=core_env) 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.events_started.connect(self.on_events_started) self.core_manager.events_manager.low_storage_signal.connect(self.on_low_storage) self.core_manager.events_manager.credit_mining_signal.connect(self.on_credit_mining_error) self.core_manager.events_manager.tribler_shutdown_signal.connect(self.on_tribler_shutdown_state_update) self.core_manager.events_manager.upgrader_tick.connect( lambda text: self.show_status_bar("Upgrading Tribler database: " + text)) self.core_manager.events_manager.upgrader_finished.connect( lambda _: self.hide_status_bar()) self.core_manager.events_manager.received_search_result.connect( self.search_results_page.received_search_result) # 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) # Resize the window according to the settings center = QApplication.desktop().availableGeometry(self).center() pos = self.gui_settings.value("pos", QPoint(center.x() - self.width() * 0.5, center.y() - self.height() * 0.5)) size = self.gui_settings.value("size", self.size()) self.move(pos) self.resize(size) self.show()
self.quitAction = QAction("&Quit", self, triggered=QApplication.instance().quit) 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) if __name__ == '__main__': import sys app = QApplication(sys.argv) if not QSystemTrayIcon.isSystemTrayAvailable(): QMessageBox.critical(None, "Systray", "I couldn't detect any system tray on this system.") sys.exit(1) QApplication.setQuitOnLastWindowClosed(False) window = Window() window.show() sys.exit(app.exec_())