def openShowSelection(self, show: TvShow(), result: list()): select = ShowSelectionWindow(show.estimatedTitle, result) select.setWindowModality(Qt.WindowModal) mw = qtmodern.windows.ModernWindow(select) mw.setWindowModality(Qt.WindowModal) mw.show() # This loop will wait for the window is destroyed loop = QEventLoop() select.finished.connect(loop.quit) loop.exec() return select.acceptedId
def openMovieSelection(self, movie: Movie(), result: list()): select = MovieSelectionWindow(movie.file.fullNameAndPath, result) select.setWindowModality(Qt.WindowModal) mw = qtmodern.windows.ModernWindow(select) mw.setWindowModality(Qt.WindowModal) mw.show() # This loop will wait for the window is destroyed loop = QEventLoop() select.finished.connect(loop.quit) loop.exec() return select.acceptedId
def enterId(self): select = CustomEnterWindow(True) select.setWindowModality(Qt.WindowModal) mw = qtmodern.windows.ModernWindow(select) mw.setWindowModality(Qt.WindowModal) mw.show() select.ui.txtId.setFocus() loop = QEventLoop() select.finished.connect(loop.quit) loop.exec() if select.result != None and select.result.isdecimal(): self.acceptedId = int(select.result) self.close()
def __enterTitleWindow__(self, search): select = CustomEnterWindow(False) select.setWindowModality(Qt.WindowModal) mw = qtmodern.windows.ModernWindow(select) mw.setWindowModality(Qt.WindowModal) mw.show() select.ui.txtId.setFocus() loop = QEventLoop() select.finished.connect(loop.quit) loop.exec() if select.result != None: self.__possibilities__ = search(select.result) self.actualizeTable()
class _QtMainWindow(QMainWindow): # This was added so that someone can patch # `napari._qt.qt_main_window._QtMainWindow._window_icon` # to their desired window icon _window_icon = NAPARI_ICON_PATH # To track window instances and facilitate getting the "active" viewer... # We use this instead of QApplication.activeWindow for compatibility with # IPython usage. When you activate IPython, it will appear that there are # *no* active windows, so we want to track the most recently active windows _instances: ClassVar[List['_QtMainWindow']] = [] def __init__(self, viewer: 'Viewer', parent=None) -> None: super().__init__(parent) self._ev = None self._qt_viewer = QtViewer(viewer, show_welcome_screen=True) self._quit_app = False self.setWindowIcon(QIcon(self._window_icon)) self.setAttribute(Qt.WA_DeleteOnClose) self.setUnifiedTitleAndToolBarOnMac(True) center = QWidget(self) center.setLayout(QHBoxLayout()) center.layout().addWidget(self._qt_viewer) center.layout().setContentsMargins(4, 0, 4, 0) self.setCentralWidget(center) self.setWindowTitle(self._qt_viewer.viewer.title) self._maximized_flag = False self._window_size = None self._window_pos = None self._old_size = None self._positions = [] act_dlg = QtActivityDialog(self._qt_viewer._canvas_overlay) self._qt_viewer._canvas_overlay.resized.connect( act_dlg.move_to_bottom_right ) act_dlg.hide() self._activity_dialog = act_dlg self.setStatusBar(ViewerStatusBar(self)) settings = get_settings() # TODO: # settings.plugins.defaults.call_order = plugin_manager.call_order() # set the values in plugins to match the ones saved in settings if settings.plugins.call_order is not None: plugin_manager.set_call_order(settings.plugins.call_order) _QtMainWindow._instances.append(self) # since we initialize canvas before window, # we need to manually connect them again. handle = self.windowHandle() if handle is not None: handle.screenChanged.connect( self._qt_viewer.canvas._backend.screen_changed ) def statusBar(self) -> 'ViewerStatusBar': return super().statusBar() @classmethod def current(cls): return cls._instances[-1] if cls._instances else None @classmethod def current_viewer(cls): window = cls.current() return window._qt_viewer.viewer if window else None def event(self, e): if ( e.type() == QEvent.ToolTip and self._qt_viewer.viewer.tooltip.visible ): QToolTip.showText( e.globalPos(), self._qt_viewer.viewer.tooltip.text, self ) if e.type() == QEvent.Close: # when we close the MainWindow, remove it from the instances list try: _QtMainWindow._instances.remove(self) except ValueError: pass if e.type() in {QEvent.WindowActivate, QEvent.ZOrderChange}: # upon activation or raise_, put window at the end of _instances try: inst = _QtMainWindow._instances inst.append(inst.pop(inst.index(self))) except ValueError: pass return super().event(e) def _load_window_settings(self): """ Load window layout settings from configuration. """ settings = get_settings() window_position = settings.application.window_position # It's necessary to verify if the window/position value is valid with # the current screen. if not window_position: window_position = (self.x(), self.y()) else: width, height = window_position screen_geo = QApplication.desktop().geometry() if screen_geo.width() < width or screen_geo.height() < height: window_position = (self.x(), self.y()) return ( settings.application.window_state, settings.application.window_size, window_position, settings.application.window_maximized, settings.application.window_fullscreen, ) def _get_window_settings(self): """Return current window settings. Symmetric to the 'set_window_settings' setter. """ window_fullscreen = self.isFullScreen() if window_fullscreen: window_maximized = self._maximized_flag else: window_maximized = self.isMaximized() window_state = qbytearray_to_str(self.saveState()) return ( window_state, self._window_size or (self.width(), self.height()), self._window_pos or (self.x(), self.y()), window_maximized, window_fullscreen, ) def _set_window_settings( self, window_state, window_size, window_position, window_maximized, window_fullscreen, ): """ Set window settings. Symmetric to the 'get_window_settings' accessor. """ self.setUpdatesEnabled(False) self.setWindowState(Qt.WindowNoState) if window_position: window_position = QPoint(*window_position) self.move(window_position) if window_size: window_size = QSize(*window_size) self.resize(window_size) if window_state: self.restoreState(str_to_qbytearray(window_state)) # Toggling the console visibility is disabled when it is not # available, so ensure that it is hidden. if in_ipython(): self._qt_viewer.dockConsole.setVisible(False) if window_fullscreen: self.setWindowState(Qt.WindowFullScreen) self._maximized_flag = window_maximized elif window_maximized: self.setWindowState(Qt.WindowMaximized) self.setUpdatesEnabled(True) def _save_current_window_settings(self): """Save the current geometry of the main window.""" ( window_state, window_size, window_position, window_maximized, window_fullscreen, ) = self._get_window_settings() settings = get_settings() if settings.application.save_window_geometry: settings.application.window_maximized = window_maximized settings.application.window_fullscreen = window_fullscreen settings.application.window_position = window_position settings.application.window_size = window_size settings.application.window_statusbar = ( not self.statusBar().isHidden() ) if settings.application.save_window_state: settings.application.window_state = window_state def close(self, quit_app=False): """Override to handle closing app or just the window.""" self._quit_app = quit_app return super().close() def close_window(self): """Close active dialog or active window.""" parent = QApplication.focusWidget() while parent is not None: if isinstance(parent, QMainWindow): self.close() break if isinstance(parent, QDialog): parent.close() break try: parent = parent.parent() except Exception: parent = getattr(parent, "_parent", None) def show(self, block=False): super().show() if block: self._ev = QEventLoop() self._ev.exec() def changeEvent(self, event): """Handle window state changes.""" if event.type() == QEvent.WindowStateChange: # TODO: handle maximization issue. When double clicking on the # title bar on Mac the resizeEvent is called an varying amount # of times which makes it hard to track the original size before # maximization. condition = ( self.isMaximized() if os.name == "nt" else self.isFullScreen() ) if condition and self._old_size is not None: if self._positions and len(self._positions) > 1: self._window_pos = self._positions[-2] self._window_size = ( self._old_size.width(), self._old_size.height(), ) else: self._old_size = None self._window_pos = None self._window_size = None self._positions = [] super().changeEvent(event) def resizeEvent(self, event): """Override to handle original size before maximizing.""" # the first resize event will have nonsense positions that we dont # want to store (and potentially restore) if event.oldSize().isValid(): self._old_size = event.oldSize() self._positions.append((self.x(), self.y())) if self._positions and len(self._positions) >= 2: self._window_pos = self._positions[-2] self._positions = self._positions[-2:] super().resizeEvent(event) def closeEvent(self, event): """This method will be called when the main window is closing. Regardless of whether cmd Q, cmd W, or the close button is used... """ if self._ev and self._ev.isRunning(): self._ev.quit() # Close any floating dockwidgets for dock in self.findChildren(QtViewerDockWidget): if dock.isFloating(): dock.setFloating(False) self._save_current_window_settings() # On some versions of Darwin, exiting while fullscreen seems to tickle # some bug deep in NSWindow. This forces the fullscreen keybinding # test to complete its draw cycle, then pop back out of fullscreen. if self.isFullScreen(): self.showNormal() for _i in range(5): time.sleep(0.1) QApplication.processEvents() if self._quit_app: quit_app() event.accept() def restart(self): """Restart the napari application in a detached process.""" process = QProcess() process.setProgram(sys.executable) if not running_as_bundled_app(): process.setArguments(sys.argv) process.startDetached() self.close(quit_app=True) @staticmethod @Slot(Notification) def show_notification(notification: Notification): """Show notification coming from a thread.""" NapariQtNotification.show_notification(notification)