Python QtWidgets.QDialog类代码示例

 def keyPressEvent(self, e):
     """Handle default key actions or pass the event to the inherited method
     """
     if (int(e.modifiers()), e.key()) in OWWidget.defaultKeyActions:
         OWWidget.defaultKeyActions[int(e.modifiers()), e.key()](self)
     else:
         QDialog.keyPressEvent(self, e)

    def __init__(self, parent=None, flags=Qt.WindowFlags(0),
                 model=None, **kwargs):
        QDialog.__init__(self, parent, flags, **kwargs)

        self.__setupUi()
        if model is not None:
            self.setModel(model)

    def __init__(self, parent=None, **kwargs):
        QDialog.__init__(self, parent, **kwargs)

        if sys.platform == "darwin":
            self.setAttribute(Qt.WA_MacSmallSize, True)

        self.__setupUi()

 def test_escape_hides(self):
     window = QDialog()
     w = WebviewWidget(window)
     window.show()
     w.setFocus(Qt.OtherFocusReason)
     self.assertFalse(window.isHidden())
     QTest.keyClick(w, Qt.Key_Escape)
     self.assertTrue(window.isHidden())

 def showEvent(self, event):
     """Overloaded to restore the geometry when the widget is shown
     """
     QDialog.showEvent(self, event)
     if self.save_position and not self.__was_restored:
         # Restore saved geometry on show
         self.__restoreWidgetGeometry()
         self.__was_restored = True
     self.__quicktipOnce()

 def showEvent(self, event):
     """Overloaded to restore the geometry when the widget is shown
     """
     QDialog.showEvent(self, event)
     if self.save_position and not self.__was_restored:
         # Restore saved geometry on (first) show
         if self.__splitter is not None:
             self.__splitter.setControlAreaVisible(self.controlAreaVisible)
         self.__restoreWidgetGeometry()
         self.__was_restored = True
     self.__quicktipOnce()

 def resizeEvent(self, event):
     """Overloaded to save the geometry (width and height) when the widget
     is resized.
     """
     QDialog.resizeEvent(self, event)
     # Don't store geometry if the widget is not visible
     # (the widget receives a resizeEvent (with the default sizeHint)
     # before first showEvent and we must not overwrite the the
     # savedGeometry with it)
     if self.save_position and self.isVisible():
         self.__updateSavedGeometry()

    def __new__(cls, *args, captionTitle=None, **kwargs):
        self = super().__new__(cls, None, cls.get_flags())
        QDialog.__init__(self, None, self.get_flags())
        OWComponent.__init__(self)
        WidgetMessagesMixin.__init__(self)
        WidgetSignalsMixin.__init__(self)

        stored_settings = kwargs.get('stored_settings', None)
        if self.settingsHandler:
            self.settingsHandler.initialize(self, stored_settings)

        self.signalManager = kwargs.get('signal_manager', None)
        self.__env = _asmappingproxy(kwargs.get("env", {}))

        self.graphButton = None
        self.report_button = None

        OWWidget.widget_id += 1
        self.widget_id = OWWidget.widget_id

        captionTitle = self.name if captionTitle is None else captionTitle

        # must be set without invoking setCaption
        self.captionTitle = captionTitle
        self.setWindowTitle(captionTitle)

        self.setFocusPolicy(Qt.StrongFocus)

        self.__blocking = False

        # flag indicating if the widget's position was already restored
        self.__was_restored = False

        self.__statusMessage = ""

        self.__msgwidget = None
        self.__msgchoice = 0

        self.left_side = None
        self.controlArea = self.mainArea = self.buttonsArea = None
        self.splitter = None
        if self.want_basic_layout:
            self.set_basic_layout()

        sc = QShortcut(QKeySequence(Qt.ShiftModifier | Qt.Key_F1), self)
        sc.activated.connect(self.__quicktip)

        sc = QShortcut(QKeySequence.Copy, self)
        sc.activated.connect(self.copy_to_clipboard)
        if self.controlArea is not None:
            # Otherwise, the first control has focus
            self.controlArea.setFocus(Qt.ActiveWindowFocusReason)
        return self

    def __init__(self, master):
        """Initialize the attributes and set up the interface"""
        QDialog.__init__(self, master, windowTitle=self.captionTitle)
        WidgetMessagesMixin.__init__(self)
        self.setLayout(QVBoxLayout())

        self.insert_message_bar()
        self.layout().insertWidget(0, self.message_bar)
        self.master = master

        self.keep_running = False
        self.scheduled_call = None
        self.saved_state = None
        self.saved_progress = 0
        self.scores = []
        self.add_to_model = queue.Queue()

        self.update_timer = QTimer(self)
        self.update_timer.timeout.connect(self._update)
        self.update_timer.setInterval(200)

        self._thread = None
        self._worker = None

        self.filter = QLineEdit()
        self.filter.setPlaceholderText("Filter ...")
        self.filter.textChanged.connect(self.filter_changed)
        self.layout().addWidget(self.filter)
        # Remove focus from line edit
        self.setFocus(Qt.ActiveWindowFocusReason)

        self.rank_model = QStandardItemModel(self)
        self.model_proxy = QSortFilterProxyModel(
            self, filterCaseSensitivity=False)
        self.model_proxy.setSourceModel(self.rank_model)
        self.rank_table = view = QTableView(
            selectionBehavior=QTableView.SelectRows,
            selectionMode=QTableView.SingleSelection,
            showGrid=False,
            editTriggers=gui.TableView.NoEditTriggers)
        if self._has_bars:
            view.setItemDelegate(TableBarItem())
        else:
            view.setItemDelegate(HorizontalGridDelegate())
        view.setModel(self.model_proxy)
        view.selectionModel().selectionChanged.connect(
            self.on_selection_changed)
        view.horizontalHeader().setStretchLastSection(True)
        view.horizontalHeader().hide()
        self.layout().addWidget(view)

        self.button = gui.button(
            self, self, "Start", callback=self.toggle, default=True)

 def __init__(self, parent=None):
     QDialog.__init__(self, parent)
     self.setupUi(self)
     self.hotkey_screen.setText(settings['hotkey/screenshot'])
     self.hotkey_clip.setText(settings['hotkey/clipboard'])
     self.autostart.setChecked(self.is_autostart_enabled())
     self.buttons.clicked.connect(self.save_or_close)
     if os.name == 'nt':
         # Windows hijacks PrintScreen button for it's screenshotting functionality therefore hotkey widget can not
         # capture this key. We must bind it manually.
         self.printscreen.setChecked(self.hotkey_screen.text() == 'Print')
         self.hotkey_screen.setEnabled(not self.printscreen.isChecked())
         self.printscreen.toggled.connect(self._windows_print_screen)
         self.clear_hotkey_screen.pressed.connect(lambda: self.printscreen.setChecked(False))
     else:
         self.printscreen.setVisible(False)
     self.qt_version.setText('{} ({})'.format(QT_VERSION_STR, AnyQt.USED_API))
     self.resize(self.width(), 0)

    def __init__(self, master, model):
        QDialog.__init__(self)

        self.master = master

        self.setWindowFlags(Qt.Tool)
        self.setLayout(QVBoxLayout())
        self.setWindowTitle("Hidden Axes")

        btns_area = gui.widgetBox(
            self, addSpace=0, spacing=9, orientation=Qt.Horizontal,
            sizePolicy=QSizePolicy(*SIZE_POLICY_FIXED)
        )
        self.btn_add = QPushButton(
            "Add", autoDefault=False, sizePolicy=QSizePolicy(*SIZE_POLICY_FIXED)
        )
        self.btn_add.clicked.connect(self._add)
        self.btn_cancel = QPushButton(
            "Cancel", autoDefault=False, sizePolicy=QSizePolicy(*SIZE_POLICY_FIXED)
        )
        self.btn_cancel.clicked.connect(self._cancel)

        btns_area.layout().addWidget(self.btn_add)
        btns_area.layout().addWidget(self.btn_cancel)

        filter_edit, view = variables_filter(model=model)
        self.view_other = view
        view.setMinimumSize(QSize(30, 60))
        view.setSizePolicy(*SIZE_POLICY_ADAPTING)
        view.viewport().setAcceptDrops(True)

        self.layout().addWidget(filter_edit)
        self.layout().addWidget(view)
        self.layout().addWidget(btns_area)

        master = self.master
        box = master.box
        master.master.setEnabled(False)
        self.move(box.mapToGlobal(QPoint(0, box.pos().y() + box.height())))
        self.setFixedWidth(master.master.controlArea.width())
        self.setMinimumHeight(300)
        self.show()
        self.raise_()
        self.activateWindow()

    def showEvent(self, event):
        """Overloaded to restore the geometry when the widget is shown
        """
        QDialog.showEvent(self, event)
        if self.save_position and not self.__was_restored:
            # Restore saved geometry on (first) show
            if self.__splitter is not None:
                self.__setControlAreaVisible(self.controlAreaVisible)
            if self.savedWidgetGeometry is not None:
                self.__restoreWidgetGeometry(bytes(self.savedWidgetGeometry))
            self.__was_restored = True

        if not self.__was_shown:
            # Mark as explicitly moved/resized if not already. QDialog would
            # otherwise adjust position/size on subsequent hide/show
            # (move/resize events coming from the window manager do not set
            # these flags).
            self.setAttribute(Qt.WA_Moved, True)
            self.setAttribute(Qt.WA_Resized, True)
            self.__was_shown = True
        self.__quicktipOnce()

    def __init__(self, parent, windowTitle='Date picker'):
        super().__init__(parent, windowTitle=windowTitle)

        self.parent = parent

        self.setLayout(QVBoxLayout())
        self.mainArea = gui.widgetBox(self)
        self.layout().addWidget(self.mainArea)

        self.cal = QCalendarWidget(self)
        self.cal.setGridVisible(True)
        self.cal.move(20, 20)
        self.cal.clicked[QDate].connect(self.set_date)
        self.mainArea.layout().addWidget(self.cal)

        # Set the default date.
        self.picked_date = self.cal.selectedDate().toString('yyyy/MM/dd')

        gui.button(self.mainArea, self, 'OK', lambda: QDialog.accept(self))

 def acceptChanges(self):
     state = self.getCurrentState()
     oldState = self.colorSchemas[self.selectedSchemaIndex][1]
     if state == oldState:
         QDialog.accept(self)
     else:
         # if we change the default schema, we must save it under a new name
         if self.colorSchemas[self.selectedSchemaIndex][0] == "Default":
             if QMessageBox.information(
                     self, 'Question',
                     'The color schema has changed. Save?',
                     QMessageBox.Yes | QMessageBox.Discard) == QMessageBox.Discard:
                 QDialog.reject(self)
             else:
                 self.selectedSchemaIndex = self.schemaCombo.count() - 1
                 self.schemaCombo.setCurrentIndex(self.selectedSchemaIndex)
                 self.paletteSelected()
                 QDialog.accept(self)
         # simply save the new users schema
         else:
             self.colorSchemas[self.selectedSchemaIndex] = \
                 [self.colorSchemas[self.selectedSchemaIndex][0], state]
             QDialog.accept(self)

    def __init__(self, *args, **kwargs):
        QDialog.__init__(self, *args, **kwargs)
        self.scheme = None
        self.__autoCommit = True

        self.__setupUi()