Python QComboBox.setEditable方法代码示例

# 需要导入模块: from qtpy.QtWidgets import QComboBox [as 别名]
# 或者: from qtpy.QtWidgets.QComboBox import setEditable [as 别名]
 def _create_settings_widgets(self, settings):
     """
     Create a widget for a settings instance, containing label/editor pairs
     for each setting in the current level of the passed QSettings instance.
     The key of the setting is used as the label, but it's capitalized and
     underscores are replaced by spaces.
     """
     wrap = QWidget(self)
     form = QFormLayout()
     hint_lookup = Settings()
     for k in settings.allKeys():
         if k.startswith("_"):
             continue                                # Ignore hidden keys
         v = settings.value(k)                       # Read value
         label = k.capitalize().replace('_', ' ')
         abs_key = settings.group() + '/' + k
         self._initial_values[abs_key] = v           # Store initial value
         hints = hint_lookup.get_enum_hint(abs_key)  # Check for enum hints
         # Create a fitting editor widget based on value type:
         if hints is not None:
             w = QComboBox()
             w.addItems(hints)
             w.setEditable(True)
             w.setEditText(v)
             w.editTextChanged.connect(partial(self._on_setting_changed,
                                               abs_key, w))
         elif isinstance(v, str):
             if v.lower() in ('true', 'false'):
                 w = QCheckBox()
                 w.setChecked(v.lower() == 'true')
                 w.toggled.connect(partial(self._on_setting_changed,
                                           abs_key, w))
             else:
                 w = QLineEdit(v)
                 w.textChanged.connect(partial(self._on_setting_changed,
                                               abs_key, w))
         elif isinstance(v, int):
             w = QSpinBox()
             w.setRange(np.iinfo(np.int32).min, np.iinfo(np.int32).max)
             w.setValue(v)
             w.valueChanged.connect(partial(self._on_setting_changed,
                                            abs_key, w))
         elif isinstance(v, float):
             w = QDoubleSpinBox()
             w.setRange(np.finfo(np.float32).min, np.finfo(np.float32).max)
             w.setValue(v)
             w.valueChanged.connect(partial(self._on_setting_changed,
                                            abs_key, w))
         else:
             w = QLineEdit(str(v))
             w.textChanged.connect(partial(self._on_setting_changed,
                                           abs_key, w))
         self._lut[abs_key] = w
         form.addRow(label, w)
     wrap.setLayout(form)
     return wrap

# 需要导入模块: from qtpy.QtWidgets import QComboBox [as 别名]
# 或者: from qtpy.QtWidgets.QComboBox import setEditable [as 别名]
 def _make_search_box(self):
     """
     Make a algorithm search box.
     :return: A QComboBox
     """
     search_box = QComboBox(self)
     search_box.setEditable(True)
     search_box.completer().setCompletionMode(QCompleter.PopupCompletion)
     search_box.setInsertPolicy(QComboBox.NoInsert)
     search_box.editTextChanged.connect(self._on_search_box_selection_changed)
     search_box.lineEdit().returnPressed.connect(self.execute_algorithm)
     return search_box

# 需要导入模块: from qtpy.QtWidgets import QComboBox [as 别名]
# 或者: from qtpy.QtWidgets.QComboBox import setEditable [as 别名]
 def _make_search_box(self):
     """
     Make an algorithm search box.
     :return: A QComboBox
     """
     search_box = QComboBox(self)
     search_box.setEditable(True)
     search_box.completer().setCompletionMode(QCompleter.PopupCompletion)
     # setFilterMode behaviour changing is only available on Qt5, if this check is not present the Qt4 tests fail
     if qtpy.PYQT5:
         search_box.completer().setFilterMode(Qt.MatchContains)
     search_box.setInsertPolicy(QComboBox.NoInsert)
     search_box.editTextChanged.connect(self._on_search_box_selection_changed)
     search_box.lineEdit().returnPressed.connect(self.execute_algorithm)
     return search_box

# 需要导入模块: from qtpy.QtWidgets import QComboBox [as 别名]
# 或者: from qtpy.QtWidgets.QComboBox import setEditable [as 别名]
class LayoutSaveDialog(QDialog):
    """ """
    def __init__(self, parent, order):
        super(LayoutSaveDialog, self).__init__(parent)

        # variables
        self._parent = parent

        # widgets
        self.combo_box = QComboBox(self)
        self.combo_box.addItems(order)
        self.combo_box.setEditable(True)
        self.combo_box.clearEditText()
        self.button_box = QDialogButtonBox(QDialogButtonBox.Ok |
                                           QDialogButtonBox.Cancel,
                                           Qt.Horizontal, self)
        self.button_ok = self.button_box.button(QDialogButtonBox.Ok)
        self.button_cancel = self.button_box.button(QDialogButtonBox.Cancel)

        # widget setup
        self.button_ok.setEnabled(False)
        self.dialog_size = QSize(300, 100)
        self.setWindowTitle('Save layout as')
        self.setModal(True)
        self.setMinimumSize(self.dialog_size)
        self.setFixedSize(self.dialog_size)

        # layouts
        self.layout = QVBoxLayout()
        self.layout.addWidget(self.combo_box)
        self.layout.addWidget(self.button_box)
        self.setLayout(self.layout)

        # signals and slots
        self.button_box.accepted.connect(self.accept)
        self.button_box.rejected.connect(self.close)
        self.combo_box.editTextChanged.connect(self.check_text)

    def check_text(self, text):
        """Disable empty layout name possibility"""
        if to_text_string(text) == u'':
            self.button_ok.setEnabled(False)
        else:
            self.button_ok.setEnabled(True)

