def fill_listing(self): playlists = self.controller.model().get_playlist_ids(self.kind) self.lst_lists.clear() for name, pid in playlists.items(): item = QListWidgetItem(name, self.lst_lists) item.playlist_id = pid # For click callback.
def feel_list(self): self.lstGroups.clear() ds_groups = GroupsList(USER_GROUP_PATHS) for ds_group in ds_groups.groups.itervalues(): item = QListWidgetItem(QIcon(ds_group.icon), self.tr(ds_group.alias)) item.setData(Qt.UserRole, ds_group) self.lstGroups.addItem(item)
def createCellWidget(self, qmlDict, attr, count): """ Creates specific widgets for each attribute, which can be a QCombobox, a QLineEdit or a QListWidget. """ if attr in qmlDict.keys(): enableIgnoreOption = False #case the type is dict the cell widget must be a combobox if isinstance(qmlDict[attr],dict): comboItem = DsgCustomComboBox() comboItem.addItems(sorted(qmlDict[attr].keys())) self.attributeTableWidget.setCellWidget(count, 1, comboItem) #case the type is tuple the cell widget must be a listwidget if isinstance(qmlDict[attr],tuple): (table, filterKeys) = qmlDict[attr] #getting the value relation dictionary used to make the listwidget valueRelation = self.makeValueRelationDict(table, filterKeys) list = QListWidget() for key in valueRelation.keys(): listItem = QListWidgetItem(key) listItem.setCheckState(Qt.Unchecked) list.addItem(listItem) self.attributeTableWidget.setCellWidget(count, 1, list) #this is the normal case, a simple lineedit else: textItem = QLineEdit() self.attributeTableWidget.setCellWidget(count, 1, textItem) enableIgnoreOption = True #insert here aditional parameters self.createAditionalParameters(count, enableIgnoreOption)
def get_input(self, obj, key): lb = self.lb_objects for item_index in range(lb.count()): if lb.item(item_index).data(Qt.UserRole) == key: break else: item_index = None if obj is None: if item_index is None: return del self.objects[key] lb.takeItem(item_index) if not self.objects: self.send("Object", None) return else: self.objects[key] = obj item_desc = "{} {}".format( type(obj).__name__, getattr(obj, "name", "")) if item_index is None: item = QListWidgetItem(item_desc) item.setData(Qt.UserRole, key) lb.addItem(item) lb.setCurrentItem(item) else: lb.item(item_index).setText(item_desc) self._on_selection_change()
def _update_pyqt_object_from_config(self, obj, config_data, index=None): if index: obj = obj[index] if type(obj) == QPushButton: # QPushButton obj.setText(config_data[0]) obj.setStyleSheet(config_data[1]) # return obj elif hasattr(obj, 'isChecked'): # [QCheckBox,QRadioButton]: obj.setChecked(config_data[0]) elif hasattr(obj, 'text'): # QLabel, QLineEdit obj.setText(config_data[0]) # return obj elif hasattr(obj, 'count') and hasattr(obj, 'itemText') and hasattr(obj, 'currentIndex'): # QComboBox obj.clear() obj.addItems(config_data[0]) obj.setCurrentIndex(config_data[1]) # return obj elif hasattr(obj, 'count') and hasattr(obj, 'selectedIndexes'): # # QListWidget # removing old items obj.clear() for itemlabel in config_data[0]: item = QListWidgetItem() item.setText(itemlabel) obj.addItem(item) for itemid in range(obj.count()): if itemid in config_data[1]: obj.item(itemid).setSelected(True) else: obj.item(itemid).setSelected(False)
def __init__(self, workspace, documents): super(_UISaveFiles, self).__init__(workspace) self.cancelled = False uic.loadUi(os.path.join(DATA_FILES_PATH, 'ui/SaveFiles.ui'), self) self.buttonBox.clicked.connect(self._onButtonClicked) self._itemToDocument = {} for document in documents: name = document.fileName() if name is None: name = 'untitled' item = QListWidgetItem( name, self.listWidget ) if document.filePath() is not None: item.setToolTip( document.filePath() ) item.setCheckState( Qt.Checked ) self._itemToDocument[item] = document # Retitle buttons, add first letter shortcuts for them. bb = self.buttonBox self._shortcut = ( self._firstLetterShortcut(bb.Discard, 'close &Without saving'), self._firstLetterShortcut(bb.Cancel, '&Cancel close'), self._firstLetterShortcut(bb.Save, '&Save checked') ) self.buttonBox.button(QDialogButtonBox.Cancel).setFocus()
def __init__(self, main): QListWidget.__init__(self) self.setStyleSheet(""" WebPluginList { color: black; background-color: white; selection-color: blue; border-radius: 10px; selection-background-color: #437DCD; } WebPluginList:Item { border-radius: 10px; border-style: solid; background-color: white; } WebPluginList:Item:hover { border-radius: 10px; border-style: solid; background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #FAFBFE, stop: 1 #6181E0); }""") self.connect(self, SIGNAL("itemSelectionChanged()"), self.openSelected) self._main = main settings = QSettings() i = 1 for recent_project in settings.value('recentProjects', []).toStringList(): if manage_files.folder_exists(str(recent_project)): item = QListWidgetItem(str(recent_project.split('/')[-1])) item.setToolTip(recent_project) item.setIcon(QIcon(resources.images['tree-app'])) self.addItem(item) i = i + 1 if i == 10: break
def fileProcessed(self, path, rv): if isinstance(rv, Exception): try: raise rv except IOError as exc: if exc.errno == errno.ENOENT: msg = "ERROR: File doesn't exist" else: msg = "ERROR: %s" % os.strerror(exc.errno) except UnicodeDecodeError: msg = "ERROR: Cannot read file using %s encoding" % self.processor.input_encoding except UnicodeEncodeError: msg = "ERROR: Cannot write file using %s encoding (try setting output encoding to UTF-8)" % self.processor.output_encoding except pysubs2.FormatAutodetectionError: msg = "ERROR: Unknown subtitle format (malformed file?)" except Exception as exc: msg = "ERROR: %r" % exc else: msg = None self.processed_ok += 1 self.processed += 1 self.progressBar.setValue(self.progressBar.value() + 1) if msg: item = QListWidgetItem(msg) item.setForeground(QColor("darkred" if msg.startswith("ERROR") else "darkgreen")) self.logList.addItem(item) scroll_to_bottom(self.logList)
def set_widgets(self): """Set widgets on the Hazard Category tab.""" self.clear_further_steps() # Set widgets self.lstHazardCategories.clear() self.lblDescribeHazardCategory.setText('') self.lblSelectHazardCategory.setText( hazard_category_question) hazard_categories = self.hazard_categories_for_layer() for hazard_category in hazard_categories: if not isinstance(hazard_category, dict): hazard_category = definition(hazard_category) item = QListWidgetItem( hazard_category['name'], self.lstHazardCategories) item.setData(QtCore.Qt.UserRole, hazard_category['key']) self.lstHazardCategories.addItem(item) # Set values based on existing keywords (if already assigned) category_keyword = self.parent.get_existing_keyword('hazard_category') if category_keyword: categories = [] for index in xrange(self.lstHazardCategories.count()): item = self.lstHazardCategories.item(index) categories.append(item.data(QtCore.Qt.UserRole)) if category_keyword in categories: self.lstHazardCategories.setCurrentRow( categories.index(category_keyword)) self.auto_select_one_item(self.lstHazardCategories)
def __init__(self, workspace, documents): super(_UISaveFiles, self).__init__(workspace) self.cancelled = False uic.loadUi(os.path.join(DATA_FILES_PATH, 'ui/SaveFiles.ui'), self) self.buttonBox.clicked.connect(self._onButtonClicked) self._itemToDocument = {} for document in documents: name = document.fileName() if name is None: name = 'untitled' item = QListWidgetItem( name, self.listWidget ) if document.filePath() is not None: item.setToolTip( document.filePath() ) item.setCheckState( Qt.Checked ) self._itemToDocument[item] = document self.buttonBox.button(self.buttonBox.Discard).setText(self.tr('close &Without saving')) self.buttonBox.button(self.buttonBox.Cancel).setText(self.tr('&Cancel close')) self.buttonBox.button(self.buttonBox.Save).setText(self.tr('&Save checked')) # Provide first-letter only shortcuts (not Alt+first letter which is # already present because of the & before letters) for each button. self.shortcut = [] for letter, button in (("W", self.buttonBox.Discard), ("C", self.buttonBox.Cancel), ("S", self.buttonBox.Save)): shortcut = QShortcut(QKeySequence(letter), self) shortcut.activated.connect(self.buttonBox.button(button).click) self.shortcut.append(shortcut) self.buttonBox.button(QDialogButtonBox.Cancel).setFocus()
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 resultitemchanged(self, new_item): self.IDC_textDetails.setText('') self.IDC_listRessources.clear() self.IDC_plainTextLink.clear() if new_item is None: return package = new_item.data(Qt.UserRole) self.cur_package = package if package is None: return self.IDC_textDetails.setText( u'{0}\n\n{1}\n{2}\n\n{3}'.format( package.get('notes', 'no notes'), package.get('author', 'no author'), package.get('author_email', 'no author_email'), package.get('license_id', 'no license_id') ) ) if package.get('num_resources', 0) > 0: for res in package['resources']: item = QListWidgetItem(u'{0}: {1}'.format( res.get('format', 'no format') , res.get('name', 'no name') )) item.setData(Qt.UserRole, res) item.setCheckState(Qt.Unchecked) self.IDC_listRessources.addItem(item)
def __init__(self, opPixelClassification, parent): super( QDialog, self ).__init__(parent=parent) self._op = opPixelClassification classifier_listwidget = QListWidget(parent=self) classifier_listwidget.setSelectionMode( QListWidget.SingleSelection ) classifier_factories = self._get_available_classifier_factories() for name, classifier_factory in classifier_factories.items(): item = QListWidgetItem( name ) item.setData( Qt.UserRole, QVariant(classifier_factory) ) classifier_listwidget.addItem(item) buttonbox = QDialogButtonBox( Qt.Horizontal, parent=self ) buttonbox.setStandardButtons( QDialogButtonBox.Ok | QDialogButtonBox.Cancel ) buttonbox.accepted.connect( self.accept ) buttonbox.rejected.connect( self.reject ) layout = QVBoxLayout() layout.addWidget( classifier_listwidget ) layout.addWidget( buttonbox ) self.setLayout(layout) self.setWindowTitle( "Select Classifier Type" ) # Save members self._classifier_listwidget = classifier_listwidget
def updateList(self, visualizations): self.ui.tablesList.clear() for visualization in visualizations: item = QListWidgetItem(self.ui.tablesList) owner = None owner = visualization['permission']['owner']['username'] widget = CartoDBDatasetsListItem( visualization['name'], owner, visualization['table']['size'], visualization['table']['row_count'], shared=(owner != self.currentUser), multiuser=self.currentMultiuser) # item.setText(visualization['name']) readonly = False # qDebug('Vis:' + json.dumps(visualization, sort_keys=True, indent=2, separators=(',', ': '))) if visualization['permission'] is not None and owner != self.currentUser and \ visualization['permission']['acl'] is not None: for acl in visualization['permission']['acl']: if acl['type'] == 'user' and 'username' in acl['entity'] and acl['entity']['username'] == self.currentUser and \ acl['access'] == 'r': readonly = True break widget.readonly = readonly if readonly: widget.setTextColor('#999999') item.setSizeHint(widget.sizeHint()) # item.setIcon(QIcon(":/plugins/qgis-cartodb/images/icons/layers.png")) self.ui.tablesList.setItemWidget(item, widget)
def add_item_list(self, items): if not self.isVisible(): self.show() for i in items: item = QListWidgetItem(i) item.setTextAlignment(Qt.AlignHCenter) self._list_widget.addItem(item)
def popularListaAlimentos(self): self.alimentos = {} #busca todos os arquivos for root, dirs, files in os.walk(MY_DIR_ALIMENTO): #para cada arquivo for f in files: #pega o arquivo, carrega e fecha arq = file(MY_DIR_ALIMENTO + f) alim = pickle.load(arq) arq.close() #adiciona o item na lista de alimento self.alimentos[str(alim.nome)] = alim icon = QtGui.QIcon() icon.addPixmap(QtGui.QPixmap(alim.imagem), QtGui.QIcon.Normal, QtGui.QIcon.Off) item = QListWidgetItem() item.setIcon(icon) item.setText(alim.nome) self.listaAlimentos.addItem(item)
def __init__(self, data, parent=None): self.data = data if isinstance(data, Species): text = data.name self.amounts_index = data.index elif isinstance(data, Compartment): text = data.compartment_name_and_xy_coords() self.amounts_index = data.index elif isinstance(data, Run): text = "%s" % (data._run_number) self.amounts_index = data._run_number - 1 # elif isinstance(data, Simulation): # text = "%s %s" % (data.model_input_file, data.simulation_start_time) # self.amounts_index = None else: raise TypeError("type of data is not recognised") QListWidgetItem.__init__(self, text, parent, QListWidgetItem.UserType) # QObject::startTimer: QTimer can only be used with threads started with QThread if isinstance(self.amounts_index, int): self.setToolTip('%d' % self.amounts_index)
def __init__(self, iface, toolbar, parent=None): CartoDBPluginUserDialog.__init__(self, toolbar, parent) self.iface = iface self.ui = Ui_Upload() self.ui.setupUi(self) self.ui.bar = QgsMessageBar() self.ui.bar.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) self.ui.verticalLayout.insertWidget(0, self.ui.bar) self.ui.uploadBT.clicked.connect(self.upload) self.ui.cancelBT.clicked.connect(self.reject) self.ui.layersList.itemSelectionChanged.connect(self.validateButtons) layers = QgsMapLayerRegistry.instance().mapLayers() # TODO Implement add to project # self.ui.convertCH.hide() self.ui.overideCH.hide() self.ui.layersList.clear() self.ui.uploadBar.setValue(0) self.ui.uploadBar.hide() self.ui.uploadingLB.hide() for id_ly, ly in layers.iteritems(): qDebug('Layer id {}'.format(stripAccents(id_ly))) if ly.type() == QgsMapLayer.VectorLayer and not isinstance(ly, CartoDBLayer): item = QListWidgetItem(self.ui.layersList) widget = CartoDBLayerListItem(ly.name(), ly, getSize(ly), ly.dataProvider().featureCount()) item.setSizeHint(widget.sizeHint()) self.ui.layersList.setItemWidget(item, widget)
def set_widgets(self): """Set widgets on the Classification tab.""" self.clear_further_steps() purpose = self.parent.step_kw_purpose.selected_purpose()['name'] subcategory = self.parent.step_kw_subcategory.\ selected_subcategory()['name'] self.lstClassifications.clear() self.lblDescribeClassification.setText('') self.lblSelectClassification.setText( classification_question % (subcategory, purpose)) classifications = self.classifications_for_layer() for classification in classifications: if not isinstance(classification, dict): classification = definition(classification) item = QListWidgetItem( classification['name'], self.lstClassifications) item.setData(QtCore.Qt.UserRole, classification['key']) self.lstClassifications.addItem(item) # Set values based on existing keywords (if already assigned) classification_keyword = self.parent.get_existing_keyword( 'classification') if classification_keyword: classifications = [] for index in xrange(self.lstClassifications.count()): item = self.lstClassifications.item(index) classifications.append(item.data(QtCore.Qt.UserRole)) if classification_keyword in classifications: self.lstClassifications.setCurrentRow( classifications.index(classification_keyword)) self.auto_select_one_item(self.lstClassifications)
def __init__(self, weboob, parent=None): QWidget.__init__(self, parent) self.ui = Ui_MessagesManager() self.ui.setupUi(self) self.weboob = weboob self.ui.backendsList.addItem('(All)') for backend in self.weboob.iter_backends(): if not backend.has_caps(ICapMessages): continue item = QListWidgetItem(backend.name.capitalize()) item.setData(Qt.UserRole, backend) self.ui.backendsList.addItem(item) self.ui.backendsList.setCurrentRow(0) self.backend = None self.thread = None self.message = None self.ui.replyButton.setEnabled(False) self.ui.replyWidget.hide() self.connect(self.ui.backendsList, SIGNAL('itemSelectionChanged()'), self._backendChanged) self.connect(self.ui.threadsList, SIGNAL('itemSelectionChanged()'), self._threadChanged) self.connect(self.ui.messagesTree, SIGNAL('itemClicked(QTreeWidgetItem *, int)'), self._messageSelected) self.connect(self.ui.messagesTree, SIGNAL('itemActivated(QTreeWidgetItem *, int)'), self._messageSelected) self.connect(self.ui.replyButton, SIGNAL('clicked()'), self._replyPressed) self.connect(self.ui.sendButton, SIGNAL('clicked()'), self._sendPressed)
def set_widgets(self): """Set widgets on the Subcategory tab.""" self.clear_further_steps() # Set widgets purpose = self.parent.step_kw_purpose.selected_purpose() self.lstSubcategories.clear() self.lblDescribeSubcategory.setText('') self.lblIconSubcategory.setPixmap(QPixmap()) self.lblSelectSubcategory.setText( get_question_text('%s_question' % purpose['key'])) for i in self.subcategories_for_layer(): item = QListWidgetItem(i['name'], self.lstSubcategories) item.setData(QtCore.Qt.UserRole, i['key']) self.lstSubcategories.addItem(item) # Check if layer keywords are already assigned key = self.parent.step_kw_purpose.selected_purpose()['key'] keyword = self.parent.get_existing_keyword(key) # Overwrite the keyword if it's KW mode embedded in IFCW mode if self.parent.parent_step: keyword = self.parent.get_parent_mode_constraints()[1]['key'] # Set values based on existing keywords or parent mode if keyword: subcategories = [] for index in xrange(self.lstSubcategories.count()): item = self.lstSubcategories.item(index) subcategories.append(item.data(QtCore.Qt.UserRole)) if keyword in subcategories: self.lstSubcategories.setCurrentRow( subcategories.index(keyword)) self.auto_select_one_item(self.lstSubcategories)
def __init__(self, toolbar, parent=None): QDialog.__init__(self, parent) self.toolbar = toolbar self.settings = QSettings() self.ui = Ui_Upload() self.ui.setupUi(self) self.ui.uploadBT.clicked.connect(self.upload) self.ui.cancelBT.clicked.connect(self.reject) self.currentUser = self.toolbar.currentUser self.currentApiKey = self.toolbar.currentApiKey self.currentMultiuser = self.toolbar.currentMultiuser layers = QgsMapLayerRegistry.instance().mapLayers() self.ui.layersList.clear() self.ui.uploadBar.setValue(0) self.ui.uploadBar.hide() self.ui.uploadingLB.hide() for id, ly in layers.iteritems(): if ly.type() == QgsMapLayer.VectorLayer and not isinstance(ly, CartoDBLayer): item = QListWidgetItem(self.ui.layersList) widget = CartoDBLayerListItem(ly.name(), ly, self.getSize(ly), ly.dataProvider().featureCount()) item.setSizeHint(widget.sizeHint()) self.ui.layersList.setItemWidget(item, widget) worker = CartoDBPluginWorker(self, 'connectUser') worker.start()
def search(self, text): db = self.db c = db.cursor() self.resultsView.clear() self.resultsView.setEnabled(False) if not text: return if self.fuzzyCheck.isChecked(): search = "* ".join(text.split()) + "*" else: search = text query = c.execute("""SELECT layer, featureid, snippet(search, '[',']') as snippet FROM search JOIN featureinfo on search.docid = featureinfo.id WHERE search match '{}' LIMIT 100""".format(search)).fetchall() for layer, featureid, snippet in query: item = QListWidgetItem() text = "{}\n {}".format(layer, snippet.replace('\n', ' ')) item.setText(text) item.setData(Qt.UserRole, (layer, featureid, snippet)) self.resultsView.addItem(item) self.resultsView.setEnabled(True) if self.resultsView.count() == 0: self.resultsView.addItem("No Results") self.resultsView.setEnabled(False) db.close()
def on_OpenPlaylist_clicked(self): """ Load and parse a .pla.refs file """ self.playlistname = toPython(QFileDialog.getOpenFileName(\ None, self.trUtf8("Select playlist to edit"), self.playlistname, self.trUtf8("*.pla"), None)) if self.playlistname: unicodeplaylist = toPython(self.playlistname) prefix = mountpoint(unicodeplaylist) if os.name == 'nt': prefix = prefix + "\\" PL = open(self.playlistname + ".refs", "r") self.playlistWidget.clear() for song in PL.readlines(): song = toPython(QString(song)) song = song.strip() pcsong = prefix + song[7:] cover = os.path.join(os.path.split(pcsong)[0], "folder.jpg") listItem = QListWidgetItem(song) if os.path.isfile(cover): listItem.setIcon(QIcon(cover)) print "Loading " + cover else: print "Album art'" + cover +" not found" self.playlistWidget.addItem(listItem) PL.close()
def feel_list(self): self.lstServices.clear() ds_list = DataSourcesList(USER_DS_PATHS) for ds in ds_list.data_sources.itervalues(): item = QListWidgetItem(ds.action.icon(), ds.action.text()) item.setData(Qt.UserRole, ds) self.lstServices.addItem(item)
def build_list(self, files): self.listWidget.clear() for fname in files: item = QListWidgetItem(fname) item.setData(Qt.UserRole, fname) self.listWidget.addItem(item) self.listWidget.setCurrentRow(0)
def set_widgets(self): """Set widgets on the Field tab.""" subcategory = self.parent.step_kw_subcategory.selected_subcategory() unit = self.parent.step_kw_unit.selected_unit() question_text = field_question_name_field % (subcategory['name']) self.lblSelectField.setText(question_text) self.lstFields.clear() default_item = None type_field = self.parent.step_kw_field.selected_field() for field in self.parent.layer.dataProvider().fields(): field_name = field.name() if type_field != field_name: # We do not use a field already used in the wizard before. 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 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 set_widgets(self): """Set widgets on the layer purpose tab.""" self.clear_further_steps() # Set widgets self.lstCategories.clear() self.lblDescribeCategory.setText("") self.lblIconCategory.setPixmap(QPixmap()) self.lblSelectCategory.setText(category_question % self.parent.layer.name()) purposes = self.purposes_for_layer() if self.parent.get_layer_geometry_id() == "polygon": purposes += ["aggregation"] for purpose in purposes: if not isinstance(purpose, dict): purpose = definition(purpose) item = QListWidgetItem(purpose["name"], self.lstCategories) item.setData(QtCore.Qt.UserRole, purpose["key"]) self.lstCategories.addItem(item) # Check if layer keywords are already assigned purpose_keyword = self.parent.get_existing_keyword("layer_purpose") # Overwrite the purpose_keyword if it's KW mode embedded in IFCW mode if self.parent.parent_step: purpose_keyword = self.parent.get_parent_mode_constraints()[0]["key"] # Set values based on existing keywords or parent mode if purpose_keyword: purposes = [] for index in xrange(self.lstCategories.count()): item = self.lstCategories.item(index) purposes.append(item.data(QtCore.Qt.UserRole)) if purpose_keyword in purposes: self.lstCategories.setCurrentRow(purposes.index(purpose_keyword)) self.auto_select_one_item(self.lstCategories)
def __init__(self, iface, settings): self.iface = iface self.s = settings QDialog.__init__(self, iface.mainWindow()) # Set up the user interface from Designer. self.ui = Ui_VoGISRaumplanungPlot() self.ui.setupUi(self) try: self.json_settings = JsonSettings(self.iface, self.s.read(self.s.key_file_settings)) except: msg = u'Einstellungsdatei konnte nicht geladen werden!\nBitte die Datei auf korrektes JSON-Format überprüfen.\n\n\nFehlerprotokoll:\n{0}'.format(traceback.format_exc()) QMessageBox.warning(self.iface.mainWindow(), DLG_CAPTION, msg) return self.dkm_coverage_layer = None self.gstke = {} self.curr_gem_name = None #hold kgs and gnrs if there's already a selection in the active document self.autoselect_kgs = None self.autoselect_gnrs = None self.__add_themen() #add Gemeinde names self.gem_src = VRPGemeinden(self.iface, self.s, self.json_settings) QApplication.setOverrideCursor(Qt.WaitCursor) try: gem_names = self.gem_src.get_names() #if VRP_DEBUG is True: QgsMessageLog.logMessage('\n'.join(gem_names), DLG_CAPTION) for gem in gem_names: item = QListWidgetItem(gem) item.setData(Qt.UserRole, gem) self.ui.LST_GEMEINDEN.addItem(item) finally: QApplication.restoreOverrideCursor() #insert layouts for name, layout in self.json_settings.layouts().iteritems(): self.ui.CB_Layout.addItem(name, layout) #speed up items insertion self.ui.LST_GSTKE.setLayoutMode( QListWidget.Batched ) self.ui.LST_GSTKE.setBatchSize( 100 ) self.ui.LST_GSTKE.setUniformItemSizes(True) #check if the active layer is a DKM layer and if there are any selected features if not self.iface.activeLayer() is None: act_lyr = self.iface.activeLayer() if isinstance(act_lyr, QgsVectorLayer): sel_feats = act_lyr.selectedFeatures() if len(sel_feats) > 0: fld_gemname = self.json_settings.fld_pgem_name() fld_kg = self.json_settings.fld_kg() fld_gnr = self.json_settings.fld_gnr() dkm_flds = [fld_gemname, fld_kg, fld_gnr] if all( dkm_fld in [fld.name() for fld in act_lyr.pendingFields()] for dkm_fld in dkm_flds): #self.iface.messageBar().pushMessage(u'alles da!', QgsMessageBar.INFO) self.__apply_selected_features(sel_feats, fld_gemname, fld_kg, fld_gnr)
def __init__(self, text, parent=None, italic=False): QListWidgetItem.__init__(self, text, parent) font = self.font() font.setPointSize(10) if italic: font.setItalic(True) self.setFont(font) self.clickeable = False
def set_widgets(self): """Set widgets on the LayerMode tab.""" self.clear_further_steps() # Set widgets purpose = self.parent.step_kw_purpose.selected_purpose() subcategory = self.parent.step_kw_subcategory.selected_subcategory() layer_mode_question = ( layer_mode_raster_question if is_raster_layer(self.parent.layer) else layer_mode_vector_question) self.lblDescribeLayerMode.setText('') self.lstLayerModes.clear() layer_modes = get_layer_modes(subcategory['key']) if is_raster_layer(self.parent.layer): layer_mode_question = layer_mode_raster_question else: if len(layer_modes) == 2: layer_mode_question = layer_mode_vector_question elif len(layer_modes) == 1: if layer_modes[0]['key'] == 'classified': layer_mode_question = layer_mode_vector_classified_confirm elif layer_modes[0]['key'] == 'continuous': layer_mode_question = layer_mode_vector_continuous_confirm else: layer_mode_question = layer_mode_vector_question self.lblSelectLayerMode.setText( layer_mode_question % (subcategory['name'], purpose['name'])) for layer_mode in layer_modes: item = QListWidgetItem(layer_mode['name'], self.lstLayerModes) item.setData(QtCore.Qt.UserRole, layer_mode['key']) self.lstLayerModes.addItem(item) # Set value to existing keyword or default value layer_mode_keys = [m['key'] for m in layer_modes] layer_mode_keyword = self.parent.get_existing_keyword('layer_mode') if layer_mode_keyword in layer_mode_keys: index = layer_mode_keys.index(layer_mode_keyword) elif layer_mode_continuous['key'] in layer_mode_keys: # Set default value index = layer_mode_keys.index(layer_mode_continuous['key']) else: index = -1 self.lstLayerModes.setCurrentRow(index) self.auto_select_one_item(self.lstLayerModes)
def add_list_items(self, proposals): self.completion_list.clear() for p in proposals: self.completion_list.addItem( QListWidgetItem(QIcon( self._icons.get(p[0], resources.IMAGES['attribute'])), p[1], type=ord(p[0])))
def populateAreaList(self): ''' Populate the area ID listbox ''' [ self.lstAreas.addItem(QListWidgetItem(str(intOrString(label)))) for label in self.model.getOutputAreaIDs() ]
def loadModules(self): self.ui.modulesList.clear() for name, module in sorted( self.weboob.repositories.get_all_modules_info( self.caps).iteritems()): item = QListWidgetItem(name.capitalize()) self.set_icon(item, module) self.ui.modulesList.addItem(item)
def FillSurveys(self): self.AS = AllSurveys(self.ODB) FullName = self.AS.GetCombo() for fn in FullName: item = QListWidgetItem(fn) self.AvailSurveys.addItem(item) self.AvailSurveys.setSelectionMode( QtGui.QAbstractItemView.MultiSelection)
def add_last_used_services(self): services = CachedServices().get_cached_services() if len(services) == 0: return self.lstSearchResult.insertItem(0, self.tr("Last used:")) # l = QLabel(self.tr("Last used:")) # l.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed) # self.lSearchResult.addWidget(l) for attributes, image_qByteArray in services: custom_widget = QmsSearchResultItemWidget(attributes, image_qByteArray) new_item = QListWidgetItem(self.lstSearchResult) new_item.setSizeHint(custom_widget.sizeHint()) self.lstSearchResult.addItem(new_item) self.lstSearchResult.setItemWidget(new_item, custom_widget)
def uncommit(self): path = self.plugin.editor.get_project_owner() for pos in reversed(xrange(self.added_files.count())): item = self.added_files.item(pos) widget = self.added_files.itemWidget(item) text = widget.text() if widget.isChecked(): self.git.uncommit(path, str(widget.text())) self.added_files.removeItemWidget(item) self.added_files.takeItem(pos) item = QListWidgetItem() self.untracked_files.addItem(item) check_box = QCheckBox(text) self.untracked_files.setItemWidget(item, check_box) for pos in reversed(xrange(self.s_modified_files.count())): item = self.s_modified_files.item(pos) widget = self.s_modified_files.itemWidget(item) text = widget.text() if widget.isChecked(): self.git.uncommit(path, widget.text()) self.s_modified_files.removeItemWidget(item) self.s_modified_files.takeItem(pos) item = QListWidgetItem() self.modified_files.addItem(item) check_box = QCheckBox(text) self.modified_files.setItemWidget(item, check_box) for pos in reversed(xrange(self.s_deleted_files.count())): item = self.s_deleted_files.item(pos) widget = self.s_deleted_files.itemWidget(item) text = widget.text() if widget.isChecked(): self.git.uncommit(path, widget.text()) self.s_deleted_files.removeItemWidget(item) self.s_deleted_files.takeItem(pos) item = QListWidgetItem() self.deleted_files.addItem(item) check_box = QCheckBox(text) self.deleted_files.setItemWidget(item, check_box)
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 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 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 setupPluginList(self, pluginList): """setup plugin list from configuration file""" fts = ConfManager.getManager().getValue('common', 'plugins') i = 0 for ft in fts: flistItem = QListWidgetItem(QIcon('icon/plugin.png'), ft['name'], pluginList) pluginList.insertItem(i, flistItem) i += 1
def setupFolderList(self, folderList): """setup folder list for showing""" fts = ConfManager.getManager().getValue('common', 'folders') i = 0 for ft in fts: flistItem = QListWidgetItem(QIcon('icon/folder.png'), ft, folderList) folderList.insertItem(i, flistItem) i += 1
def on_operation_commands_add_clicked(self): tx_packets = dict([ (packet.name, num) for num, packet in self.instr_cfg.instrument.tx_packets.iteritems() ]) (text, ok) = QInputDialog.getItem(\ self, self.trUtf8("Add operation command"), self.trUtf8("Select command to send:"), tx_packets.keys(), 0, False) if ok and text: cmd_num = tx_packets[str(text)] command = self.instr_cfg.add_operation_command(cmd_num) item = QListWidgetItem(str(cmd_num)) item.cmd = command self.operation_commands_list.addItem(item) self.operation_commands_list.setCurrentItem(item)
def __init__(self): QMainWindow.__init__(self) # finger scrolling effect self.charm = FlickCharm() # make instance (in QMainwindow as parent) self.listwidget = QListWidget() self.setCentralWidget(self.listwidget) #populate ListWidget with a set of Items... for i in range(1000): newItem = QListWidgetItem( self.listwidget ) # create new ListWidgetItem (parent= ListWidget) newItem.setText("This is entry no {0}".format(i)) #self.m_firstColor.append(newItem) self.charm.activateOn(self.listwidget) # activate on widget
def add_file(self, f): item = QListWidgetItem(f) self.ui.listWidgetFiles.addItem(item) #the following happens multiple times if you open multiple files, but who cares self.ui.actionAdd_Comment.setEnabled(True) self.ui.actionAdd_Comment_radius_0.setEnabled(True) self.ui.actionSave.setEnabled(True)
def addPiece(self, comp): """ adds a Component instance, and returns the QListWidgetItem created """ if self.hideItem(comp, False) >= 0: return blockItem = QListWidgetItem(self) comp.toListWidgetItem(blockItem) return blockItem
def show_result(self, geoservice, image_ba): if geoservice: custom_widget = QmsSearchResultItemWidget(geoservice, image_ba) new_item = QListWidgetItem(self.lstSearchResult) new_item.setSizeHint(custom_widget.sizeHint()) self.lstSearchResult.addItem(new_item) self.lstSearchResult.setItemWidget(new_item, custom_widget) # self.lSearchResult.addWidget(custom_widget) else: new_item = QListWidgetItem() new_item.setText(self.tr('No results!')) new_item.setData(Qt.UserRole, None) self.lstSearchResult.addItem(new_item) # l = QLabel(self.tr("No results!")) # l.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed) # self.lSearchResult.addWidget(l) self.lstSearchResult.update()
def _tabListValue_setup(self): self.tabListValue_list_values.clear() self.tabListValue_tx_value.clear() prop = self.property_selected if prop == 'geom': return property_list = self._get_property(self.resource, prop) for elem in property_list: k, v = elem.items()[0] item = QListWidgetItem() item.setText(unicode(v)) self.tabListValue_list_values.addItem(item)
def __init__(self, evtxManager, root): EventLogViewer.__init__(self, None) self.evtxManager = evtxManager self.vfs = VFS.Get() self.evtx_table_view.setColumnCount(7) self.evtx_table_view.hideColumn(4) self.evtx_table_view.hideColumn(5) self.evtx_table_view.hideColumn(6) self.admin_pannel.hide() self.list_widget = QListWidget() file_names = QLabel('Windows events') ww = QWidget() l = QVBoxLayout(ww) l.addWidget(file_names) l.addWidget(self.list_widget) l.setSpacing(2) l.setContentsMargins(2, 2, 2, 2) for node_name, chunks in self.evtxManager.getData(): node = self.vfs.getNodeById(node_name) if node.absolute()[:len(root)] != root: continue item = QListWidgetItem( QIcon(':/toggle_log'), node.name().replace('Microsoft-Windows-', '').replace('.evtx', '')) item.setData(QListWidgetItem.UserType, long(node_name)) self.list_widget.addItem(item) self.list_widget.sortItems() self.list_widget.itemClicked.connect(self.fill_log_viewer) self.splitter.insertWidget(0, ww) ctrl = EvtControlPannel(self.evtx_table_view) self.splitter.insertWidget(2, ctrl) self.list_widget.itemClicked.connect(ctrl.reload)
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_instrument(self, instrument): self.clear_instrument() self.instrument = instrument # base info self.instrument_name.setText(self.instrument.name) self.instrument_short_name.setText(self.instrument.short_name) self.byte_order.setCurrentIndex(self.byte_order.findText(self.instrument.byte_order)) # connection self.conn_type.setCurrentIndex(self.conn_type.findText(self.instrument.connection.type)) self.load_connection() # packet format for i, field in enumerate(self.instrument.packet_format.rx_format): combo_box = getattr(self, 'pf_rx_format_{0}'.format(i)) combo_box.setCurrentIndex(combo_box.findText(field)) for i, field in enumerate(self.instrument.packet_format.tx_format): combo_box = getattr(self, 'pf_tx_format_{0}'.format(i)) combo_box.setCurrentIndex(combo_box.findText(field)) for start_byte in self.instrument.packet_format.start_bytes: item = QListWidgetItem(hex(start_byte)) item.setFlags(item.flags() | Qt.ItemIsEditable) self.pf_start_bytes.addItem(item) for end_byte in self.instrument.packet_format.end_bytes: item = QListWidgetItem(hex(end_byte)) item.setFlags(item.flags() | Qt.ItemIsEditable) self.pf_end_bytes.addItem(item) # rx packets for num in self.instrument.rx_packets: self.rx_packets_list.addItem(str(num)) if self.rx_packets_list.count(): self.rx_packets_list.setCurrentItem(self.rx_packets_list.item(0)) # tx packets for num in self.instrument.tx_packets: self.tx_packets_list.addItem(str(num)) if self.tx_packets_list.count(): self.tx_packets_list.setCurrentItem(self.tx_packets_list.item(0))
def add_items(self): characters = self.client.results for character in characters: item = QListWidgetItem(self.get_name(character["name"])) item.setData(Qt.UserRole, character) item.setSizeHint(QSize(48, 48)) icon = self.get_icon(character) if icon is not None: item.setIcon(icon) self.listWidget.addItem(item) self.listWidget.setCurrentRow(0)
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 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 data(self, role): if role == Qt.DisplayRole: if self.nodesCount : return QString.fromUtf8(self.__tag.name() + ' (' + str(self.nodesCount) + ')') else: return QString.fromUtf8(self.__tag.name()) elif role == Qt.BackgroundRole: color = self.__tag.color() return QColor(color.r, color.g, color.b) return QListWidgetItem.data(self, role)
def FillTranChar(self): for fieldname in [ 'SurveyTitle', 'SubSampleLocation', 'Year', 'StatArea', 'SubArea' ]: item = QListWidgetItem(fieldname) self.TransectCharacteristics.addItem(item) #pdb.set_trace() self.TransectCharacteristics.setSelectionMode( QtGui.QAbstractItemView.MultiSelection)
def grabNewData(self): self.data = self.data.append(self.servThread.newData, ignore_index=True) newNames = [ x for x in self.data.columns.values.tolist() if x not in self.varNames ] for name in newNames: self.xAxis.addItem(QListWidgetItem(name)) self.yAxis.addItem(QListWidgetItem(name)) for index in self.servThread.newData['FileNumber']: self.indexList.addItem(QListWidgetItem(str(index))) if self.varNames == []: self.xAxis.setCurrentRow(0) self.yAxis.setCurrentRow(0) self.indexList.setCurrentRow(0) self.plotData() self.varNames = self.varNames + newNames self.servThread.newData = pd.DataFrame()
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_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 set_widgets(self): """Set widgets on the LayerMode tab.""" self.clear_further_steps() # Set widgets self.lblBandSelector.setText( tr('Please select which band that contains the data that you want to ' 'use for this layer.')) self.lstBands.clear() band_num = self.parent.layer.bandCount() for i in range(band_num): item = QListWidgetItem(self.parent.layer.bandName(i + 1), self.lstBands) item.setData(QtCore.Qt.UserRole, i + 1) self.lstBands.addItem(item) existing_band = self.parent.get_existing_keyword('active_band') if existing_band: self.lstBands.setCurrentRow(existing_band - 1) else: # Set to Band 1 / index 0 self.lstBands.setCurrentRow(0)