def openPopover(self, name="popover", html="UniqueBible.app", fullScreen=False, screenNo=-1): # image options if config.exportEmbeddedImages: html = self.parent.parent.exportAllImages(html) if config.clickToOpenImage: html = self.parent.parent.addOpenImageAction(html) # format html content html = self.parent.parent.wrapHtml(html) if not hasattr(self, "popoverView") or not self.popoverView.isVisible: self.popoverView = WebEngineViewPopover(self, name, self.name) self.popoverView.setHtml(html, config.baseUrl) if fullScreen: monitor = QDesktopWidget().screenGeometry(screenNo) self.popoverView.move(monitor.left(), monitor.top()) if platform.system() == "Linux": # Using self.popoverView.showFullScreen() directly does not work on Linux self.popoverView.showMaximized() self.popoverView.escKeyPressed() else: self.popoverView.showFullScreen() else: self.popoverView.setMinimumWidth(config.popoverWindowWidth) self.popoverView.setMinimumHeight(config.popoverWindowHeight) self.popoverView.show()
def setup_for_first_run(self): """Assume this is a first run of the application and set layouts accordingly""" self.setWindowState(Qt.WindowMaximized) desktop = QDesktopWidget() self.window_size = desktop.screenGeometry().size() self.setup_default_layouts()
def get_screen_size(): """Get **available** screen size/resolution.""" if mpl.get_backend().startswith('Qt'): # Inspired by spyder/widgets/shortcutssummary.py from qtpy.QtWidgets import QDesktopWidget # noqa widget = QDesktopWidget() sg = widget.availableGeometry(widget.primaryScreen()) x0 = sg.x() y0 = sg.y() w0 = sg.width() h0 = sg.height() elif mpl.get_backend() == "TkAgg": # https://stackoverflow.com/a/42951711/38281 window = plt.get_current_fig_manager().window x0, y0 = 0, 0 w0, h0 = window.wm_maxsize() # h = window.winfo_screenheight() # w = window.winfo_screenwidth() else: # Mac Retina Early 2013 x0 = 0 y0 = 23 w0 = 1280 h0 = 773 return x0, y0, w0, h0
def get_screen_resolution(self): """ """ widget = QDesktopWidget() geometry = widget.availableGeometry(widget.primaryScreen()) value = "{0}x{1}".format(geometry.width(), geometry.height()) return value
def _detrend_end(self, result): self.detrendButton.setEnabled(True) self.df_fit = result['fit'] self.df_residual = result['residual'] self.df_continuous = result['continuous'] if self.actionDetrendLog.isChecked(): pos = self.frameGeometry().topRight() x = pos.x() y = pos.y() rect = QDesktopWidget().screenGeometry() if x + 10 > rect.width(): x -= 320 y += 30 else: y += 20 x += 20 self.logDialog = TSLogDialog(parent=self, name=self.site, log=result['log']) self.logDialog.setGeometry(x, y, 300, self.frameGeometry().height() - 20) self.logDialog.show() else: log = result['log'] self.display_information(log) self.detrend_plot_check() self._update_data_combox()
def setup_for_first_run(self): """Assume this is a first run of the application and set layouts accordingly""" self.setWindowState(Qt.WindowMaximized) desktop = QDesktopWidget() self.window_size = desktop.screenGeometry().size() self.setup_default_layouts()
def readSettings(self, settings): qapp = QApplication.instance() # get the saved window geometry window_size = settings.get('MainWindow/size') if not isinstance(window_size, QSize): window_size = QSize(*window_size) window_pos = settings.get('MainWindow/position') if not isinstance(window_pos, QPoint): window_pos = QPoint(*window_pos) if settings.has('MainWindow/font'): font_string = settings.get('MainWindow/font').split(',') font = QFontDatabase().font(font_string[0], font_string[-1], int(font_string[1])) qapp.setFont(font) # reset font for ipython console to ensure it stays monospace self.ipythonconsole.console.reset_font() # make sure main window is smaller than the desktop desktop = QDesktopWidget() # this gives the maximum screen number if the position is off screen screen = desktop.screenNumber(window_pos) # recalculate the window size desktop_geom = desktop.availableGeometry(screen) w = min(desktop_geom.size().width(), window_size.width()) h = min(desktop_geom.size().height(), window_size.height()) window_size = QSize(w, h) # and position it on the supplied desktop screen x = max(window_pos.x(), desktop_geom.left()) y = max(window_pos.y(), desktop_geom.top()) if x + w > desktop_geom.right(): x = desktop_geom.right() - w if y + h > desktop_geom.bottom(): y = desktop_geom.bottom() - h window_pos = QPoint(x, y) # set the geometry self.resize(window_size) self.move(window_pos) # restore window state if settings.has('MainWindow/state'): if not self.restoreState(settings.get('MainWindow/state'), SAVE_STATE_VERSION): logger.warning( "The previous layout of workbench is not compatible with this version, reverting to default layout." ) else: self.setWindowState(Qt.WindowMaximized) # read in settings for children AlgorithmInputHistory().readSettings(settings) for widget in self.widgets: if hasattr(widget, 'readSettingsIfNotDone'): widget.readSettingsIfNotDone(settings)
def get_screen_resolution(): """Return the screen resolution of the primary screen.""" try: widget = QDesktopWidget() geometry = widget.availableGeometry(widget.primaryScreen()) value = "{0}x{1}".format(geometry.width(), geometry.height()) except Exception: value = None return value
def readSettings(self, settings): qapp = QApplication.instance() qapp.setAttribute(Qt.AA_UseHighDpiPixmaps) if hasattr(Qt, 'AA_EnableHighDpiScaling'): qapp.setAttribute(Qt.AA_EnableHighDpiScaling, settings.get('high_dpi_scaling')) # get the saved window geometry window_size = settings.get('MainWindow/size') if not isinstance(window_size, QSize): window_size = QSize(*window_size) window_pos = settings.get('MainWindow/position') if not isinstance(window_pos, QPoint): window_pos = QPoint(*window_pos) if settings.has('MainWindow/font'): font_string = settings.get('MainWindow/font').split(',') font = QFontDatabase().font(font_string[0], font_string[-1], int(font_string[1])) qapp.setFont(font) # make sure main window is smaller than the desktop desktop = QDesktopWidget() # this gives the maximum screen number if the position is off screen screen = desktop.screenNumber(window_pos) # recalculate the window size desktop_geom = desktop.availableGeometry(screen) w = min(desktop_geom.size().width(), window_size.width()) h = min(desktop_geom.size().height(), window_size.height()) window_size = QSize(w, h) # and position it on the supplied desktop screen x = max(window_pos.x(), desktop_geom.left()) y = max(window_pos.y(), desktop_geom.top()) if x + w > desktop_geom.right(): x = desktop_geom.right() - w if y + h > desktop_geom.bottom(): y = desktop_geom.bottom() - h window_pos = QPoint(x, y) # set the geometry self.resize(window_size) self.move(window_pos) # restore window state if settings.has('MainWindow/state'): self.restoreState(settings.get('MainWindow/state')) else: self.setWindowState(Qt.WindowMaximized) # read in settings for children AlgorithmInputHistory().readSettings(settings) for widget in self.widgets: if hasattr(widget, 'readSettings'): widget.readSettings(settings)
def __honour_image_aspect_ratio(self): ''' resizes the window to fit the image aspect ratio based on the chart size ''' if len(self.image.text()) > 0: width, height = Image.open(self.image.text()).size width_delta = width - self.__x height_delta = height - self.__y if width_delta != 0 or height_delta != 0: win_size = self.size() target_size = QSize(win_size.width() + width_delta, win_size.height() + height_delta) available_size = QDesktopWidget().availableGeometry() if available_size.width() < target_size.width() or available_size.height() < target_size.height(): target_size.scale(available_size.width() - 48, available_size.height() - 48, Qt.KeepAspectRatio) self.resize(target_size)
def _center_main_window(self): self.logger.info("MainWindow._center_main_window") qr = self.frameGeometry() cp = QDesktopWidget().availableGeometry().center() qr.moveCenter(cp) self.move(qr.topLeft())
def __init__(self, parent=None): super(NativeNotification, self).__init__(parent=parent) time = datetime.now() current_time = "{}:{}".format(time.hour, time.minute) self.setWindowFlags(Qt.Tool | Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint | Qt.WindowSystemMenuHint) resolution = QDesktopWidget().screenGeometry(-1) screenWidth = resolution.width() screenHeight = resolution.height() self.nMessages = 0 self.mainLayout = QVBoxLayout(self) self.move(screenWidth, 0)
def readSettings(self, settings): qapp = QApplication.instance() qapp.setAttribute(Qt.AA_UseHighDpiPixmaps) if hasattr(Qt, 'AA_EnableHighDpiScaling'): qapp.setAttribute(Qt.AA_EnableHighDpiScaling, settings.get('high_dpi_scaling')) # get the saved window geometry window_size = settings.get('MainWindow/size') if not isinstance(window_size, QSize): window_size = QSize(*window_size) window_pos = settings.get('MainWindow/position') if not isinstance(window_pos, QPoint): window_pos = QPoint(*window_pos) # make sure main window is smaller than the desktop desktop = QDesktopWidget() # this gives the maximum screen number if the position is off screen screen = desktop.screenNumber(window_pos) # recalculate the window size desktop_geom = desktop.screenGeometry(screen) w = min(desktop_geom.size().width(), window_size.width()) h = min(desktop_geom.size().height(), window_size.height()) window_size = QSize(w, h) # and position it on the supplied desktop screen x = max(window_pos.x(), desktop_geom.left()) y = max(window_pos.y(), desktop_geom.top()) window_pos = QPoint(x, y) # set the geometry self.resize(window_size) self.move(window_pos) # restore window state if settings.has('MainWindow/state'): self.restoreState(settings.get('MainWindow/state')) else: self.setWindowState(Qt.WindowMaximized) # read in settings for children AlgorithmInputHistory().readSettings(settings) for widget in self.widgets: if hasattr(widget, 'readSettings'): widget.readSettings(settings)
def get_screen_size(): """Get **available** screen size/resolution.""" if mpl.get_backend().startswith('Qt'): # Inspired by spyder/widgets/shortcutssummary.py from qtpy.QtWidgets import QDesktopWidget widget = QDesktopWidget() sg = widget.availableGeometry(widget.primaryScreen()) x0 = sg.x() y0 = sg.y() w0 = sg.width() h0 = sg.height() else: # Mac Retina Early 2013 x0 = 0 y0 = 23 w0 = 1280 h0 = 773 return x0, y0, w0, h0
def readSettings(self, settings): qapp = QApplication.instance() qapp.setAttribute(Qt.AA_UseHighDpiPixmaps) if hasattr(Qt, 'AA_EnableHighDpiScaling'): qapp.setAttribute(Qt.AA_EnableHighDpiScaling, settings.get('main/high_dpi_scaling')) # get the saved window geometry window_size = settings.get('main/window/size') if not isinstance(window_size, QSize): window_size = QSize(*window_size) window_pos = settings.get('main/window/position') if not isinstance(window_pos, QPoint): window_pos = QPoint(*window_pos) # make sure main window is smaller than the desktop desktop = QDesktopWidget() # this gives the maximum screen number if the position is off screen screen = desktop.screenNumber(window_pos) # recalculate the window size desktop_geom = desktop.screenGeometry(screen) w = min(desktop_geom.size().width(), window_size.width()) h = min(desktop_geom.size().height(), window_size.height()) window_size = QSize(w, h) # and position it on the supplied desktop screen x = max(window_pos.x(), desktop_geom.left()) y = max(window_pos.y(), desktop_geom.top()) window_pos = QPoint(x, y) # set the geometry self.resize(window_size) self.move(window_pos) # restore window state if settings.has('main/window/state'): self.restoreState(settings.get('main/window/state')) else: self.setWindowState(Qt.WindowMaximized) # have algorithm dialogs do their thing AlgorithmInputHistory().readSettings(settings)
def ensure_widget_is_on_screen(widget): """If the supplied widget is off the screen it will be moved so it is on the screen. The widget must already be 'shown' """ # this gives the maximum screen number if the position is off screen desktop = QDesktopWidget() screen = desktop.screenNumber(widget.pos()) # get the window size desktop_geom = desktop.availableGeometry(screen) # get the widget dimensions with any os added extras widget_geom = widget.frameGeometry() # and position it on the supplied desktop screen x = max(widget_geom.x(), desktop_geom.left()) y = max(widget_geom.y(), desktop_geom.top()) if x + widget_geom.width() > desktop_geom.right(): x = desktop_geom.right() - widget_geom.width() if y + widget_geom.height() > desktop_geom.bottom(): y = desktop_geom.bottom() - widget_geom.height() window_pos = QPoint(x, y) widget.move(window_pos)
def alignToDisplay(self, alignment): """ Determines where on the monitor the widget should be located Args: Alignment (QtCore.Qt.Alignment): Determines where on the monitor to position the widget. AlignLeft AlignRight AlignTop AlignBottom """ # set screen properties self.screen_geometry = QDesktopWidget().screenGeometry(-1) self.screen_width = self.screen_geometry.width() self.screen_height = self.screen_geometry.height() self.screen_pos = self.screen_geometry.topLeft() if alignment == Qt.AlignLeft: height = self.screen_height width = self.getDepth() pos = self.screen_pos elif alignment == Qt.AlignRight: height = self.screen_height width = self.getDepth() pos_x = (self.screen_pos.x() + self.screen_width - self.getDepth()) pos = QPoint(pos_x, self.screen_pos.y()) elif alignment == Qt.AlignTop: height = self.getDepth() width = self.screen_width pos = self.screen_pos elif alignment == Qt.AlignBottom: height = self.getDepth() width = self.screen_width pos_y = (self.screen_pos.y() + self.screen_height - self.getDepth()) pos = QPoint(self.screen_pos.x(), pos_y) self.setFixedHeight(height) self.setFixedWidth(width) self.move(pos)
def toggle_fullscreen(self): """ Toggle option to show the mainwindow in fullscreen or windowed. Returns ------- None. """ main = self.main if self._fullscreen_flag: self._fullscreen_flag = False if os.name == 'nt': main.setWindowFlags(main.windowFlags() ^ (Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint)) main.setGeometry(self._saved_normal_geometry) main.showNormal() if self._maximized_flag: main.showMaximized() else: self._maximized_flag = main.isMaximized() self._fullscreen_flag = True self._saved_normal_geometry = main.normalGeometry() if os.name == 'nt': # Due to limitations of the Windows DWM, compositing is not # handled correctly for OpenGL based windows when going into # full screen mode, so we need to use this workaround. # See spyder-ide/spyder#4291. main.setWindowFlags(main.windowFlags() | Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint) screen_number = QDesktopWidget().screenNumber(main) if screen_number < 0: screen_number = 0 r = QApplication.desktop().screenGeometry(screen_number) main.setGeometry(r.left() - 1, r.top() - 1, r.width() + 2, r.height() + 2) main.showNormal() else: main.showFullScreen() self._update_fullscreen_action()
def eventloop(shell, init_code=None, init_file=None, console_id=0, pictures=None): """ The GUI Process and Thread running the eventloop """ shell.logdir.find_log_path() qapp = GuiApplication(shell, sys.argv) qapp.setShortCuts() qapp.newWindow('main') #To run in a new thread but on the same gui process #panid = qapp.mainWindow.newThread() qapp.mainWindow.show() desktopGeometry = QDesktopWidget().availableGeometry() qapp.mainWindow.resize(int(desktopGeometry.width() * 3 / 5), int(desktopGeometry.height() * 3 / 5)) qtRectangle = qapp.mainWindow.frameGeometry() centerPoint = desktopGeometry.center() qtRectangle.moveCenter(centerPoint) qapp.mainWindow.move(qtRectangle.topLeft()) # Make sure the gui proxy for the main thread is created qapp.panels.restore_state_from_config('base') # if not config['debug']['skip_restore_perspective']: # if config['default_perspective'] != 'base': # qapp.panels.restore_state_from_config(config['default_perspective']) qapp.processEvents() qapp.cmdserver = CommandServer(shell) if not init_file is None: cmd = {'cmd': 'execute_file', 'args': (init_file, console_id)} qapp.cmdserver.cmd_queue.put(cmd) if not init_code is None: cmd = {'cmd': 'execute_code', 'args': (init_code, console_id)} qapp.cmdserver.cmd_queue.put(cmd) if not pictures is None: cmd = {'cmd': 'open_images', 'args': pictures} qapp.cmdserver.cmd_queue.put(cmd) cmd = config.get('init_command') qapp.cmdserver.cmd_queue.put(cmd) qapp.cmdserver.start_queue_loop(qapp) qapp.cmdserver.start(qapp) exit_code = qapp.exec_() #Kill all the children parent = psutil.Process(os.getpid()) for child in parent.children(recursive=True): child.kill() from pylab import plt plt.close('all') sys.stdout = sys.__stdout__ sys.stderr = sys.__stderr__ print(f'Exiting {PROGNAME}. Releasing lock.') shell.logdir.release_lock_file()
def center_window(window: QWidget): screen = QDesktopWidget().screenGeometry() size = window.geometry() window.move(int((screen.width() - size.width()) / 2), int((screen.height() - size.height()) / 2))
def get_screen_resolution(self): """Return the screen resolution of the primary screen.""" widget = QDesktopWidget() geometry = widget.availableGeometry(widget.primaryScreen()) return geometry.width(), geometry.height()
def center_widget_on_screen(widget): rect = widget.frameGeometry() center = QDesktopWidget().availableGeometry().center() rect.moveCenter(center) widget.move(rect.topLeft())
def getAllScreensWorkspace() -> list: """Returns workspaces of all the available screen.s""" return [ QDesktopWidget().availableGeometry(x) for x in range(QDesktopWidget().screenCount()) ]
def getAllScreensGeometry() -> list: """Returns geometries of all the available screens.""" return [ QDesktopWidget().screenGeometry(x) for x in range(QDesktopWidget().screenCount()) ]
def screen_resolutions(self): width = 0 for displayNr in range(QDesktopWidget().screenCount()): sizeObject = QDesktopWidget().screenGeometry(displayNr) width += sizeObject.width() return width - 5
def placescreen(self, pos): resolution = QDesktopWidget().screenGeometry() self.move( (resolution.width() / pos) - (self.frameSize().width() / pos), (resolution.height() / pos) - (self.frameSize().height() / pos))
def center(self): """居中显示""" qr = self.frameGeometry() # 获得frame cp = QDesktopWidget().availableGeometry().center() qr.moveCenter(cp) self.move(qr.topLeft())
def move_to(self, position='top', *, win_ratio=0.9, min_length=0): """Move popup to a position relative to the QMainWindow. Parameters ---------- position : {str, tuple}, optional position in the QMainWindow to show the pop, by default 'top' if str: must be one of {'top', 'bottom', 'left', 'right' } if tuple: must be length 4 with (left, top, width, height) win_ratio : float, optional Fraction of the width (for position = top/bottom) or height (for position = left/right) of the QMainWindow that the popup will occupy. Only valid when isinstance(position, str). by default 0.9 min_length : int, optional Minimum size of the long dimension (width for top/bottom or height fort left/right). Raises ------ ValueError if position is a string and not one of {'top', 'bottom', 'left', 'right' } """ if isinstance(position, str): window = self.parent().window() if self.parent() else None if not window: raise ValueError( "Specifying position as a string is only posible if " "the popup has a parent") left = window.pos().x() top = window.pos().y() if position in ('top', 'bottom'): width = window.width() * win_ratio width = max(width, min_length) left += (window.width() - width) / 2 height = self.sizeHint().height() top += (24 if position == 'top' else (window.height() - height - 12)) elif position in ('left', 'right'): height = window.height() * win_ratio height = max(height, min_length) # 22 is for the title bar top += 22 + (window.height() - height) / 2 width = self.sizeHint().width() left += (12 if position == 'left' else (window.width() - width - 12)) else: raise ValueError('position must be one of ' '["top", "left", "bottom", "right"]') elif isinstance(position, (tuple, list)): assert len(position) == 4, '`position` argument must have length 4' left, top, width, height = position else: raise ValueError(f"Wrong type of position {position}") # necessary for transparent round corners self.resize(self.sizeHint()) # make sure the popup is completely on the screen # In Qt ≥5.10 we can use screenAt to know which monitor the mouse is on if hasattr(QGuiApplication, "screenAt"): screen_geometry: QRect = QGuiApplication.screenAt( QCursor.pos()).geometry() else: # This widget is deprecated since Qt 5.11 from qtpy.QtWidgets import QDesktopWidget screen_num = QDesktopWidget().screenNumber(QCursor.pos()) screen_geometry = QGuiApplication.screens()[screen_num].geometry() left = max(min(screen_geometry.right() - width, left), screen_geometry.left()) top = max(min(screen_geometry.bottom() - height, top), screen_geometry.top()) self.setGeometry(left, top, width, height)
class AbstractSlideDisplay(QWidget): """ Abstract class for all slide bars. This will be inherited by the HSVSlideDisplay and UnitSlideDisplay. The base properties of this widget are to create the containter for these widgets, and then subclass this widget and draw the visuals. Kwargs: ** alignment (QtCore.Qt.Align): where the widget should be align relative to the display ** depth (int): how wide/tall the widget should be depending on its orientation ** display_widget (QWidget): optional argument. If entered, the display will show up over that widget rather than over the main display. Attributes: alignment (Qt.Alignment): Where widget should be aligned depth (int): width/height of the slideBar (depends on orientation) display_widget (QWidget): optional argument. If entered, the display will show up over that widget rather than over the main display. Notes: - This should be abstracted for SliderBar--> HueSlideDisplay SatSlideDisplay ValueSlideDisplay UnitSlideDisplay """ def __init__(self, parent=None, alignment=Qt.AlignBottom, depth=50, display_widget=None): super(AbstractSlideDisplay, self).__init__(parent) setAsTool(self) # set properties self.setDisplayWidget(display_widget) self.setDepth(depth) self.setAlignment(alignment) """ API """ def getDepth(self): return self._depth def setDepth(self, depth): self._depth = depth def getAlignment(self): return self._alignment def setAlignment(self, alignment): self._alignment = alignment def getDisplayWidget(self): return self._display_widget def setDisplayWidget(self, display_widget): self._display_widget = display_widget """ UTILS """ def setWidgetPosition(self, alignment, widget=None): """ Picks which algorithm to use to determine the widgets position If 'display_widget' is defined, then it will align to that widget, if not, it will align to the main display on the system. """ _accepted = [Qt.AlignLeft, Qt.AlignRight, Qt.AlignTop, Qt.AlignBottom] if alignment in _accepted: if widget: self.alignToWidget(alignment, widget) else: self.alignToDisplay(alignment) def alignToWidget(self, alignment, widget): """ Determines where on the monitor the widget should be located Args: * alignment (QtCore.Qt.Alignment): Determines where on the monitor to position the widget. AlignLeft AlignRight AlignTop AlignBottom * widget (QWidget): The QWidget that the slide bar should be aligned to. """ screen_pos = getGlobalPos(widget) if alignment == Qt.AlignLeft: height = widget.height() width = self.getDepth() pos = screen_pos elif alignment == Qt.AlignRight: height = widget.height() width = self.getDepth() pos_x = (screen_pos.x() + widget.width() - self.getDepth()) pos = QPoint(pos_x, screen_pos.y()) elif alignment == Qt.AlignTop: height = self.getDepth() width = widget.width() pos = screen_pos elif alignment == Qt.AlignBottom: height = self.getDepth() width = widget.width() pos_y = (screen_pos.y() + widget.height() - self.getDepth()) pos = QPoint(screen_pos.x(), pos_y) self.setFixedHeight(height) self.setFixedWidth(width) self.move(pos) def alignToDisplay(self, alignment): """ Determines where on the monitor the widget should be located Args: Alignment (QtCore.Qt.Alignment): Determines where on the monitor to position the widget. AlignLeft AlignRight AlignTop AlignBottom """ # set screen properties self.screen_geometry = QDesktopWidget().screenGeometry(-1) self.screen_width = self.screen_geometry.width() self.screen_height = self.screen_geometry.height() self.screen_pos = self.screen_geometry.topLeft() if alignment == Qt.AlignLeft: height = self.screen_height width = self.getDepth() pos = self.screen_pos elif alignment == Qt.AlignRight: height = self.screen_height width = self.getDepth() pos_x = (self.screen_pos.x() + self.screen_width - self.getDepth()) pos = QPoint(pos_x, self.screen_pos.y()) elif alignment == Qt.AlignTop: height = self.getDepth() width = self.screen_width pos = self.screen_pos elif alignment == Qt.AlignBottom: height = self.getDepth() width = self.screen_width pos_y = (self.screen_pos.y() + self.screen_height - self.getDepth()) pos = QPoint(self.screen_pos.x(), pos_y) self.setFixedHeight(height) self.setFixedWidth(width) self.move(pos) def update(self, *args, **kwargs): print('you need to reimplement this on: {}'.format(self)) return QWidget.update(self, *args, **kwargs) """ EVENTS""" def keyPressEvent(self, event, *args, **kwargs): if event.key() == Qt.Key_Escape: self.close() return QWidget.keyPressEvent(self, event, *args, **kwargs)
def get_screen_resolution(self): """Return the screen resolution of the primary screen.""" widget = QDesktopWidget() geometry = widget.availableGeometry(widget.primaryScreen()) return geometry.width(), geometry.height()
def screen_center(self): return QDesktopWidget().availableGeometry().center()