def __init__(self): super(PersistendIndexProve, self).__init__() self.uiw = loadUi("/u/isaito/data/Dropbox/ROS/groovy_quantal/catkin_ws/src/rqt_prove/resource/treeview.ui") self._std_model = QStandardItemModel() self._rootitem = self._std_model.invisibleRootItem() item_r_1 = QStandardItem("r1") item_r_2 = QStandardItem("r2") print 'index before {}'.format(item_r_1.index()) qindex_persistent = QPersistentModelIndex(item_r_1.index()) self._std_model.beginInsertRows(self._rootitem.index(), 0, 0) self._rootitem.appendRow(item_r_1) self._rootitem.appendRow(item_r_2) self._std_model.endInsertRows() print 'index after {}'.format(item_r_1.index()) print 'index after 2 {}'.format(self._std_model.index(0, 0, QModelIndex())) print '_rootitem index={} persistent list={}'.format( self._rootitem.index(), self._std_model.persistentIndexList()) self.uiw._treeview.setModel(self._std_model) self.selectionModel = self.uiw._treeview.selectionModel() self.selectionModel.selectionChanged.connect( self._selection_changed_slot) self.selectionModel.currentChanged.connect( self._current_changed_slot) print('del/sel?\tde/sel index\tde/sel.row\tde/sel.dat\tparent\tinternal id') self.uiw.show()
def findMatches(self): regexp, content = self.getRegExpAndText() if not regexp : return # Or if not content : return end = len(content) matches = bret.search(regexp, content, 0 if self.NoMatchesLimitCheckBox.isChecked() else self.MatchesLimitSpinBox.value(), 0, end) headers = [_translate("MatchesTreeView", 'Match', None), _translate("MatchesTreeView", 'From position', None), _translate("MatchesTreeView", 'to position', None)] if self.PositionsCheckBox.isChecked() else [_translate("MatchesTreeView", 'Match', None)] self.matchesModel.setHorizontalHeaderLabels(headers) for m in matches : item = QStandardItem(m.group()) item.setToolTip(_translate("MatchesTreeView", "Double-click to copy", None)) if self.PositionsCheckBox.isChecked() : startPositionItem = QStandardItem(str(m.start())) endPositionItem = QStandardItem(str(m.end())) self.matchesModel.appendRow([item, startPositionItem, endPositionItem]) else : self.matchesModel.appendRow([item]) if self.GroupsCheckBox.isChecked() : for i in range(len(m.groups())) : subgroupItem = QStandardItem(m.group(i+1)) subgroupItem.setToolTip(_translate("MatchesTreeView", "Double-click to copy", None)) if self.PositionsCheckBox.isChecked() : subgroupStartItem = QStandardItem(str(m.start(i+1))) subgroupEndItem = QStandardItem(str(m.end(i+1))) item.appendRow([subgroupItem, subgroupStartItem, subgroupEndItem]) else : item.appendRow([subgroupItem]) numberOfResults = len(matches) self.NumberOfResultsLabel.setText('<i>' + _translate("CentralWidget", 'Number of results returned :', None) + ' </i><b>' + str(numberOfResults) + '</b>') self.MatchesTreeView.expandAll() self.MatchesTreeView.resizeColumnToContents(0)
def on_analyses_viewmodel_updated(self, view_model): qmodel = QStandardItemModel() qmodel.itemChanged.connect(self.on_qmodel_itemChanged) qmodel.setColumnCount(5) qmodel.setHorizontalHeaderItem(0, QStandardItem('Ion')) qmodel.setHorizontalHeaderItem(1, QStandardItem('Method')) qmodel.setHorizontalHeaderItem(2, QStandardItem('Start')) qmodel.setHorizontalHeaderItem(3, QStandardItem('End')) qmodel.setHorizontalHeaderItem(4, QStandardItem('Reason')) root = qmodel.invisibleRootItem() for ion, analysis in view_model.analyses.items(): ion_name = QStandardItem(ion.name) ion_name.setData(ion, Qt.UserRole) method = QStandardItem(analysis.method) start = QStandardItem(str(round(analysis.range.start,2))) end = QStandardItem(str(round(analysis.range.end,2))) reason = QStandardItem(analysis.reason) root.appendRow([ion_name, method, start, end, reason]) self.rangedTable.setModel(qmodel) self.rangedTable.setItemDelegateForColumn(1, MethodsComboDelegate(view_model.methods, self.rangedTable)) for row in range(0, qmodel.rowCount()): self.rangedTable.openPersistentEditor(qmodel.index(row, 1)) self.rangedTable.setColumnWidth(1, 95) self.rangedTable.setContextMenuPolicy(3) self.rangedTable.customContextMenuRequested.connect(self._context_menu_requested) shortcut = QShortcut(QKeySequence('Del'), self.rangedTable, self._delete_ion,self._delete_ion, context=0)
def listCharts(self): self.chartModel.clear() for c in self.charts: item = QStandardItem(c[0] + ' (' + c[2] + ')') item.setData(c[1]) self.chartModel.appendRow(item)
def addSelection(self, selection, name=""): self._selections.append(selection) item = QStandardItem(selection.name) item.setFlags(item.flags() ^ Qt.ItemIsDropEnabled) self._listModel.appendRow(item) self.setSelectionModified(False) return item
def _createListItem(self, values): result = [] for val in values: item = QStandardItem(str(val)) item.setEditable(False) result.append(item) return result
class UserItemModel(QStandardItemModel): foo, nama, userPicture, address, realname, locked = range(6) def __init__(self): QStandardItemModel.__init__(self) role_names = { self.foo: "", self.nama: "nama", self.userPicture: "userpicture", self.address: "address", self.realname: "realname", self.locked: "locked" } self.setRoleNames(role_names) def addRootElement(self): root = MyUser('root', 'root', '/root') self.addUserItem(root.getName(), root.getAvatar(), root.getHome(), root.getRealName(), root.getLock()) def addUserItem(self, username, userPicture, address, realname, locked, foo = ""): self.item = QStandardItem() self.item.setData(username, self.nama) self.item.setData(userPicture, self.userPicture) self.item.setData(address, self.address) self.item.setData(realname, self.realname) self.item.setData(locked, self.locked) self.appendRow(self.item)
def addItemToQTableView(self, item, selectedItems): standardItem = QStandardItem(item.name) standardItem.setData(item.data) logger.debug( "--rightArrowClicked() self._model.appendRow(standardItem) selectedItems: {0}" .format(len(selectedItems))) self._model.appendRow(standardItem)
def removePeakFromOneCluster(self): idx=self.view.treeView_3.selectedIndexes()[0]#supposed the selection exists if not idx.isValid(): return model=idx.model() #copy the item itemToDelete = model.itemFromIndex(idx) item = QStandardItem(itemToDelete) #no need to select already selected, then removing self.view.treeView_3.removeSelected() #putting the copied item in view parentIndex = idx.parent().parent().parent() sample = self.currentSample[3]#self.model.sample(parentIndex.data().toString(), #fullNameEntry=False) if sample is None: print "Unknown error" return data = map(str, item.text().split('/'))[:2] dataParent = map(str, idx.parent().parent().data().toString().split('/')) sample.mappedPeaks.sample=sample; sample.rawPeaks.sample=sample#du to one bug don't know why goodPeak = sample.mappedPeaks.peakAt(*map(float, dataParent)) fragPeak = sample.rawPeaks.peakAt(*map(float, data)) try: goodPeak.fragCluster.remove(fragPeak) goodPeak.isoCluster.remove(fragPeak) except ValueError: pass #adding item to the treeView parentItem = model.itemFromIndex(parentIndex) index = bisect_left(sample.mappedPeaks.masses(), float(item.text().split('/')[0])) #model.insertRow(index, item) parentItem.insertRow(index, item) self.view.treeView_3.update()
def initialize_buckets_table(self): self.storj_engine = StorjEngine() # init StorjEngine logger.info("resolving buckets") model = QStandardItemModel(1, 1) # initialize model for inserting to table model.setHorizontalHeaderLabels(['Name', 'Storage', 'Transfer', 'ID']) i = 0 try: for bucket in self.storj_engine.storj_client.bucket_list(): item = QStandardItem(bucket.name) model.setItem(i, 0, item) # row, column, item (QStandardItem) item = QStandardItem(str(bucket.storage)) model.setItem(i, 1, item) # row, column, item (QStandardItem) item = QStandardItem(str(bucket.transfer)) model.setItem(i, 2, item) # row, column, item (QStandardItem) item = QStandardItem(bucket.id) model.setItem(i, 3, item) # row, column, item (QStandardItem) i = i + 1 except sjexc.StorjBridgeApiError as e: QtGui.QMessageBox.about( self, 'Unhandled bucket resolving exception', 'Exception: %s' % e) self.bucket_manager_ui.total_buckets_label.setText(str(i)) # set label of user buckets number self.bucket_manager_ui.bucket_list_tableview.setModel(model) self.bucket_manager_ui.bucket_list_tableview.horizontalHeader().setResizeMode(QtGui.QHeaderView.Stretch)
def on_add_image(self): image_path = QFileDialog.getOpenFileName( self, 'Select image', filter='Images (*.png *.jpg *.bmp)') ignored, name = os.path.split(unicode(image_path)) self.image_model.appendRow( [QStandardItem(name), QStandardItem(image_path)])
def populateForms(self): row = 0 for form in getForms(): formitem = QStandardItem(form) formitem.setCheckable(True) self.formmodel.insertRow(row, formitem) row += 1
def restore(self): try: address = os.path.join(os.path.dirname(__file__), 'EXPDATA', 'All.txt') self.address = address file1 = open(address, 'r+') except: address = os.path.join(os.path.dirname(__file__), 'Mineral_Physics', 'EXPDATA', 'All.txt') self.address = address file1 = open(address, 'r') next(file1) for i, line in enumerate(file1): line = line.split() newItem = QStandardItem(self.Solidsolution[i].name) self.model.setItem(i, 0, newItem) for col in range(len(line)): try: string = "{:5.2f}".format(line[col]) except: string = line[col] item = QStandardItem(string) self.model.setItem(i, col, item) file1.close() self.update_data()
def update_tree_view(self): sis = self.tree_view.header().sortIndicatorSection() sio = self.tree_view.header().sortIndicatorOrder() self.tree_view_model.clear() for info in infos.get_brick_infos(): if info.connected_uid != '0': position_prefix = info.connected_uid else: position_prefix = info.uid position_item = QStandardItem(info.position.upper()) position_item.setData(position_prefix + ':' + info.position.upper(), USER_ROLE_POSITION) parent = [QStandardItem(info.name), QStandardItem(info.uid), position_item, QStandardItem('.'.join(map(str, info.firmware_version_installed)))] for item in parent: item.setFlags(item.flags() & ~Qt.ItemIsEditable) self.tree_view_model.appendRow(parent) for port in sorted(info.bricklets): if info.bricklets[port] and info.bricklets[port].protocol_version == 2: child = [QStandardItem(info.bricklets[port].name), QStandardItem(info.bricklets[port].uid), QStandardItem(info.bricklets[port].position.upper()), QStandardItem('.'.join(map(str, info.bricklets[port].firmware_version_installed)))] for item in child: item.setFlags(item.flags() & ~Qt.ItemIsEditable) parent[0].appendRow(child) if info.can_have_extension: extensions = [] if info.extensions['ext0'] != None: extensions.append((info.extensions['ext0'], 'Ext0')) if info.extensions['ext1'] != None: extensions.append((info.extensions['ext1'], 'Ext1')) for extension in extensions: if extension[0].firmware_version_installed != (0, 0, 0): fw_version = '.'.join(map(str, extension[0].firmware_version_installed)) else: fw_version = '' child = [QStandardItem(extension[0].name), QStandardItem(''), QStandardItem(extension[1]), QStandardItem(fw_version)] for item in child: item.setFlags(item.flags() & ~Qt.ItemIsEditable) parent[0].appendRow(child) self.set_tree_view_defaults() self.tree_view.header().setSortIndicator(sis, sio) self.update_advanced_window() self.delayed_refresh_updates_timer.start()
def addItemToStore(self, name, category=None, icon=None): newItem = QStandardItem(name) if icon: newItem.setIcon(icon) if category: newItem.setData(category) self.__modelStore.appendRow(newItem)
def __display_table_rslt(self, table_rows): ''' controls table_comp_rslt widget fill the widget with table_rows list @param table_rows: [] ''' rows_count = len(table_rows) model = QStandardItemModel(rows_count, 3) model.setHorizontalHeaderLabels(TAB_LABELS) # fill model with data for row in range(rows_count): for col in range(3): item = QStandardItem() item.setData(str(table_rows[row][col]), Qt.DisplayRole) model.setItem(row, col, item) # self.table_comp_rslt.clearContents() if self.table_comp_rslt.isSortingEnabled(): self.table_comp_rslt.setSortingEnabled(False) proxy = numsort.NumberSortModel() proxy.setSourceModel(model) self.table_comp_rslt.setModel(proxy) self.table_comp_rslt.resizeColumnsToContents() self.table_comp_rslt.setSortingEnabled(True)
def __init__(self, __parent = None, event=False, fm = False): """ Model constructor. Create the default QStandardItem's for the default nodes. """ QStandardItemModel.__init__(self, __parent) EventHandler.__init__(self) self.__parent = __parent self.VFS = VFS.Get() self.ch = False # init translation self.translation() # creating qstandarditem for the default nodes (the four displayed nodes when dff is launched) self.root_item = self.invisibleRootItem() tmp = self.VFS.GetNode("/").children() item_list = [] for i in tmp: node_item = QStandardItem(i.name()) node_item.setData(QVariant(long(i.this)), Qt.UserRole + 1) node_item.setData(QVariant(False), Qt.UserRole + 2) item_list.append(node_item) if len(item_list): self.root_item.appendRows(item_list) if event: self.VFS.connection(self)
def setupChecklist(widget, names, checks = None): tp = type(widget) # Prepare checks if checks is None: checks = [] for name in names: checks.append(Qt.Unchecked) else: newChecks = [] for check in checks: if check: newChecks.append(Qt.Checked) else: newChecks.append(Qt.Unchecked) checks = newChecks ## QListView if tp is QListView: model = QStandardItemModel() for i in xrange(len(names)): item = QStandardItem(names[i]) item.setCheckable(True) item.setCheckState(checks[i]) model.appendRow(item) widget.setModel(model) ## QListWidget elif tp is QListWidget: for i in xrange(len(names)): item = QListWidgetItem(names[i]) item.setFlags(Qt.ItemFlags(48)) # 48 = checkable(16), enabled(32) item.setCheckState(checks[i]) widget.addItem(item) ## NOT SUPPORTED else: raise TypeError('Class ' + str(tp) + ' is not supported.')
def populateProjects(self): row = 0 for project in getProjects(): projectitem = QStandardItem(project.name) projectitem.setCheckable(True) self.projectsmodel.insertRow(row, projectitem) row += 1
def __init__(self, name=None, description=None, thumbnail=None, icon=None, path=None): QStandardItem.__init__(self) self.__name = "" if name is None: name = "Untitled" self.setName(name) if description is None: description = "No description." self.setDescription(description) if thumbnail is None: thumbnail = UNKNOWN_SVG self.setThumbnail(thumbnail) if icon is not None: self.setIcon(icon) if path is not None: self.setPath(path)
def make_row(self, state, title): item = QStandardItem(title) if title else QStandardItem() item.setFlags( Qt.ItemIsUserCheckable | Qt.ItemIsTristate | Qt.ItemIsEnabled | Qt.ItemIsEditable) item.setData(self.state_to_check_state(state), Qt.CheckStateRole) return [item]
def add_category(self): text, ok = QInputDialog.getText(self, 'Create new category', 'Category name:') if ok: catItem = QStandardItem(text) catItem.setCheckable(True) self.model.appendRow(catItem)
def fillScalars(self): scalars = [ 'absorbance (%)', 'reflectance (%)', 'transmittance (%)', 'absorbance (mA/cm²)', 'reflectance (mA/cm²)', 'transmittance (mA/cm²)', 'generation', 'Jmax (mA/cm²)', 'absorption layerwise (%)', 'absorption layerwise (mA/cm²)', 'collection layerwise (%)', 'collection layerwise (mA/cm²)', 'calc. time (s)' ] self.scalarListModel = QStandardItemModel() scalarsToShow = self.defaults['defaultScalars'] for value in scalars: item = QStandardItem(value) check = Qt.Checked if value in scalarsToShow else Qt.Unchecked item.setCheckState(check) item.setCheckable(True) self.scalarListModel.appendRow(item) self.scalarListView.setModel(self.scalarListModel)
def create_last_modified_item(last_modified): item = QStandardItem( QDateTime.fromTime_t(last_modified).toString( 'yyyy-MM-dd HH:mm:ss')) item.setData(last_modified, USER_ROLE_LAST_MODIFIED) return item
def calcALT(self): thrAlt = Unit.ConvertFeetToMeter(self.data["ThrAltitude"]) rdhAlt = Unit.ConvertFeetToMeter(self.data["RDHAltitude"]) gradient = self.data["DescentGradient"] dx = self.data["dX"] for i in range(7): item = self.stdModel.item(1, self.data["CatOfAcftCount"][0] + 5 + i) val = 0.0 try: val = float(item.text()) except: continue dist = val * 1852 valueHgt = Unit.ConvertFeetToMeter( (dist - dx) * math.tan(Unit.ConvertDegToRad(gradient))) valueAlt = valueHgt + thrAlt + rdhAlt if valueAlt > int(valueAlt): valueAlt = int(valueAlt) + 1 if valueHgt > int(valueHgt): valueHgt = int(valueHgt) + 1 itemTemp = QStandardItem( str(valueAlt) + "\n(" + str(valueHgt) + ")") itemTemp.setTextAlignment(Qt.AlignCenter) self.stdModel.setItem(2, self.data["CatOfAcftCount"][0] + 5 + i, itemTemp)
def sum_item(value): item = QStandardItem() item.setData(value, Qt.DisplayRole) item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter) item.setFlags(Qt.ItemIsEnabled) item.setFont(bold_font) return item
def __addFirstRowToModel(self, oldModel, newRow): """ :type oldModel: QAbstractItemModel :type newRow: list :return: QStandardItemModel """ model = QStandardItemModel(self) items = [] for str in newRow: items.append(QStandardItem(str)) model.appendRow(items) for i in xrange(oldModel.rowCount()): items = [] for j in xrange(oldModel.columnCount()): index = QModelIndex(oldModel.index(i, j)) data = oldModel.data(index) item = QStandardItem(data) items.append(item) model.appendRow(items) return model
def _append_to_standard_item(self, item, checklist): if checklist is not None: for child_checklist in checklist: childitem = QStandardItem(child_checklist.name) childitem.setFlags( Qt.ItemIsEnabled ) item.appendRow([childitem]) self._append_to_standard_item(childitem, child_checklist.children)
def _guiUpdate_table(self,uuid): "" self.dbconn=DbConn() # self.uuid=self.dbconn.get_uuid() uuid='' self.meta=self.dbconn.get_meta_kv()[uuid] keys=self.meta.keys() model=QStandardItemModel() model.setHorizontalHeaderItem(0,QStandardItem("Attribute")) model.setHorizontalHeaderItem(1,QStandardItem("Value")) for k in keys: name=self.meta[k]['Attribute'] item1 = QStandardItem(k) item2 = QStandardItem(name) item1.setCheckable(True) model.appendRow([item1,item2]) # model.itemChanged.connect(lambda: on_item_changed()) self.model=model self.ui.metaeditor.setModel(model) self.ui.metaeditor.setEditTriggers(QAbstractItemView.NoEditTriggers) self.ui.metaeditor.sortByColumn(1) self.ui.metaeditor.resizeColumnsToContents()
def rowFromData(self, data): row = [] for c in data: item = QStandardItem(unicode(c)) item.setFlags( (item.flags() | Qt.ItemIsEditable) if self.editable else (item.flags() & ~Qt.ItemIsEditable) ) row.append( item ) return row
def populate_neo_unit_list(self): """ Fill the unit list with appropriate entries. Qt.UserRole: The :class:`neo.Unit` object """ self.unit_model.clear() units = [] for rcg in self.recording_channel_groups(): units.extend(rcg.units) filters = self.parent.get_active_filters('Unit') units = self.filter_ordered(units, filters) for i, u in enumerate(units): if self.parent.is_filtered(u, filters): continue if u.name: name = u.name + ' (%s-%d)' % \ (self.parent.channel_group_names[rcg], i) else: name = '%s-%d' % (self.parent.channel_group_names[rcg], i) new_item = QStandardItem(name) new_item.setData(u, Qt.UserRole) self.unit_model.appendRow(new_item) if api.config.autoselect_units: self.neoUnitList.selectAll() self.selected_units_changed()
def append_row(self): """ Add a blank row after the last item in the view. """ items = [QStandardItem(), QStandardItem()] self._pair_model.appendRow(items)
def populate_neo_segment_list(self): """ Fill the segment list with appropriate entries. Qt.UserRole: The :class:`neo.Segment` object """ self.segment_model.clear() segments = [] for b in self.blocks(): segments.extend(b.segments) filters = self.parent.get_active_filters('Segment') segments = self.filter_ordered(segments, filters) for i, s in enumerate(segments): if s.name: name = s.name + ' (%s-%i)' % \ (self.parent.block_ids[s.block], i) else: name = '%s-%i' % (self.parent.block_ids[s.block], i) new_item = QStandardItem(name) new_item.setData(s, Qt.UserRole) self.segment_model.appendRow(new_item) self.neoSegmentList.setCurrentIndex(self.segment_model.index(0, 0)) if api.config.autoselect_segments: self.neoSegmentList.selectAll() self.selected_segments_changed()
def populate_neo_channel_group_list(self): """ Fill the channel group list with appropriate entries. Qt.UserRole: The :class:`neo.RecordingChannelGroup` object """ self.neoChannelGroupList.clearSelection() self.channelgroup_model.clear() self.parent.channel_group_names.clear() rcgs = [] for b in self.blocks(): rcgs.extend(b.recordingchannelgroups) filters = self.parent.get_active_filters( 'Recording Channel Group') rcgs = self.filter_ordered(rcgs, filters) for i, rcg in enumerate(rcgs): self.parent.channel_group_names[rcg] = '%s-%s' % ( self.parent.block_ids[rcg.block], self.get_letter_id(i, True)) if rcg.name: name = rcg.name + ' (%s)' % \ self.parent.channel_group_names[rcg] else: name = self.parent.channel_group_names[rcg] new_item = QStandardItem(name) new_item.setData(rcg, Qt.UserRole) self.channelgroup_model.appendRow(new_item) self.neoChannelGroupList.setCurrentIndex( self.channelgroup_model.index(0, 0)) if api.config.autoselect_channel_groups: self.neoChannelGroupList.selectAll() elif not rcgs: self.selected_channel_groups_changed()
def insert_row(self): """ Inser single row into QStandardItemModel """ standard_model = self.tbl_relation.model() feature_id = utils_giswater.getWidgetText(self.dlg_lot, self.dlg_lot.feature_id) lot_id = utils_giswater.getWidgetText(self.dlg_lot, self.lot_id) layer_name = 'v_edit_' + utils_giswater.get_item_data( self.dlg_lot, self.dlg_lot.feature_type, 0).lower() field_id = utils_giswater.get_item_data( self.dlg_lot, self.dlg_lot.feature_type, 0).lower() + str('_id') layer = self.controller.get_layer_by_tablename(layer_name) feature = self.get_feature_by_id(layer, feature_id, field_id) if feature is False: return if feature_id not in self.ids: item = [lot_id, feature_id, feature.attribute('code'), 0] row = [] for value in item: if value not in ('', None) and type(value) != QPyNullVariant: row.append(QStandardItem(str(value))) else: row.append(QStandardItem(None)) if len(row) > 0: standard_model.appendRow(row) self.ids.append(feature_id) self.insert_single_checkbox(self.tbl_relation)
def setModel(self): from gui.MetBaseGui import MSStandardItem #we assume that the different peaks have the same identifiers #TODO: may have to merge several stuffs later if self.choosenOne.formulas: self.identificationModel.setHorizontalHeaderLabels( ["score", "formula", "diff mass", "names"]) for i, f in enumerate(self.choosenOne.formulas.iterkeys()): self.identificationModel.setItem( i, 0, MSStandardItem(str(self.choosenOne.formulas[f]["score"]))) self.identificationModel.setItem(i, 1, QStandardItem(str(f))) self.identificationModel.setItem( i, 2, MSStandardItem(str( self.choosenOne.formulas[f]["diffmass"]))) self.identificationModel.setItem( i, 3, QStandardItem(self.choosenOne.formulas[f]["names"])) if self.choosenOne.formulas[f]["names"] != 'Not Found': for j in xrange(4): self.identificationModel.item(i, j).setBackground( QBrush(Qt.green)) else: for j in xrange(4): self.identificationModel.item(i, j).setBackground( QBrush(Qt.red)) self.tableView.setModel(self.identificationModel)
def initTable(self): self.model.clear() # header = QHeaderView(Qt.Horizontal) # headerModel = QStandardItemModel() layer = self.baseLayer fields = layer.pendingFields() headersList = ["fid"] for field in fields: headersList.append(field.name()) self.model.setHorizontalHeaderLabels(headersList) # headerModel.setHorizontalHeaderLabels(headersList) # header.setModel(headerModel) # self.attributeTable.setHorizontalHeader(header) if len(layer.selectedFeatures()) > 0: features = layer.selectedFeatures() else: features = layer.getFeatures() for feature in features: record = [QStandardItem(str(feature.id()))] for field in feature.fields(): name = field.name() attribute = feature.attribute(name).toString() stdItemValue = QStandardItem(attribute) stdItemValue.setEditable(False) record.append(stdItemValue) self.model.appendRow(record)
def __init__(self, name, proc=None, path=None): QStandardItem.__init__(self, name) self.proc = proc self.path = path self.hive = None self.children = 0 self.expanded = False self.root = False
def _processDB(self, db, parent, dbf): """process the database and add its child nodes""" for k, v in db.items(): item = QStandardItem(k) item.setIcon(self.icons["project"]) item.setData(QVariant("P|%s|%s" % (dbf, v.path))) parent.appendRow(item) self._processProject(v, item, dbf)
def mkitem(self, d): """ dict with field->value """ si = QStandardItem() for k, v in d.items(): rid = self.roleids[k] si.setData(v, rid) return si
def _processProject(self, pr, parent, dbf): """process the project and add its child nodes""" for k, v in pr.items(): item = QStandardItem(k) item.setIcon(self.icons['sensorgroup']) item.setData(QVariant("G|%s|%s" % (dbf, v.path))) parent.appendRow(item) self._processSensorGroup(v, item, dbf)
def addRow(self, song): attribs = song.getFormatedValues(self.playlistOrder) nodes = [QStandardItem('')] nodes[-1].setData(song) for i in attribs: nodes.append(QStandardItem(i)) nodes[-1].setData(song) self.model().appendRow(nodes)
def mkitem(self, d): """ dict with field->value """ si = QStandardItem() for k,v in d.items(): rid = self.roleids[k] si.setData(v, rid) return si
def populateClients(self): row = 0 for client, settings in self.config['clients'].iteritems(): name = QStandardItem(client) name.setData(settings) path = QStandardItem(settings['path']) self.model.insertRow(row, [name, path]) row += 1
def addSensorgroup(self, project_mi, sg): """show a newly created or updated sensorgroup""" dbf = self.dsFolder(project_mi) item = QStandardItem(sg.name) item.setIcon(self.icons["sensorgroup"]) item.setData(QVariant("G|%s|%s" % (dbf, sg.path))) self.itemFromIndex(project_mi).appendRow(item) self._processSensorGroup(sg, item, dbf)
def row_for_state(self, score, state): items = [] attrs = sorted((self.attrs[x] for x in state), key=attrgetter("name")) for attr in attrs: item = QStandardItem(attr.name) item.setData(attr, self._AttrRole) items.append(item) return items
def __init__(self, path, display, contents=None): QStandardItem.__init__(self, display) self.setEditable(False) self.setData(QVariant(path)) self.path = path self.isClass = isinstance(contents, Class) self.isFunction = isinstance(contents, Function) self.setIcon(self.selectIcon())
def populate_sync_path_model(self, folder_paths): self.sync_path_model.clear() for folder_path in folder_paths: item = QStandardItem(folder_path) item.setEditable(False) if folder_path == "Connect to DropBox first": item.setTextAlignment(Qt.AlignCenter) self.sync_path_model.appendRow(item)
def addParentItem(self, category): item = QStandardItem(category) item.setFlags(item.flags() & ~(Qt.ItemIsEnabled | Qt.ItemIsSelectable)) item.setData("parent", Qt.AccessibleDescriptionRole) font = item.font() font.setBold(True) item.setFont(font) self.model().appendRow(item)
def loadFile(self): file = str(QtGui.QFileDialog.getOpenFileName(self, "Open csv file")) reader=csv.reader(open(file, 'rb'), delimiter=',') model=QtGui.QStandardItemModel() for i, r in enumerate(reader[1:]): model.setItem(i, 0, QStandardItem(r[0])) model.setItem(i, 1, QStandardItem(r[1])) self.tableView.setModel(model)
def add_parent_tree(self, icon, title): roots = OrderedDict() for feature_id in self.selected_features(): root = QStandardItem(icon, title) root.setData(feature_id) self.set_bold(root) self.model.appendRow(root) roots[feature_id] = root return roots
def generateLeftListLogModel(self): '''Returns log model using all logs in self._logs ''' model = QStandardItemModel(self._dataListToListWidget.leftDataTypeListView) for log in self._logs: item = QStandardItem(log.name) # checkboxes are confusing item.setCheckable(False) model.appendRow(item) return model