def populate_well_listWidget(self): survey_file = CONF.survey_dir / '.survey' if survey_file.exists(): for name in get_data_files(CONF.well_dir): new_item = QListWidgetItem(name, self.wells_listWidget) new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable) new_item.setCheckState(Qt.Unchecked)
def refreshAnnotations(self): for annotation in self.getAnnotations(): if annotation not in self.annotations: self.annotations.append(annotation) self.annotationsName.append('Annotation') i = 0 to_del = [] for annotation in self.annotations: if annotation not in self.getAnnotations(): to_del.append(i) i += 1 i = 0 for index in to_del: self.annotations.pop(index) self.annotationsName.pop(index) self.annotationList.clearSelection() self.annotationList.clear() # argh for annotation in self.annotations: item = QListWidgetItem(self.annotationsName[i]) if annotation.isVisible(): item.setCheckState(Qt.Checked) else: item.setCheckState(Qt.Unchecked) item.setFlags(item.flags() | Qt.ItemIsEditable) self.annotationList.addItem(item) i += 1
def load_data_list(self): folder_path = Path(CONF.data_root) / \ CONF.current_survey / "Seismics" for name in get_data_files(folder_path): new_item = QListWidgetItem(name, self.data_list_Widget) new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable) new_item.setCheckState(Qt.Unchecked)
def __init__(self, rawImageLayer, objectImageLayer, featureTableNames, imagePerObject=True, \ imagePerTime = True, parent=None): QDialog.__init__(self, parent) self.setWindowTitle("Export to Knime") ui_class, widget_class = uic.loadUiType( os.path.split(__file__)[0] + "/exportToKnimeDialog.ui") self.ui = ui_class() self.ui.setupUi(self) itemRaw = QListWidgetItem(rawImageLayer.name) self.ui.rawList.addItem(itemRaw) itemObjects = QListWidgetItem(objectImageLayer.name) self.ui.objectList.addItem(itemObjects) self.imagePerObject = imagePerObject self.imagePerTime = imagePerTime #FIXME: assume for now tht the feature table is a dict try: for plugin, feature_dict in featureTableNames.iteritems(): print plugin for feature_name in feature_dict.keys(): print "adding feature:", feature_name item = QListWidgetItem(feature_name) item.setFlags(item.flags() | Qt.ItemIsUserCheckable) item.setCheckState(Qt.Unchecked) self.ui.featureList.addItem(item) except: print "hahaha, doesn't work!"
def __init__(self, rawImageLayer, objectImageLayer, featureTableNames, imagePerObject=True, \ imagePerTime = True, parent=None): QDialog.__init__(self, parent) self.setWindowTitle("Export to Knime") ui_class, widget_class = uic.loadUiType(os.path.split(__file__)[0] + "/exportToKnimeDialog.ui") self.ui = ui_class() self.ui.setupUi(self) itemRaw = QListWidgetItem(rawImageLayer.name) self.ui.rawList.addItem(itemRaw) itemObjects = QListWidgetItem(objectImageLayer.name) self.ui.objectList.addItem(itemObjects) self.imagePerObject = imagePerObject self.imagePerTime = imagePerTime #FIXME: assume for now tht the feature table is a dict try: for plugin, feature_dict in featureTableNames.iteritems(): print plugin for feature_name in feature_dict.keys(): print "adding feature:", feature_name item = QListWidgetItem(feature_name) item.setFlags(item.flags() | Qt.ItemIsUserCheckable) item.setCheckState(Qt.Unchecked) self.ui.featureList.addItem(item) except: print "hahaha, doesn't work!"
def refreshPeers(self): self.ui.peerList.clear() for peer in self.communicator.peers: peer = self.communicator.peers[peer] peerName = QListWidgetItem(self.ui.peerList) peerName.peer = peer nameFont = QtGui.QFont() nameFont.setPointSize(14) peerDetails = QListWidgetItem(self.ui.peerList) peerDetails.peer = peer detailsFont = QtGui.QFont() detailsFont.setPointSize(10) name = peer.name details = "" if peer.publicKey is None: details += "Unpaired, " else: details += "Paired, " if peer.lastKnownIP is None: details += "unavailable" else: details += "available: " + peer.lastKnownIP peerName.setFont(nameFont) peerName.setText(name) peerDetails.setFont(detailsFont) peerDetails.setText(details) self.ui.peerList.addItem(peerName) self.ui.peerList.addItem(peerDetails) separatorItem = QListWidgetItem(self.ui.peerList) separatorItem.guid = peer.guid separatorItem.peer = None separatorItem.setFlags(QtCore.Qt.NoItemFlags) self.ui.peerList.addItem(separatorItem)
def writeModeData(self,data): item = QListWidgetItem() item.setText(data) item.setSizeHint(QSize(27,27)) item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsEditable | Qt.ItemIsSelectable) self.insertItem(self.count()+1,item) self.scrollToBottom()
def update(self, subject): action, key = subject if action == "add": movie = self._moviemodel.data()[-1] item = QListWidgetItem(movie.to_string()) item.setFlags(item.flags() | QtCore.Qt.ItemIsEditable) self.addItem(item) self.item_to_movie[item] = movie self.movie_to_item[movie] = item if action == "remove": item = self.movie_to_item[key] self.takeItem(self.row(item)) self.item_to_movie.pop(item) self.movie_to_item.pop(key) if action == "update": item = self.movie_to_item[key] item.setText(key.to_string()) if key.has_been_saved(): if key.has_changed(): key.set_saved(False) self.apply_item_style(key, item) if item in self.selectedItems(): self.emit(QtCore.SIGNAL("currentItemChanged(QListWidgetItem *,QListWidgetItem *)"), item, item) if action == "clear": item = self.movie_to_item[key] item.setText(key.get_title()) key.set_modified(False) key.set_saved(False) self.apply_item_style(key, item)
def initializePage(self): super(InterfacePage, self).initializePage() exsits = [] for key in app.g_configurations.interfaces: if app.g_configurations.interfaces[key]: exsits.append(key) for interface in app.g_configurations.config['interfaces']: litem = QListWidgetItem(interface['name']) litem.setToolTip(interface['description']) litem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled) if app.g_configurations.initialized: if interface['name'] in exsits: litem.setCheckState(Qt.Checked) else: litem.setCheckState(Qt.Unchecked) else: isdefault = False if app.g_configurations.component_type == "window": if interface['default'] & 2: isdefault = True else: if interface['default'] & 1: isdefault = True if isdefault: litem.setCheckState(Qt.Checked) else: litem.setCheckState(Qt.Unchecked) self.lw_interface.addItem(litem)
def populate_field_list(self, excluded_fields=None): """Helper to add field of the layer to the list. :param excluded_fields: List of field that want to be excluded. :type excluded_fields: list """ # Populate fields list if excluded_fields is None: excluded_fields = [] self.field_list.clear() for field in self.layer.dataProvider().fields(): # Skip if it's excluded if field.name() in excluded_fields: continue # Skip if it's not number (float, int, etc) if field.type() not in qvariant_numbers: continue field_item = QListWidgetItem(self.field_list) field_item.setFlags( Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsDragEnabled) field_item.setData(Qt.UserRole, field.name()) field_item.setText(field.name()) self.field_list.addItem(field_item)
def update(self, subject): action, key = subject if action == "add": movie = self._moviemodel.data()[-1] item = QListWidgetItem(movie.to_string()) item.setFlags(item.flags() | QtCore.Qt.ItemIsEditable) self.addItem(item) self.item_to_movie[item] = movie self.movie_to_item[movie] = item if action == "remove": item = self.movie_to_item[key] self.takeItem(self.row(item)) self.item_to_movie.pop(item) self.movie_to_item.pop(key) if action == "update": item = self.movie_to_item[key] item.setText(key.to_string()) if key.has_been_saved(): if key.has_changed(): key.set_saved(False) self.apply_item_style(key, item) if item in self.selectedItems(): self.emit(QtCore.SIGNAL(\ "currentItemChanged(QListWidgetItem *,QListWidgetItem *)"), item, item) if action == "clear": item = self.movie_to_item[key] item.setText(key.get_title()) key.set_modified(False) key.set_saved(False) self.apply_item_style(key, item)
def __init__(self, mainwin, pdfs): KDialog.__init__(self, mainwin) self.mainwin = mainwin self.setAttribute(Qt.WA_DeleteOnClose) self.setButtons(KDialog.ButtonCode( KDialog.User1 | KDialog.Ok | KDialog.Cancel)) self.setButtonGuiItem(KDialog.Ok, KStandardGuiItem.print_()) self.setButtonIcon(KDialog.User1, KIcon("edit-select-all")) self.setButtonText(KDialog.User1, i18n("Select all")) self.setCaption(i18n("Print documents")) b = KVBox(self) b.setSpacing(4) QLabel(i18n("Please select the files you want to print:"), b) fileList = QListWidget(b) fileList.setIconSize(QSize(22, 22)) fileList.setWhatsThis(i18n( "These are the PDF documents that are up-to-date (i.e. newer than " "the LilyPond source document). " "Check the documents you want to send to the printer.")) for pdf in pdfs: i = QListWidgetItem(KIcon("application-pdf"), os.path.basename(pdf), fileList) i.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsUserCheckable) i.setCheckState(Qt.Unchecked) fileList.item(0).setCheckState(Qt.Checked) self.fileList = fileList self.setMainWidget(b) self.resize(350, 200) self.pdfs = pdfs self.user1Clicked.connect(self.selectAll)
def set_widgets(self): """Set widgets on the Field tab.""" self.clear_further_steps() purpose = self.parent.step_kw_purpose.selected_purpose() subcategory = self.parent.step_kw_subcategory.selected_subcategory() unit = self.parent.step_kw_unit.selected_unit() if purpose == layer_purpose_aggregation: question_text = field_question_aggregation elif self.parent.step_kw_layermode.\ selected_layermode() == layer_mode_continuous and unit: subcategory_unit_relation = get_question_text( '%s_%s_question' % (subcategory['key'], unit['key'])) if 'MISSING' in subcategory_unit_relation: subcategory_unit_relation = self.tr( '{subcategory} in {unit} unit').format( subcategory=subcategory['name'].lower(), unit=unit['plural_name']) question_text = field_question_subcategory_unit % ( purpose['name'], subcategory['name'], unit['name'], subcategory_unit_relation) else: question_text = field_question_subcategory_classified % ( subcategory['name']) self.lblSelectField.setText(question_text) self.lstFields.clear() default_item = None for field in self.parent.layer.dataProvider().fields(): field_name = field.name() item = QListWidgetItem(field_name, self.lstFields) item.setData(QtCore.Qt.UserRole, field_name) # Select the item if it match the unit's default_attribute if unit and 'default_attribute' in unit \ and field_name == unit['default_attribute']: default_item = item # For continuous data, gray out id, gid, fid and text fields if self.parent.step_kw_layermode.\ selected_layermode() == layer_mode_continuous and unit: field_type = field.type() if field_type > 9 or re.match( '.{0,2}id$', field_name, re.I): item.setFlags(item.flags() & ~QtCore.Qt.ItemIsEnabled) if default_item: self.lstFields.setCurrentItem(default_item) self.lblDescribeField.clear() # Set values based on existing keywords (if already assigned) field_keyword = self.parent.field_keyword_for_the_layer() inasafe_field = self.parent.get_existing_keyword('inasafe_fields') if inasafe_field: field = inasafe_field.get(field_keyword) if field: fields = [] for index in xrange(self.lstFields.count()): fields.append(str(self.lstFields.item(index).text())) if field in fields: self.lstFields.setCurrentRow(fields.index(field)) self.auto_select_one_item(self.lstFields)
def load_data_list(self): for name in get_data_files( Path(CONF.data_root, CONF.current_survey, "Seismics")): # only initialize this way can it be set checkable new_item = QListWidgetItem(name, self.control_widget.data_listWidget) new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable) new_item.setCheckState(Qt.Unchecked)
def reload_key_list(self): while self.key_list.count() > 0: self.key_list.takeItem(0) for key in sorted(self._keys.keys()): item = QListWidgetItem(unicode(key)) item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsEditable) item.setData(Qt.UserRole, unicode(key)) self.key_list.addItem(item)
def update_well_listWidget(self): survey_file = CONF.survey_dir / '.survey' if survey_file.exists(): dnames = get_data_files(CONF.well_dir) # self.well_listWidget.addItems(dnames) for name in dnames: new_item = QListWidgetItem(name, self.well_listWidget) new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable) new_item.setCheckState(Qt.Unchecked)
def provide(self, search): if search.startswith('define ') and search != 'define ': item = QListWidgetItem( subprocess.check_output('dict {}; exit 0'.format(search[7:]), stderr=subprocess.STDOUT, shell=True)) item.setFlags(item.flags() & ~Qt.ItemIsSelectable) yield item yield True yield False
def update_list(self): """Update path list""" self.listwidget.clear() for name in self.pathlist + self.ro_pathlist: item = QListWidgetItem(name) item.setIcon(get_std_icon('DirClosedIcon')) if name in self.ro_pathlist: item.setFlags(Qt.NoItemFlags) self.listwidget.addItem(item) self.refresh()
def getNewCompo(self, w, cView): """Function that finds new composer to be added to the list.""" nameCompo = cView.composerWindow().windowTitle() if not w.findItems(nameCompo, Qt.MatchExactly): item = QListWidgetItem() item.setFlags(item.flags() | Qt.ItemIsUserCheckable) item.setCheckState(Qt.Unchecked) item.setText(nameCompo) w.addItem(item)
def populate_log_listWidget(self): self.logs_listWidget.clear() well = ppp.Well( str(CONF.well_dir / ".{}".format(self.well_comboBox.currentText()))) # self.logs_listWidget.addItems(well.logs) for name in well.logs: new_item = QListWidgetItem(name, self.logs_listWidget) new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable) new_item.setCheckState(Qt.Unchecked)
def item(icon, fileName): """ Add item to the fileList list widget. """ directory, name = os.path.split(fileName) if directory != basedir: name += " ({0})".format(os.path.normpath(directory)) i = QListWidgetItem(KIcon(icon), name, fileList) i.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsUserCheckable) i.ext = os.path.splitext(fileName)[1] i.url = KUrl.fromPath(fileName).url() i.setCheckState(Qt.Checked if i.ext in exts else Qt.Unchecked)
def update_list(self): """Update path list""" self.listwidget.clear() for name in self.pathlist+self.ro_pathlist: item = QListWidgetItem(name) item.setIcon(get_std_icon('DirClosedIcon')) if name in self.ro_pathlist: item.setFlags(Qt.NoItemFlags) self.listwidget.addItem(item) self.refresh()
def handleItemChecked(self): well_names = [] for idx in range(self.well_listWidget.count()): item = self.well_listWidget.item(idx) if item.checkState() == Qt.Checked: well_names.append(item.text()) # first well if well_names: vlog_list = [] obp_log_list = [] nct_list = [] n_list = [] first_well = ppp.Well(str(CONF.well_dir / ".{}".format(well_names[0]))) for log in first_well.logs: if "Velocity" in log: vlog_list.append(log) if "Overburden" in log: obp_log_list.append(log) # for key in first_well.params.keys(): # if "nct" in key: # nct_list.append(key) # if "eaton" in key: # n_list.append(key) pres_list = ["DST", "MDT", "EMW", "loading", "unloading", "MP"] for w_name in well_names: well = ppp.Well(str(CONF.well_dir / ".{}".format(w_name))) for log in vlog_list: if log not in well.logs: vlog_list.remove(log) for log in obp_log_list: if log not in well.logs: obp_log_list.remove(log) key_to_remove = [] for key in pres_list: if key not in well.params.keys(): key_to_remove.append(key) for key in key_to_remove: pres_list.remove(key) self.velocity_comboBox.clear() self.velocity_comboBox.addItems(vlog_list) self.obp_comboBox.clear() self.obp_comboBox.addItems(obp_log_list) # self.nct_comboBox.clear() # self.nct_comboBox.addItems(nct_list) # self.n_comboBox.clear() # self.n_comboBox.addItems(n_list) self.pres_listWidget.clear() for name in pres_list: new_item = QListWidgetItem(name, self.pres_listWidget) new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable) new_item.setCheckState(Qt.Unchecked) else: self.pres_listWidget.clear()
def refresh_list(self): self._input.clear() if not self._parameter.ordering == InputListParameter.NotOrdered: self._value_cache.sort() if self._parameter.ordering == InputListParameter.DescendingOrder: self._value_cache.reverse() for opt in self._value_cache: item = QListWidgetItem() item.setText(str(opt)) item.setFlags(item.flags() | Qt.ItemIsEditable) self._input.addItem(item)
def on_pf_add_start_byte_clicked(self): (text, ok) = QInputDialog.getText(\ self, self.trUtf8("Start byte"), self.trUtf8("Insert start byte in hex form:"), QLineEdit.Normal, self.trUtf8("0x00")) if ok and text: # TODO: check hex form with regexp item = QListWidgetItem(str(text)) item.setFlags(item.flags() | Qt.ItemIsEditable) self.pf_start_bytes.addItem(item)
def on_domainListWidget_currentRowChanged(self, idx): curItem = self.domainListWidget.item(idx) self.filterListWidget.clear() if curItem: self.domainName = curItem.data(0) self.domainDict = self.abstractDb.getDomainDictV2('dominios.'+self.domainName) for codeName in self.domainDict.keys(): newItem = QListWidgetItem(codeName) newItem.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsTristate | QtCore.Qt.ItemIsUserCheckable) newItem.setCheckState(QtCore.Qt.Unchecked) self.filterListWidget.addItem(newItem)
def _load_labels(self): self.LabelsListWidget.clear() if self.selected_provider: labels = self.selected_provider.get_labels() for label in labels: icon = utils.colored_icon(label['color']) item = QListWidgetItem(icon, label['name'], self.LabelsListWidget) item.setFlags(item.flags() | Qt.ItemIsUserCheckable) item.setCheckState(Qt.Unchecked) self.LabelsListWidget.addItem(item) self.LabelsListWidget.sortItems()
def insertCheckableItem(self, index, label, state, isBonus=False): """ Fügt einen Eintrag an der angegebenen Indexposition ein. """ item = QListWidgetItem() item.setText(label) item.setCheckState(state) if isBonus: item.setData(Qt.ForegroundRole, QColor(Config.COLOR_BONUS)) item.setFlags(item.flags() & Qt.ItemIsUserCheckable) self.insertItem(index, item)
def __init__(self, parameter, parent=None): """Constructor .. versionadded:: 2.2 :param parameter: A ListParameter object. :type parameter: ListParameter """ super(ListParameterWidget, self).__init__(parameter, parent) self._input = QListWidget() self._input.setSelectionMode(QAbstractItemView.MultiSelection) if self._parameter.maximum_item_count != \ self._parameter.minimum_item_count: tool_tip = 'Select between %d and %d items' % ( self._parameter.minimum_item_count, self._parameter.maximum_item_count) else: tool_tip = 'Select exactly %d items' % ( self._parameter.maximum_item_count) self._input.setToolTip(tool_tip) for opt in self._parameter.options_list: item = QListWidgetItem() item.setFlags(item.flags() | Qt.ItemIsEditable) item.setText(str(opt)) self._input.addItem(item) if opt in self._parameter.value: item.setSelected(True) self.inner_input_layout.addWidget(self._input) # override self._input_layout arrangement to make the label at the top # reset the layout self.input_layout.setParent(None) self.help_layout.setParent(None) self.label.setParent(None) self.inner_input_layout.setParent(None) self.input_layout = QVBoxLayout() self.input_layout.setSpacing(0) # put element into layout self.input_layout.addWidget(self.label) self.input_layout.addLayout(self.inner_input_layout) self.main_layout.addLayout(self.input_layout) self.main_layout.addLayout(self.help_layout)
def populate_classified_values(self, unassigned_values, assigned_values, default_classes): """Populate lstUniqueValues and treeClasses.from the parameters. :param unassigned_values: List of values that haven't been assigned to a class. It will be put in self.lstUniqueValues. :type unassigned_values: list :param assigned_values: Dictionary with class as the key and list of value as the value of the dictionary. It will be put in self.treeClasses. :type assigned_values: dict :param default_classes: Default classes from unit. :type default_classes: list """ # Populate the unique values list self.lstUniqueValues.clear() self.lstUniqueValues.setSelectionMode( QAbstractItemView.ExtendedSelection) for value in unassigned_values: value_as_string = value is not None and unicode(value) or 'NULL' list_item = QListWidgetItem(self.lstUniqueValues) list_item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsDragEnabled) list_item.setData(Qt.UserRole, value) list_item.setText(value_as_string) self.lstUniqueValues.addItem(list_item) # Populate assigned values tree self.treeClasses.clear() self.treeClasses.invisibleRootItem().setFlags(Qt.ItemIsEnabled) for default_class in default_classes: # Create branch for class tree_branch = QTreeWidgetItem(self.treeClasses) tree_branch.setFlags(Qt.ItemIsDropEnabled | Qt.ItemIsEnabled) tree_branch.setExpanded(True) tree_branch.setFont(0, bold_font) if 'name' in default_class: default_class_name = default_class['name'] else: default_class_name = default_class['key'] tree_branch.setText(0, default_class_name) tree_branch.setData(0, Qt.UserRole, default_class['key']) if 'description' in default_class: tree_branch.setToolTip(0, default_class['description']) # Assign known values for value in assigned_values[default_class['key']]: string_value = value is not None and unicode(value) or 'NULL' tree_leaf = QTreeWidgetItem(tree_branch) tree_leaf.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsDragEnabled) tree_leaf.setData(0, Qt.UserRole, value) tree_leaf.setText(0, string_value)
def __init__(self, parameter, parent=None): """Constructor .. versionadded:: 2.2 :param parameter: A ListParameter object. :type parameter: ListParameter """ super(ListParameterWidget, self).__init__(parameter, parent) self._input = QListWidget() self._input.setSelectionMode(QAbstractItemView.MultiSelection) if self._parameter.maximum_item_count != \ self._parameter.minimum_item_count: tool_tip = 'Select between %d and %d items' % ( self._parameter.minimum_item_count, self._parameter.maximum_item_count) else: tool_tip = 'Select exactly %d items' % ( self._parameter.maximum_item_count) self._input.setToolTip(tool_tip) for opt in self._parameter.options_list: item = QListWidgetItem() item.setFlags(item.flags() | Qt.ItemIsEditable) item.setText(str(opt)) self._input.addItem(item) if opt in self._parameter.value: item.setSelected(True) self._inner_input_layout.addWidget(self._input) # override self._input_layout arrangement to make the label at the top # reset the layout self._input_layout.setParent(None) self._help_layout.setParent(None) self._label.setParent(None) self._inner_input_layout.setParent(None) self._input_layout = QVBoxLayout() self._input_layout.setSpacing(0) # put element into layout self._input_layout.addWidget(self._label) self._input_layout.addLayout(self._inner_input_layout) self._main_layout.addLayout(self._input_layout) self._main_layout.addLayout(self._help_layout)
def set_widgets(self): """Set widgets on the Field tab.""" self.clear_further_steps() purpose = self.parent.step_kw_purpose.selected_purpose() subcategory = self.parent.step_kw_subcategory.selected_subcategory() unit = self.parent.step_kw_unit.selected_unit() if purpose == layer_purpose_aggregation: question_text = field_question_aggregation elif self.parent.step_kw_layermode.\ selected_layermode() == layer_mode_continuous and unit: # unique values, continuous or categorical data subcategory_unit_relation = get_question_text( '%s_%s_question' % (subcategory['key'], unit['key'])) question_text = field_question_subcategory_unit % ( purpose['name'], subcategory['name'], unit['name'], subcategory_unit_relation) else: question_text = field_question_subcategory_classified % ( subcategory['name']) self.lblSelectField.setText(question_text) self.lstFields.clear() default_item = None for field in self.parent.layer.dataProvider().fields(): field_name = field.name() item = QListWidgetItem(field_name, self.lstFields) item.setData(QtCore.Qt.UserRole, field_name) # Select the item if it match the unit's default_attribute if unit and 'default_attribute' in unit \ and field_name == unit['default_attribute']: default_item = item # For continuous data, gray out id, gid, fid and text fields if self.parent.step_kw_layermode.\ selected_layermode() == layer_mode_continuous and unit: field_type = field.type() if field_type > 9 or re.match( '.{0,2}id$', field_name, re.I): item.setFlags(item.flags() & ~QtCore.Qt.ItemIsEnabled) if default_item: self.lstFields.setCurrentItem(default_item) self.lblDescribeField.clear() # Set values based on existing keywords (if already assigned) field_keyword = self.parent.field_keyword_for_the_layer() field = self.parent.get_existing_keyword(field_keyword) if field: fields = [] for index in xrange(self.lstFields.count()): fields.append(str(self.lstFields.item(index).text())) if field in fields: self.lstFields.setCurrentRow(fields.index(field)) self.auto_select_one_item(self.lstFields)
def update_horizon_listWidget(self): self.horizon_listWidget.clear() well_name = self.well_comboBox.currentText() well = ppp.Well(str(CONF.well_dir / ".{}".format(well_name))) try: horizons = well.params['horizon'].keys() for name in horizons: new_item = QListWidgetItem(name, self.horizon_listWidget) new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable) new_item.setCheckState(Qt.Unchecked) except KeyError as e: print(e.message)
def showAttr(self): self.dlg.attributeList.clear() current = self.dlg.fileListWidget.currentItem() attributes = current.attributes for attr in attributes: item = QListWidgetItem(attr[0], self.dlg.attributeList) item.setFlags(item.flags() & ~Qt.ItemIsSelectable) if attr[1] == 0: item.setCheckState(Qt.Unchecked) else: item.setCheckState(Qt.Checked) self.dlg.attributeList.addItem(item)
def addEntry(self): item = QListWidgetItem(tr("New category")) item.setFlags(Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsSelectable) self.window.categories_list.addItem(item) name = "" i = 0 while name == "" or name in self.categories_order: name = "category%i" % i i += 1 self.categories_order.append(name) self.categories[name] = tr("New category")
def moveDown(self): item = self.window.categories_list.currentItem() row = self.window.categories_list.currentRow() name = self.categories_order[row] if row < len(self.categories_order) - 1: self.window.categories_list.model().removeRow(row) item = QListWidgetItem(self.categories[name]) item.setFlags(Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsSelectable) self.window.categories_list.insertItem(row + 1, item) self.categories_order.remove(name) self.categories_order.insert(row + 1, name) self.window.categories_list.setCurrentRow(row + 1)
def add_page(self, widget): self.connect(self, SIGNAL('check_settings()'), widget.check_settings) self.connect(widget, SIGNAL('show_this_page()'), lambda row=self.contents_widget.count(): self.contents_widget.setCurrentRow(row)) self.connect(widget, SIGNAL("apply_button_enabled(bool)"), self.apply_btn.setEnabled) self.pages_widget.addWidget(widget) item = QListWidgetItem(self.contents_widget) item.setIcon(widget.get_icon()) item.setText(widget.get_name()) item.setFlags(Qt.ItemIsSelectable|Qt.ItemIsEnabled) item.setSizeHint(QSize(0, 25))
def create_plugin_view(self, showAll = True): for p_name, p_info in self.p_info.iteritems(): item = QListWidgetItem(p_info["name"], self.ui.pluginView) item.setToolTip(p_name) item.setCheckState(Qt.Checked if p_info["activated"] else Qt.Unchecked) if p_info["forced"]: item.setForeground(Qt.gray) flags = item.flags() flags &= ~Qt.ItemIsUserCheckable item.setFlags(flags) item.setHidden(not showAll and p_info["forced"]) self.ui.pluginView.addItem(item)
def add_page(self, widget): self.connect(self, SIGNAL('check_settings()'), widget.check_settings) self.connect(widget, SIGNAL('show_this_page()'), lambda row=self.contents_widget.count(): self. contents_widget.setCurrentRow(row)) self.connect(widget, SIGNAL("apply_button_enabled(bool)"), self.apply_btn.setEnabled) self.pages_widget.addWidget(widget) item = QListWidgetItem(self.contents_widget) item.setIcon(widget.get_icon()) item.setText(widget.get_name()) item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) item.setSizeHint(QSize(0, 25))
def initList(self): self.notebookList.clear() notebooks = Mikibook.read() for nb in notebooks: item = QListWidgetItem() item.setData(Qt.DisplayRole, nb[0]) item.setData(Qt.UserRole, nb[1]) lockPath = os.path.join(nb[1], '.mikidown_lock') if os.path.exists(lockPath): item.setFlags(Qt.NoItemFlags) self.notebookList.addItem(item) self.updateUi(len(notebooks) != 0) self.notebookList.setCurrentRow(0)
def updateOrder(self): self.listbox.clear() self.macros = self.loadMacros() cparser = PuddleConfig() to_check = cparser.get('actions', 'checked', []) for i, m in sorted(self.macros.items()): func_name = m.name item = QListWidgetItem(func_name) item.setFlags(item.flags() | Qt.ItemIsEditable) if func_name in to_check: item.setCheckState(Qt.Checked) else: item.setCheckState(Qt.Unchecked) self.listbox.addItem(item)
def add_item(self, text, edit_item=False, select_item=False): item = QListWidgetItem(text) item.setFlags(item.flags() | Qt.ItemIsEditable) self.list_items.addItem(item) if edit_item: self.list_items.setCurrentItem(item) self.list_items.setFocus() self.list_items.editItem(item) elif select_item: self.list_items.setCurrentItem(item) self.list_items.setFocus() self.update_ui_state()
def __init__(self, name = None, attributes = [], selectedAttributes = []): QListWidget.__init__(self) self.menu = AttributeSelectorMenu(self) self.setSelectionMode(QAbstractItemView.ExtendedSelection) if name: self.name = name self.attributes = attributes for attribute in self.attributes: item = QListWidgetItem(attribute) item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsUserCheckable | Qt.ItemIsEnabled) if attribute in selectedAttributes: item.setCheckState(Qt.Checked) else: item.setCheckState(Qt.Unchecked) self.addItem(item)
def createIcons(self): vectorButton = QListWidgetItem(self.contentsWidget) vectorButton.setIcon(QIcon(":custom-vector.svg")) vectorButton.setText("Vector Layer") vectorButton.setTextAlignment(Qt.AlignHCenter) vectorButton.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) rasterButton = QListWidgetItem(self.contentsWidget) rasterButton.setIcon(QIcon(":custom-raster.svg")) rasterButton.setText("Raster Layer") rasterButton.setTextAlignment(Qt.AlignHCenter) rasterButton.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) self.connect(self.contentsWidget, SIGNAL("currentItemChanged(QListWidgetItem*, QListWidgetItem*)"), self.changePage)
def addListItem(self, component, title, valid=True, checked=True): item = QListWidgetItem(title) item.component = component item.setFlags(item.flags() | Qt.ItemIsUserCheckable) if valid: pass else: item.setForeground(QColor('gray')) if checked: item.setCheckState(Qt.Checked) else: item.setCheckState(Qt.Unchecked) self.components_list.addItem(item)
def loadComposers(self): self.lstComposers.clear() self.composers = { c.composerWindow().windowTitle(): c for c in self.iface.activeComposers() } if len(self.composers) > 0: self.lstComposers.addItems(self.composers.keys()) self.lstComposers.sortItems() else: item = QListWidgetItem(self.tr("No composers found")) item.setFlags(item.flags() ^ Qt.ItemIsEnabled) self.lstComposers.addItem(item) self.toggleButtons()
def add_new_item(self, name, project, is_new=False, is_valid=True): item = QListWidgetItem(self.moduleList, QListWidgetItem.UserType) item.setData(QListWidgetItem.UserType, project) item.setSizeHint(QSize(150, 150)) if not is_valid: item.setFlags(item.flags() & ~Qt.ItemIsEnabled) projectwidget = ProjectWidget(self.moduleList, project, is_new=is_new) projectwidget.install_project.connect(self.projectInstall.emit) projectwidget.update_project.connect(self.projectUpdate.emit) projectwidget.setEnabled(is_valid) self.moduleList.addItem(item) self.moduleList.setItemWidget(item, projectwidget) self.projectitems[name] = item
def update_pres_listWidget(self): pres_list = ["DST", "MDT", "EMW", "loading", "unloading", "MP"] well_name = self.well_comboBox.currentText() well = ppp.Well(str(CONF.well_dir / ".{}".format(well_name))) key_to_remove = [] for key in pres_list: if key not in well.params.keys(): key_to_remove.append(key) for key in key_to_remove: pres_list.remove(key) self.pres_listWidget.clear() for name in pres_list: new_item = QListWidgetItem(name, self.pres_listWidget) new_item.setFlags(new_item.flags() | Qt.ItemIsUserCheckable) new_item.setCheckState(Qt.Unchecked)
def modelChanged(self): self._list.clear() items = self._model.getList() for item in items: list_item = QListWidgetItem(item) list_item.setFlags(list_item.flags() | Qt.ItemIsUserCheckable) if self._model.isValueSelected(item): list_item.setCheckState(Qt.Checked) else: list_item.setCheckState(Qt.Unchecked) self._list.addItem(list_item) self.filterList(self._search_box.filter())
def set_project_id(self, prjId = None): self.sectionListWidget.clear() if prjId is not None: self.projectId = prjId if self.projectId is None: return for s_id, section in self.data[prjId]['Sections'].items(): title = '{0}: de {1} a {2}'.format(section['Counter'], section['StartNode'], section['EndNode']) item = QListWidgetItem(warning_icon, title) item.setData(Qt.UserRole, s_id) item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsUserCheckable) item.setCheckState(Qt.Checked if section['Import'] else Qt.Unchecked) self.sectionListWidget.addItem(item) self.update_status()
def addIcon(self, page="Main"): button = QListWidgetItem() if page == "Main": button.setIcon(QIcon(":gconf-editor")) button.setText("Main") elif page == "Configure": button.setIcon(QIcon(":preferences-system")) button.setText("Configure") elif page == "Plot Options": button.setIcon(QIcon(":applications-graphics")) button.setText("Plot Options") else: button.setIcon(QIcon(":applications-debugging")) button.setText(page) button.setTextAlignment(Qt.AlignHCenter) button.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) self.contentsWidget.addItem(button)
def __addListItems(self): i = 0 for key in self.__statistics.keys(): name = self.sender().getProjectName(key) if name is None: name = key color = self.__colors[i] item = QListWidgetItem(name) item.setData(Qt.DecorationRole, QVariant(QColor(color))) item.setData(Qt.UserRole, QVariant(key)) item.setFlags(Qt.ItemIsSelectable|Qt.ItemIsUserCheckable|Qt.ItemIsEnabled) item.setCheckState(Qt.Checked) self.__projectsList.addItem(item) i = i + 1 if i >= len(self.__colors): i = 0