# 需要导入模块: from qtpy.QtWidgets import QComboBox [as 别名]
# 或者: from qtpy.QtWidgets.QComboBox import setEditable [as 别名]
class FontLayout(QGridLayout):
    """Font selection"""
    def __init__(self, value, parent=None):
        QGridLayout.__init__(self)
        font = tuple_to_qfont(value)
        assert font is not None
        
        # Font family
        self.family = QFontComboBox(parent)
        self.family.setCurrentFont(font)
        self.addWidget(self.family, 0, 0, 1, -1)
        
        # Font size
        self.size = QComboBox(parent)
        self.size.setEditable(True)
        sizelist = list(range(6, 12)) + list(range(12, 30, 2)) + [36, 48, 72]
        size = font.pointSize()
        if size not in sizelist:
            sizelist.append(size)
            sizelist.sort()
        self.size.addItems([str(s) for s in sizelist])
        self.size.setCurrentIndex(sizelist.index(size))
        self.addWidget(self.size, 1, 0)
        
        # Italic or not
        self.italic = QCheckBox(_("Italic"), parent)
        self.italic.setChecked(font.italic())
        self.addWidget(self.italic, 1, 1)
        
        # Bold or not
        self.bold = QCheckBox(_("Bold"), parent)
        self.bold.setChecked(font.bold())
        self.addWidget(self.bold, 1, 2)
        
    def get_font(self):
        font = self.family.currentFont()
        font.setItalic(self.italic.isChecked())
        font.setBold(self.bold.isChecked())
        font.setPointSize(int(self.size.currentText()))
        return qfont_to_tuple(font)

# 需要导入模块: from qtpy.QtWidgets import QComboBox [as 别名]
# 或者: from qtpy.QtWidgets.QComboBox import setEditable [as 别名]
    def add_row(self, row=-1):
        """this add a default row to the table that takes care
        of the rules"""
        _random_key = generate_random_key()

        _list_ui_for_this_row = {}
        _list_ui_to_unlock = []

        self.table_ui.insertRow(row)
        self.table_ui.setRowHeight(row, self.row_height)

        # key
        _item = QTableWidgetItem("{}".format(_random_key))
        self.table_ui.setItem(row, 0, _item)

        # rule #
        _rule_name = self.define_unique_rule_name(row)
        _item = QTableWidgetItem("{}".format(_rule_name))
        _item.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
        self.table_ui.setItem(row, 1, _item)

        # search argument
        _widget = QComboBox()
        _list_ui_for_this_row['list_items'] = _widget
        list_items = LIST_SEARCH_CRITERIA[self.parent.parent.instrument['short_name'].lower()]
        _widget.addItems(list_items)
        self.table_ui.setCellWidget(row, 2, _widget)
        _widget.blockSignals(True)
        _list_ui_to_unlock.append(_widget)
        _widget.currentIndexChanged.connect(lambda value=list_items[0],
                                            key = _random_key:
                                            self.parent.list_item_changed(value, key))

        # criteria
        list_criteria = ['is', 'contains']
        _widget = QComboBox()
        _list_ui_for_this_row['list_criteria'] = _widget
        _widget.addItems(list_criteria)
        self.table_ui.setCellWidget(row, 3, _widget)
        _widget.blockSignals(True)
        _list_ui_to_unlock.append(_widget)
        _widget.currentIndexChanged.connect(lambda value=list_criteria[0],
                                            key = _random_key:
                                            self.parent.list_criteria_changed(value, key))

        # argument
        _widget = QComboBox()
        _widget.setEditable(True)
        _list_ui_for_this_row['list_items_value'] = _widget
        list_values = list(self.parent.metadata['Chemical Formula'])
        _widget.addItems(list_values)
        self.table_ui.setCellWidget(row, 4, _widget)
        _widget.blockSignals(True)
        _list_ui_to_unlock.append(_widget)
        _widget.editTextChanged.connect(lambda value=list_values[0],
                                        key = _random_key:
                                        self.parent.list_argument_changed(value, key))
        _widget.currentIndexChanged.connect(lambda value=list_values[0],
                                            key = _random_key:
                                            self.parent.list_argument_index_changed(value, key))

        if row == 0:
            self.table_ui.horizontalHeader().setVisible(True)

        unlock_signals_ui(list_ui=_list_ui_to_unlock)

        self.parent.list_ui[_random_key] = _list_ui_for_this_row
        self.parent.check_all_filter_widgets()