def new_item(self, cat, name, desc='', misc=None, sort=None, userdata=None): """Add a new item to a category. Args: cat: The parent category. name: The name of the item. desc: The description of the item. misc: Misc text to display. sort: Data for the sort role (int). userdata: User data to be added for the first column. Return: A (nameitem, descitem, miscitem) tuple. """ assert not isinstance(name, int) assert not isinstance(desc, int) assert not isinstance(misc, int) nameitem = QStandardItem(name) descitem = QStandardItem(desc) if misc is None: miscitem = QStandardItem() else: miscitem = QStandardItem(misc) cat.appendRow([nameitem, descitem, miscitem]) if sort is not None: nameitem.setData(sort, Role.sort) if userdata is not None: nameitem.setData(userdata, Role.userdata) return nameitem, descitem, miscitem
def __init__(self, database, main_spectrum = None): super(ReferenceSpectraDialog, self).__init__() self.main_spectrum = main_spectrum self.ui = Ui_ReferenceSpectraDialog() self.ui.setupUi(self) self.reference_catalogues = ReferenceCatalogues(database) self.full_model = QStandardItemModel() self.catalogues_model = QStandardItemModel() self.ui.catalogue.setModel(self.catalogues_model) self.ui.catalogue.currentTextChanged.connect(lambda txt: self.populate()) for catname, cat in self.reference_catalogues.catalogues.items(): row = QStandardItem(catname) row.setData(cat) self.catalogues_model.appendRow(row) self.model = QSortFilterProxyModel() self.model.setSourceModel(self.full_model) self.model.setFilterCaseSensitivity(Qt.CaseInsensitive) self.model.setFilterKeyColumn(0) self.ui.entries.setModel(self.model) self.ui.type_filter.currentTextChanged.connect(lambda txt: self.model.setFilterWildcard("{}*".format(txt) ) ) self.ui.buttonBox.button(QDialogButtonBox.Open).setEnabled(False) self.ui.entries.selectionModel().selectionChanged.connect(lambda selected, deselected: self.ui.buttonBox.button(QDialogButtonBox.Open).setEnabled(len(selected.indexes()) > 0) ) self.accepted.connect(self.load_fits) self.populate()
def test_completion_item_next_prev(tree, count, expected, completionview): """Test that on_next_prev_item moves the selection properly. Args: tree: Each list represents a completion category, with each string being an item under that category. count: Number of times to go forward (or back if negative). expected: item data that should be selected after going back/forward. """ model = base.BaseCompletionModel() for catdata in tree: cat = QStandardItem() model.appendRow(cat) for name in catdata: cat.appendRow(QStandardItem(name)) filtermodel = sortfilter.CompletionFilterModel(model, parent=completionview) completionview.set_model(filtermodel) if count < 0: for _ in range(-count): completionview.completion_item_prev() else: for _ in range(count): completionview.completion_item_next() idx = completionview.selectionModel().currentIndex() assert filtermodel.data(idx) == expected
def test_completion_show(show, rows, quick_complete, completionview, config_stub): """Test that the completion widget is shown at appropriate times. Args: show: The completion show config setting. rows: Each entry represents a completion category with only one item. quick_complete: The completion quick-complete config setting. """ config_stub.data['completion']['show'] = show config_stub.data['completion']['quick-complete'] = quick_complete model = base.BaseCompletionModel() for name in rows: cat = QStandardItem() model.appendRow(cat) cat.appendRow(QStandardItem(name)) filtermodel = sortfilter.CompletionFilterModel(model, parent=completionview) assert not completionview.isVisible() completionview.set_model(filtermodel) assert completionview.isVisible() == (show == 'always' and len(rows) > 0) completionview.completion_item_focus('next') expected = (show != 'never' and len(rows) > 0 and not (quick_complete and len(rows) == 1)) assert completionview.isVisible() == expected completionview.set_model(None) completionview.completion_item_focus('next') assert not completionview.isVisible()
def __init__(self, parent=None): super(UniverseTreeView, self).__init__(parent) model = QStandardItemModel() self.setModel(model) root_item = model.invisibleRootItem() self.areas_item = QStandardItem("Areas") self.areas_item.setData(Areas, Qt.UserRole) self.areas_item.setEditable(False) root_item.appendRow(self.areas_item) Areas.added.connect(self.init_areas) Areas.removed.connect(self.init_areas) Areas.reset.connect(self.init_areas) self.characters_item = QStandardItem("Characters") self.characters_item.setData(Characters, Qt.UserRole) self.characters_item.setEditable(False) root_item.appendRow(self.characters_item) Characters.added.connect(self.init_characters) Characters.removed.connect(self.init_characters) Characters.reset.connect(self.init_characters) self.races_item = QStandardItem("Races") self.races_item.setEditable(False) self.races_item.setData(Races, Qt.UserRole) root_item.appendRow(self.races_item) Races.added.connect(self.init_races) Races.removed.connect(self.init_races) Races.reset.connect(self.init_races) self.item_prototypes_item = QStandardItem("Item Prototypes") self.item_prototypes_item.setData(ItemPrototypes, Qt.UserRole) self.item_prototypes_item.setEditable(False) root_item.appendRow(self.item_prototypes_item) ItemPrototypes.added.connect(self.init_item_prototypes) ItemPrototypes.removed.connect(self.init_item_prototypes) ItemPrototypes.reset.connect(self.init_item_prototypes) self.groups_item = QStandardItem("Groups") self.groups_item.setData(Groups, Qt.UserRole) self.groups_item.setEditable(False) root_item.appendRow(self.groups_item) Groups.added.connect(self.init_groups) Groups.removed.connect(self.init_groups) Groups.reset.connect(self.init_groups) self.init_all() self.activated.connect(self.item_activated)
def initUi(self, options, enabledOptions, headerOptions, singleSelectionMode): boldFont = QFont() boldFont.setBold(True) # set the selection mode if not singleSelectionMode: self.listView_options.setSelectionMode(QAbstractItemView.ExtendedSelection) # create enableItems if none if enabledOptions is None: enabledOptions = [True for idx in range(len(options))] # Insert the choices self.standaredItemModel = QStandardItemModel(self.listView_options) self.standaredItemModel.itemChanged.connect(self.onItemChanged) for idx in range(len(options)): standaredItem = QStandardItem(options[idx]) standaredItem.setSelectable(enabledOptions[idx]) if idx in headerOptions: standaredItem.setFont(boldFont) self.standaredItemModel.appendRow(standaredItem) self.listView_options.setModel(self.standaredItemModel) # disable select all / de select all buttons if in single selection # mode if singleSelectionMode: self.pushButton_sellectAll.setDisabled(True) self.pushButton_deSellectAll.setDisabled(True)
def test_completion_item_focus(which, tree, expected, completionview, qtbot): """Test that on_next_prev_item moves the selection properly. Args: which: the direction in which to move the selection. tree: Each list represents a completion category, with each string being an item under that category. expected: expected argument from on_selection_changed for each successive movement. None implies no signal should be emitted. """ model = base.BaseCompletionModel() for catdata in tree: cat = QStandardItem() model.appendRow(cat) for name in catdata: cat.appendRow(QStandardItem(name)) filtermodel = sortfilter.CompletionFilterModel(model, parent=completionview) completionview.set_model(filtermodel) for entry in expected: if entry is None: with qtbot.assertNotEmitted(completionview.selection_changed): completionview.completion_item_focus(which) else: with qtbot.waitSignal(completionview.selection_changed) as sig: completionview.completion_item_focus(which) assert sig.args == [entry]
def populate(self): self.model.clear() self.model.setHorizontalHeaderLabels(['Lambda', 'Element', 'Atomic number', 'Ionization', 'Stellar spectral types']) c = self.database.cursor() query = "SELECT lambda, Element, Z, Ion, SpTypes from spectral_lines WHERE {} ORDER BY lambda ASC;" conditions = ['(1 = 1)'] element = self.elements_model.item(self.ui.elements.currentIndex()).data() if element['z']: conditions.append("(Z = {})".format(element['z'])) if self.ui.lambda_from.value() > 0: conditions.append("(Lambda >= {})".format(self.ui.lambda_from.value())) if self.ui.lambda_to.value() > 0: conditions.append("(Lambda <= {})".format(self.ui.lambda_to.value())) if self.ui.name.text(): conditions.append("(Element like '%{}%')".format(self.ui.name.text())) if self.ui.sp_types.isChecked(): conditions.append("(SpTypes <> '')") for row in c.execute(query.format(" AND ".join(conditions))): first_item = QStandardItem("{}".format(row[0])) first_item.setData({'lambda': row[0], 'name': row[1], 'z': row[2]}) self.model.appendRow( [ first_item, QStandardItem(row[1]), QStandardItem("{}".format(row[2])), QStandardItem("{}".format(row[3])), QStandardItem(row[4]) ])
def addPoint(self): rows = self._current.editor.selectedRows() newStart = self._videoWidget.position if len(rows) == 0 or newStart is None: self._err.showMessage(_("Select a subtitle and position in current video first.")) return # row and sub reflect the same subtitle, but we need both for different things row = rows[0] sub = self._current.data.subtitles[row] # Don't add the same subtitle or the same sync time twice if any(row == point.subNo or newStart == point.start for point in _syncPoints(self._current.model)): self._err.showMessage(_("Can't repeat synchronization points")) return if sub.fps != newStart.fps: self._err.showMessage(_("Subtitle and video have different framerates (%(sub)s vs" "%(vid)s") % dict(sub=sub.fps, vid=newStart.fps)) return delta = sub.end - sub.start newEnd = newStart + delta startItem, endItem, textItem = createRow(sub, newStart, newEnd) subNoItem = QStandardItem(str(row)) subNoItem.setEditable(False) textItem.setEditable(False) rmItem = QStandardItem("") self._current.model.appendRow([subNoItem, startItem, endItem, textItem, rmItem]) self._rmButton(self._table, rmItem)
def __connect_events(self): self.model = QStandardItemModel() self.mass_list = [] for i in range(10): mass = 184 + i self.mass_list.append(str(mass)) for i in range(10): mass = 209 + i self.mass_list.append(str(mass)) for i in range(10): mass = 273.3 + i self.mass_list.append(str(mass)) for i in range(10): mass = 294 + i self.mass_list.append(str(mass)) for mass in self.mass_list: item = QStandardItem(mass) item.setCheckable(True) item.setEditable(True) self.model.appendRow(item) self.view = self.ui.listView_Mass self.view.setModel(self.model) # changes in one item, don't know which one self.model.itemChanged.connect(self.change_list) # changes in button self.ui.pushButton_ChangeList.clicked.connect(self.emit_list_signal) # get peaks found and update automatically the mass list self.ana.masstabSelectorRaisedSignal.connect(self.update_list_view)
def fillReferences(self): for value in self.referenceList: item = QStandardItem(value[0]) check = Qt.Checked if value[1] else Qt.Unchecked item.setCheckState(check) item.setCheckable(True) self.referenceListModel.appendRow(item)
def current_to_recent(self): track = self.player.get_item() if track is not "": item = QStandardItem(track) track_meta = self.meta_info(track) item.setText(track_meta) item.setData(track, 1) self.recentTrackListModel.insertRow(0, item)
def setModelData(self, items, checkedItems): self.clear() for item in items: modelItem = QStandardItem(item) if item in checkedItems: modelItem.setCheckState(Qt.Checked) else: modelItem.setCheckState(Qt.Unchecked) self.appendRow(modelItem)
def set_server_mgr(self, server_mgr): self.server_mgr = server_mgr self.nodesets = [] self.model.clear() self.model.setHorizontalHeaderLabels(['Node Sets']) item = QStandardItem("Opc.Ua.NodeSet2.xml") item.setFlags(Qt.NoItemFlags) self.model.appendRow([item]) self.view.expandAll()
def addItems(self, parent, elements): for k in sorted(elements.keys()): item = QStandardItem(k) parent.appendRow(item) if type(elements[k]) == dict: self.addItems(item, elements[k]) else: child = QStandardItem(str(elements[k])) item.appendRow(child)
def init(self): model = self.model() model.clear() root_item = model.invisibleRootItem() for t in weapon_types: item = QStandardItem(t.title()) item.setData(t, Qt.UserRole) root_item.appendRow(item)
def __init__(self,xpos=0.0,ypos=0.0,zpos=0.0): QStandardItem.__init__(self,"X: "+str(xpos)+" Y: "+str(ypos)+" Z: "+str(zpos)) try: self.x=float(xpos) self.y=float(ypos) self.z=float(zpos) except ValueError: #raise raise ValueError("could not set point values")
def fresh(self): confFile=open("conf","r") self.listModel=QStandardItemModel() self.itemList=cPickle.load(confFile) confFile.close() for item in self.itemList: itemView=QStandardItem(QIcon(item.path),item.name) itemView.setEditable(False) self.listModel.appendRow(itemView) self.listview.setModel(self.listModel)
def _set_items(self, item, data): item.setRowCount(0) subitems = [] for d in sorted(data, key=lambda r: r.name.lower()): subitem = QStandardItem(d.name) subitem.setEditable(False) subitem.setData(d, Qt.UserRole) subitems.append(subitem) item.appendRows(subitems)
def _show_list(self, parent, mylist, vtype): for idx, val in enumerate(mylist): name_item = QStandardItem(str(idx)) vitem = QStandardItem() vitem.setText(val_to_string(val)) vitem.setData(ListData(mylist, idx, val, vtype), Qt.UserRole) row = [name_item, vitem, QStandardItem(vtype.name)] parent.appendRow(row) if vtype == ua.VariantType.ExtensionObject: self._show_ext_obj(name_item, val)
def init(self): print("SelectRaceComboBox.init") model = self.model() model.clear() root_item = model.invisibleRootItem() for race in Races: item = QStandardItem(race.name) item.setData(race, Qt.UserRole) root_item.appendRow(item)
def build_row(result): preview = QStandardItem(str(result.data)) preview.setEditable(False) preview.result = result return [ QStandardItem(result.manifest.label), QStandardItem(result.manifest._size), QStandardItem(result.manifest.type()), preview, ]
def colorize(self, excelModel, prologModel): for row in range(prologModel.rowCount()): if str(excelModel.data(excelModel.index(row, 0))).lower() == "none": if "_lab" in str(prologModel.data(prologModel.index(row, 1))).lower() or "lab_" in str(prologModel.data(prologModel.index(row, 2))).lower(): pass else: for column in range(prologModel.columnCount()): if str(prologModel.data(prologModel.index(row, column))).lower() != str(excelModel.data(excelModel.index(row, column))).lower(): toAdd = QStandardItem(str(prologModel.data(prologModel.index(row, column)))) toAdd.setBackground(QBrush(QColor(255, 155, 55, 200))) prologModel.setItem(row, column, toAdd) elif str(prologModel.data(prologModel.index(row, 2))).lower() not in str(excelModel.data(excelModel.index(row, 1))).lower(): #confronto docente toAdd = QStandardItem(str(prologModel.data(prologModel.index(row, 2)))) toAdd.setBackground(QBrush(QColor(255, 0, 0, 100))) prologModel.setItem(row, 2, toAdd) elif str(excelModel.data(excelModel.index(row, 4))).lower() != str(prologModel.data(prologModel.index(row, 5))).lower(): #confronto ore toAdd = QStandardItem(str(prologModel.data(prologModel.index(row, 5)))) toAdd.setBackground(QBrush(QColor(255, 0, 0, 100))) prologModel.setItem(row, 5, toAdd) """"
def load_projects(self): self.clear() self.setHorizontalHeaderLabels(['Name']) for project in get_projects(): item = QStandardItem(project) item.setEditable(False) self.appendRow(item) self.sort(0)
def AddTag( self, name ): newTag = QStandardItem( name ) newTagQuantity = QItemToSortByNum( "0" ) newTag.setFlags( Qt.ItemIsUserCheckable | Qt.ItemIsEnabled | Qt.ItemIsSelectable ) newTag.setData( QVariant( Qt.Unchecked ), Qt.CheckStateRole ) self.tagDict[ name ] = newTag currentRow = [ newTag, newTagQuantity ] self.tagNameToTagItemsDict[ name ] = currentRow self.tagModel.appendRow( currentRow ) self.tagModel.sort( Qt.AscendingOrder ) self.wereAnyChanges = True
def _createRow(self, sub): timeStart = QStandardItem(sub.start.toStr()) timeEnd = QStandardItem(sub.end.toStr()) text = QStandardItem(sub.text) timeStart.setData(sub.start, CustomDataRoles.FrameTimeRole) timeEnd.setData(sub.end, CustomDataRoles.FrameTimeRole) timeStart.setData(False, CustomDataRoles.ErrorFlagRole) timeEnd.setData(False, CustomDataRoles.ErrorFlagRole) return [timeStart, timeEnd, text]
def fillUserList(newUser=None): model = QStandardItemModel() mylist = ['asd', 'wqe', 'wqra', 'tewt4'] if newUser: mylist += newUser print(mylist) for item in mylist: myitem = QStandardItem(item) myitem.setEditable(0) model.appendRow(myitem) myapp.listView.setModel(model) myapp.listView.doubleClicked.connect(openConversationWindow)
def addTreeEntry(self, parent, name, parameter, func, level = 1): child = QStandardItem(name) child.setCheckable(True) value = QStandardItem(str(parameter)) parent.appendRow([child, value]) if level == 3: osciNum = parent.parent().rowCount() - 2 itemNum = parent.rowCount() - 1 self.parameterList.append([parameter, func, osciNum, itemNum]) else: self.parameterList.append([parameter, func])
def populate(self): self.full_model.clear() catalogue = self.catalogues_model.item(self.ui.catalogue.currentIndex()).data() self.full_model.setHorizontalHeaderLabels(['Spectral Type']) entries = self.reference_catalogues.spectra(catalogue['name']) self.ui.type_filter.clear() self.ui.type_filter.addItem('') self.ui.type_filter.addItems( sorted(set([i['sptype'] for i in entries])) ) for entry in entries: item = QStandardItem(entry['sptype']) item.setData(entry) self.full_model.appendRow(item)
def create_table(self, rela): table = custom_table.Table() model = QStandardItemModel() table.setModel(model) model.setHorizontalHeaderLabels(rela.header) for row_count, row in enumerate(rela.content): for col_count, data in enumerate(row): item = QStandardItem(data) item.setFlags(item.flags() & ~Qt.ItemIsEditable) model.setItem(row_count, col_count, item) return table
def __iniModelFromStringList(self,allLines): ##从字符串列表构建模型 rowCnt=len(allLines) #文本行数,第1行是标题 self.itemModel.setRowCount(rowCnt-1) #实际数据行数 headerText=allLines[0].strip() #第1行是表头,去掉末尾的换行符 "\n" headerList=headerText.split("\t") self.itemModel.setHorizontalHeaderLabels(headerList) self.__lastColumnTitle=headerList[len(headerList)-1] # 最后一列表头的标题,即“测井取样” lastColNo=self.COL_COUNT-1 #最后一列的列号 for i in range(rowCnt-1): lineText=allLines[i+1].strip() #一行的文字,\t分隔 strList=lineText.split("\t") for j in range(self.COL_COUNT-1): #不含最后一列 item=QStandardItem(strList[j]) self.itemModel.setItem(i,j,item) item=QStandardItem(self.__lastColumnTitle) #最后一列 item.setFlags(self.__lastColumnFlags) item.setCheckable(True) if (strList[lastColNo]=="0"): item.setCheckState(Qt.Unchecked) else: item.setCheckState(Qt.Checked) self.itemModel.setItem(i,lastColNo,item) #设置最后一列的item
def add_new_page(self, templateUrl): # check for page list and or location. pagesList = [] if "pages" in self.setupDictionary.keys(): pagesList = self.setupDictionary["pages"] if not "pageNumber" in self.setupDictionary.keys(): self.setupDictionary['pageNumber'] = 0 if (str(self.setupDictionary["pagesLocation"]).isspace()): self.setupDictionary["pagesLocation"] = os.path.relpath( QFileDialog.getExistingDirectory( caption=i18n("Where should the pages go?"), options=QFileDialog.ShowDirsOnly), self.projecturl) # Search for the possible name. extraUnderscore = str() if str(self.setupDictionary["projectName"])[-1].isdigit(): extraUnderscore = "_" self.setupDictionary['pageNumber'] += 1 pageName = str(self.setupDictionary["projectName"]).replace( " ", "_") + extraUnderscore + str( format(self.setupDictionary['pageNumber'], "03d")) url = os.path.join(str(self.setupDictionary["pagesLocation"]), pageName + ".kra") # open the page by opening the template and resaving it, or just opening it. absoluteUrl = os.path.join(self.projecturl, url) if (os.path.exists(absoluteUrl)): newPage = Application.openDocument(absoluteUrl) else: booltemplateExists = os.path.exists( os.path.join(self.projecturl, templateUrl)) if booltemplateExists is False: templateUrl = os.path.relpath( QFileDialog.getOpenFileName( caption=i18n( "Which image should be the basis the new page?"), directory=self.projecturl, filter=str(i18n("Krita files") + "(*.kra)"))[0], self.projecturl) newPage = Application.openDocument( os.path.join(self.projecturl, templateUrl)) newPage.waitForDone() newPage.setFileName(absoluteUrl) newPage.setName(pageName.replace("_", " ")) newPage.save() newPage.waitForDone() # Get out the extra data for the standard item. newPageItem = QStandardItem() newPageItem.setIcon( QIcon(QPixmap.fromImage(newPage.thumbnail(256, 256)))) newPageItem.setDragEnabled(True) newPageItem.setDropEnabled(False) newPageItem.setEditable(False) newPageItem.setText(pageName.replace("_", " ")) newPageItem.setData("", role=CPE.DESCRIPTION) newPageItem.setData(url, role=CPE.URL) newPageItem.setData("", role=CPE.KEYWORDS) newPageItem.setData("", role=CPE.LASTEDIT) newPageItem.setData("", role=CPE.EDITOR) newPageItem.setToolTip(url) # close page document. while os.path.exists(absoluteUrl) is False: qApp.processEvents() self.pagesWatcher.addPath(absoluteUrl) newPage.close() # add item to page. self.pagesModel.appendRow(newPageItem)
def add_module(self, module): _module_name = QStandardItem() _module_name.setText(module) self._ObjCmodule_model.appendRow(_module_name)
def __init__(self, data): QStandardItem.__init__(self) self._logger = logging.getLogger(self.__class__.__name__) self._data = data self._text = self._getText(data)
def addBackends(self, cap=None, entry_all=True, entry_title=False): """ Populate the model by adding backends. Appends backends to the model, without clearing previous entries. For each entry in the model, the cap name is stored under role RoleBackendName and the capability object under role RoleCapability. :param cap: capabilities to add (None to add all loaded caps) :param entry_all: if True, add a "All backends" entry :param entry_title: if True, add a disabled entry with the cap name """ if entry_title: if cap: capname = cap.__name__ else: capname = '(All capabilities)' item = QStandardItem(capname) item.setEnabled(False) self.appendRow(item) first = True for backend in self.weboob.iter_backends(caps=cap): if first and entry_all: item = QStandardItem('(All backends)') item.setData('', self.RoleBackendName) item.setData(cap, self.RoleCapability) self.appendRow(item) first = False item = QStandardItem(backend.name) item.setData(backend.name, self.RoleBackendName) item.setData(cap, self.RoleCapability) minfo = self.weboob.repositories.get_module_info(backend.NAME) icon_path = self.weboob.repositories.get_module_icon_path(minfo) if icon_path: pixmap = QPixmapCache.find(icon_path) if not pixmap: pixmap = QPixmap(QImage(icon_path)) item.setIcon(QIcon(pixmap)) self.appendRow(item)
def _on_class_enumeration_match(self, java_class): _class_name = QStandardItem() _class_name.setText(java_class) self._javaclass_model.appendRow(_class_name)
return True return super().helpEvent(event, view, option, index) class AutoToolTipItemDelegate(AutoToolTipItemDelegateMixin, QItemDelegate): pass if __name__ == "__main__": import sys from PyQt5.QtWidgets import QApplication, QListView from PyQt5.QtGui import QStandardItemModel, QStandardItem app = QApplication(sys.argv) view = QListView() model = QStandardItemModel() view.setModel(model) view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) view.setItemDelegate(AutoToolTipItemDelegate()) view.setMinimumWidth(200) for i in range(0, 20): item = QStandardItem(str(i) * (50 - i)) model.appendRow(item) view.show() sys.exit(app.exec_())
def add_context(self, data): if self.dwarf.arch == 'ia32': self.threads_model.setHeaderData(1, Qt.Horizontal, 'EIP') elif self.dwarf.arch == 'x64': self.threads_model.setHeaderData(1, Qt.Horizontal, 'RIP') else: self.threads_model.setHeaderData(1, Qt.Horizontal, 'PC') is_java = data['is_java'] tid = QStandardItem() tid.setText(str(data['tid'])) tid.setData(data, Qt.UserRole + 1) tid.setTextAlignment(Qt.AlignCenter) pc_col = QStandardItem() if not is_java: if data['reason'] == 2: pc_col.setText(data['ptr']) else: pc = int(data['ptr'], 16) if 'arm' in self.dwarf.arch: # dethumbify if pc & 1 == 1: pc -= 1 if self._uppercase_hex: str_fmt = '0x{0:X}' else: str_fmt = '0x{0:x}' pc_col.setText(str_fmt.format(pc)) else: parts = data['ptr'].split('.') pc_col.setText(parts[len(parts) - 1]) symb_col = QStandardItem() if True: if not is_java: if 'symbol' in data['context']['pc']: str_fmt = ('{0} - {1}'.format( data['context']['pc']['symbol']['moduleName'], data['context']['pc']['symbol']['name'])) symb_col.setText(str_fmt) else: symb_col.setText('.'.join(parts[:len(parts) - 1])) else: str_fmt = ('loading {0}'.format('')) # str_fmt = ('loading {0}'.format(library_onload)) symb_col.setText(str_fmt) self.threads_model.appendRow([tid, pc_col, symb_col]) self.resizeColumnToContents(0) self.resizeColumnToContents(1) self.setCurrentIndex( self.threads_model.index(self.threads_model.rowCount() - 1, 0))
def update(self): if self.maybe_defer_update(): return current_address = self.get_role_data_for_current_item( col=self.Columns.LABEL, role=self.ROLE_ADDRESS_STR) if self.show_change == AddressTypeFilter.RECEIVING: addr_list = self.wallet.get_receiving_addresses() elif self.show_change == AddressTypeFilter.CHANGE: addr_list = self.wallet.get_change_addresses() else: addr_list = self.wallet.get_addresses() self.proxy.setDynamicSortFilter( False) # temp. disable re-sorting after every change self.std_model.clear() self.refresh_headers() fx = self.parent.fx set_address = None addresses_beyond_gap_limit = self.wallet.get_all_known_addresses_beyond_gap_limit( ) for address in addr_list: num = self.wallet.get_address_history_len(address) label = self.wallet.get_label(address) c, u, x = self.wallet.get_addr_balance(address) balance = c + u + x is_used_and_empty = self.wallet.is_used(address) and balance == 0 if self.show_used == AddressUsageStateFilter.UNUSED and ( balance or is_used_and_empty): continue if self.show_used == AddressUsageStateFilter.FUNDED and balance == 0: continue if self.show_used == AddressUsageStateFilter.USED_AND_EMPTY and not is_used_and_empty: continue if self.show_used == AddressUsageStateFilter.FUNDED_OR_UNUSED and is_used_and_empty: continue balance_text = self.parent.format_amount(balance, whitespaces=True) # create item if fx and fx.get_fiat_address_config(): rate = fx.exchange_rate() fiat_balance = fx.value_str(balance, rate) else: fiat_balance = '' labels = [ '', address, label, balance_text, fiat_balance, "%d" % num ] address_item = [QStandardItem(e) for e in labels] # align text and set fonts for i, item in enumerate(address_item): item.setTextAlignment(Qt.AlignVCenter) if i not in (self.Columns.TYPE, self.Columns.LABEL): item.setFont(QFont(MONOSPACE_FONT)) self.set_editability(address_item) address_item[self.Columns.FIAT_BALANCE].setTextAlignment( Qt.AlignRight | Qt.AlignVCenter) # setup column 0 if self.wallet.is_change(address): address_item[self.Columns.TYPE].setText(_('change')) address_item[self.Columns.TYPE].setBackground( ColorScheme.YELLOW.as_color(True)) else: address_item[self.Columns.TYPE].setText(_('receiving')) address_item[self.Columns.TYPE].setBackground( ColorScheme.GREEN.as_color(True)) address_item[self.Columns.LABEL].setData(address, self.ROLE_ADDRESS_STR) address_path = self.wallet.get_address_index(address) address_item[self.Columns.TYPE].setData(address_path, self.ROLE_SORT_ORDER) address_path_str = self.wallet.get_address_path_str(address) if address_path_str is not None: address_item[self.Columns.TYPE].setToolTip(address_path_str) address_item[self.Columns.FIAT_BALANCE].setData( balance, self.ROLE_SORT_ORDER) # setup column 1 if self.wallet.is_frozen_address(address): address_item[self.Columns.ADDRESS].setBackground( ColorScheme.BLUE.as_color(True)) if address in addresses_beyond_gap_limit: address_item[self.Columns.ADDRESS].setBackground( ColorScheme.RED.as_color(True)) # add item count = self.std_model.rowCount() self.std_model.insertRow(count, address_item) address_idx = self.std_model.index(count, self.Columns.LABEL) if address == current_address: set_address = QPersistentModelIndex(address_idx) self.set_current_idx(set_address) # show/hide columns if fx and fx.get_fiat_address_config(): self.showColumn(self.Columns.FIAT_BALANCE) else: self.hideColumn(self.Columns.FIAT_BALANCE) self.filter() self.proxy.setDynamicSortFilter(True)
def create_stat_model(database): # Список записей из базы hist_list = database.message_history() # Объект модели данных: list_qmodel = QStandardItemModel() list_qmodel.setHorizontalHeaderLabels( ['Имя Клиента', 'Последний раз входил', 'Сообщений отправлено', 'Сообщений получено']) for row in hist_list: user, last_seen, sent, recvd = row user = QStandardItem(user) user.setEditable(False) last_seen = QStandardItem(str(last_seen.replace(microsecond=0))) last_seen.setEditable(False) sent = QStandardItem(str(sent)) sent.setEditable(False) recvd = QStandardItem(str(recvd)) recvd.setEditable(False) list_qmodel.appendRow([user, last_seen, sent, recvd]) return list_qmodel
def gui_create_model(database): list_users = database.active_users_list() list_qmodel = QStandardItemModel() list_qmodel.setHorizontalHeaderLabels(['Имя Клиента', 'IP Адрес', 'Порт', 'Время подключения']) for row in list_users: user, ip, port, time = row user = QStandardItem(user) user.setEditable(False) ip = QStandardItem(ip) ip.setEditable(False) port = QStandardItem(str(port)) port.setEditable(False) # Уберём милисекунды из строки времени, # т.к. такая точность не требуется. time = QStandardItem(str(time.replace(microsecond=0))) time.setEditable(False) list_qmodel.appendRow([user, ip, port, time]) return list_qmodel
def update(self): self.wallet = self.parent.wallet current_address = self.current_item_user_role(col=self.Columns.LABEL) if self.show_change == 1: addr_list = self.wallet.get_receiving_addresses() elif self.show_change == 2: addr_list = self.wallet.get_change_addresses() else: addr_list = self.wallet.get_addresses() self.model().clear() self.refresh_headers() fx = self.parent.fx set_address = None for address in addr_list: num = self.wallet.get_address_history_len(address) label = self.wallet.labels.get(address, '') c, u, x = self.wallet.get_addr_balance(address) balance = c + u + x is_used_and_empty = self.wallet.is_used(address) and balance == 0 if self.show_used == 1 and (balance or is_used_and_empty): continue if self.show_used == 2 and balance == 0: continue if self.show_used == 3 and not is_used_and_empty: continue balance_text = self.parent.format_amount(balance, whitespaces=True) # create item if fx and fx.get_fiat_address_config(): rate = fx.exchange_rate() fiat_balance = fx.value_str(balance, rate) else: fiat_balance = '' labels = [ '', address, label, balance_text, fiat_balance, "%d" % num ] address_item = [QStandardItem(e) for e in labels] # align text and set fonts for i, item in enumerate(address_item): item.setTextAlignment(Qt.AlignVCenter) if i not in (self.Columns.TYPE, self.Columns.LABEL): item.setFont(QFont(MONOSPACE_FONT)) item.setEditable(i in self.editable_columns) address_item[self.Columns.FIAT_BALANCE].setTextAlignment( Qt.AlignRight | Qt.AlignVCenter) # setup column 0 if self.wallet.is_change(address): address_item[self.Columns.TYPE].setText(_('change')) address_item[self.Columns.TYPE].setBackground( ColorScheme.YELLOW.as_color(True)) else: address_item[self.Columns.TYPE].setText(_('receiving')) address_item[self.Columns.TYPE].setBackground( ColorScheme.GREEN.as_color(True)) address_item[self.Columns.LABEL].setData(address, Qt.UserRole) # setup column 1 if self.wallet.is_frozen_address(address): address_item[self.Columns.ADDRESS].setBackground( ColorScheme.BLUE.as_color(True)) if self.wallet.is_beyond_limit(address): address_item[self.Columns.ADDRESS].setBackground( ColorScheme.RED.as_color(True)) # add item count = self.model().rowCount() self.model().insertRow(count, address_item) address_idx = self.model().index(count, self.Columns.LABEL) if address == current_address: set_address = QPersistentModelIndex(address_idx) self.set_current_idx(set_address) # show/hide columns if fx and fx.get_fiat_address_config(): self.showColumn(self.Columns.FIAT_BALANCE) else: self.hideColumn(self.Columns.FIAT_BALANCE) self.filter()
def slot_add_page_from_url(self): # get the pages. urlList = QFileDialog.getOpenFileNames( caption=i18n("Which existing pages to add?"), directory=self.projecturl, filter=str(i18n("Krita files") + "(*.kra)"))[0] # get the existing pages list. pagesList = [] if "pages" in self.setupDictionary.keys(): pagesList = self.setupDictionary["pages"] # And add each url in the url list to the pages list and the model. for url in urlList: if self.projecturl not in urlList: newUrl = os.path.join(self.projecturl, self.setupDictionary["pagesLocation"], os.path.basename(url)) shutil.move(url, newUrl) url = newUrl relative = os.path.relpath(url, self.projecturl) if url not in pagesList: page = zipfile.ZipFile(url, "r") thumbnail = QImage.fromData(page.read("preview.png")) dataList = self.get_description_and_title( page.read("documentinfo.xml")) if (dataList[0].isspace() or len(dataList[0]) < 1): dataList[0] = os.path.basename(url) newPageItem = QStandardItem() newPageItem.setIcon(QIcon(QPixmap.fromImage(thumbnail))) newPageItem.setDragEnabled(True) newPageItem.setDropEnabled(False) newPageItem.setEditable(False) newPageItem.setText(dataList[0].replace("_", " ")) newPageItem.setData(dataList[1], role=CPE.DESCRIPTION) newPageItem.setData(relative, role=CPE.URL) self.pagesWatcher.addPath(url) newPageItem.setData(dataList[2], role=CPE.KEYWORDS) newPageItem.setData(dataList[3], role=CPE.LASTEDIT) newPageItem.setData(dataList[4], role=CPE.EDITOR) newPageItem.setToolTip(relative) page.close() self.pagesModel.appendRow(newPageItem)
def _update_event_model(self, event): self.model.appendRow([QStandardItem(str(event))])
def populate(self, data): """Populate the data model using the data passed from the extensions object. The data model has up to three root-level items: - Invalid metadata - Failed to load - Failed dependencies """ # font for use in various Items bold = QFont() bold.setWeight(QFont.Bold) root = self.invisibleRootItem() infos = data['infos'] if infos: # Handle extensions with metadata errors infos_item = QStandardItem() infos_item.setFont(bold) infos_item.setText(_("Invalid metadata:")) infos_tooltip = ( _("Extensions whose extension.cnf file has errors.\n" "They will be loaded nevertheless.")) infos_item.setToolTip(infos_tooltip) root.appendRow(infos_item) for info in infos: name_item = QStandardItem(info) name_item.setToolTip(infos_tooltip) icon = self.extensions.icon(info) if icon: name_item.setIcon(icon) details_item = QStandardItem(infos[info]) details_item.setToolTip(infos_tooltip) infos_item.appendRow([name_item, details_item]) exceptions = data['exceptions'] if exceptions: # Handle extensions that failed to load properly import traceback exceptions_item = self.exceptions_item = QStandardItem() exceptions_item.setFont(bold) exceptions_item.setText(_("Failed to load:")) extensions_tooltip = ( _("Extensions that failed to load properly.\n" "Double click on name to show the stacktrace.\n" "Please contact the extension maintainer.")) exceptions_item.setToolTip(extensions_tooltip) root.appendRow(exceptions_item) for ext in exceptions: extension_info = self.extensions.infos(ext) name = (extension_info.get('extension-name', ext) if extension_info else ext) name_item = QStandardItem(name) name_item.setToolTip(extensions_tooltip) icon = self.extensions.icon(ext) if icon: name_item.setIcon(icon) exc_info = exceptions[ext] # store exception information in the first item name_item.exception_info = exc_info message = '{}: {}'.format(exc_info[0].__name__, exc_info[1]) details_item = QStandardItem(message) details_item.setToolTip(extensions_tooltip) exceptions_item.appendRow([name_item, details_item]) dependencies = data['dependencies'] if dependencies: # Handle extensions with dependency issues dep_item = QStandardItem(_("Failed dependencies:")) dep_item.setFont(bold) dep_tooltip = ( _("Extensions with failed or circular dependencies.\n" "They are not loaded.")) dep_item.setToolTip(dep_tooltip) root.appendRow(dep_item) missing = dependencies.get('missing', None) if missing: missing_item = QStandardItem(_("Missing:")) missing_item.setFont(bold) missing_item.setToolTip(dep_tooltip) dep_item.appendRow(missing_item) for m in missing: item = QStandardItem(m) item.setToolTip(dep_item) missing_item.appendRow(item) inactive = dependencies.get('inactive', None) if inactive: inactive_item = QStandardItem(_("Inactive:")) inactive_item.setFont(bold) inactive_item.setToolTip(dep_tooltip) dep_item.appendRow(inactive_item) for i in inactive: item = QStandardItem(i) item.setToolTip(dep_tooltip) inactive_item.appendRow(item) circular = dependencies.get('circular', None) if circular: circular_item = QStandardItem(_("Circular:")) circular_item.setFont(bold) circular_item.setToolTip(dep_tooltip) dep_item.appendRow(circular_item) item = QStandardItem(' | '.join(circular)) item.setToolTip(dep_tooltip) circular_item.appendRow(item)
def append(model, text): item = QStandardItem() text = str(text) if text is not None else "" item.setText(text) item.setDropEnabled(False) item.setEditable(False) font: QFont = item.font() font.setFamily("Courier New") font.setPointSize(font.pointSize() - FONT_DIFF) item.setFont(font) if text.startswith("+"): item.setBackground(QColor(0, 255, 0, 127)) if text.startswith("-"): item.setBackground(QColor(255, 0, 0, 127)) if text == "": item.setBackground(QColor(0, 0, 0, 47)) model.appendRow(item)
def add_channel(self): self.ItemView.appendRow(QStandardItem(self.addText.text())) channel_ls.append(self.addText.text()) self.ListView.setModel(self.ItemView) self.addText.setText("")
def window_loaded(self): try: if self.timer is not None: self.timer.stop() self.timer = None self.list_model.clear() instances_url = 'https://raw.githubusercontent.com/ckan/ckan-instances/gh-pages/config/instances.json' self.util.msg_log_debug('before getting instances: ' + instances_url) http_call = HttpCall(self.settings, self.util) response = http_call.execute_request( instances_url # , headers=self.ua_chrome , verify=False, stream=True # not needed anymore, as we use QgsNetworkAccessManager.instance() now #, proxies=self.settings.get_proxies()[1] , timeout=self.settings.request_timeout) if not response.ok: QApplication.restoreOverrideCursor() self.util.dlg_warning(u'{}: {} {}'.format( response.status_code, response.status_message, response.reason)) return else: try: json_txt = response.text.data().decode() self.util.msg_log_debug( u'resp_msg (decoded):\n{} .......'.format( json_txt[:255])) result = json.loads(json_txt) except TypeError as te: self.util.msg_log_error( u'unexpected TypeError: {0}'.format(te)) return False, self.util.tr(u'cc_api_not_accessible') except AttributeError as ae: self.util.msg_log_error( u'unexpected AttributeError: {0}'.format(ae)) return False, self.util.tr(u'cc_api_not_accessible') except: self.util.msg_log_error( u'unexpected error during request or parsing of response:' ) self.util.msg_log_last_exception() return False, self.util.tr(u'cc_invalid_json') self.settings.load() selected_servers = self.settings.selected_ckan_servers.split( '|') self.servers = [] self.util.msg_log_debug(u'{} custom servers'.format( len(self.settings.custom_servers))) for cs_name in self.settings.custom_servers: url = self.settings.custom_servers[cs_name] si = ServerInstance(cs_name, cs_name, url, url, custom_entry=True) si.selected = True if si.settings_key in selected_servers else False self.servers.append(si) for entry in result: url_api = None if 'url-api' in entry: url_api = entry['url-api'] if 'geothermaldata' not in url_api: url_api = url_api.replace('http://', 'https://') url_api += '/api/3/' si = ServerInstance(entry['title'], entry['description'], entry['url'], url_api) si.selected = True if si.settings_key in selected_servers else False self.servers.append(si) for idx, server in enumerate(self.servers): i = QStandardItem(server.title) i.setData(server) if server.api_url is not None: if server.is_custom: i.setBackground(QColor(0, 0, 255, 50)) i.setCheckable(True) i.setCheckState( Qt.Checked if server.selected else Qt.Unchecked) self.list_model.appendRow(i) finally: self.__update_server_count() QApplication.restoreOverrideCursor()
def tabInformation(self): info = QWidget() vl = VLayout() self.program_model = QStandardItemModel() for d in [ "Program version", "Build date & time", "Core/SDK version", "Flash write count", "Boot count", "Restart reason", "Friendly Name 1", "Friendly Name 2", "Friendly Name 3", "Friendly Name 4" ]: k = QStandardItem(d) k.setEditable(False) v = QStandardItem() v.setTextAlignment(Qt.AlignVCenter | Qt.AlignRight) v.setEditable(False) self.program_model.appendRow([k, v]) gbPrgm = GroupBoxH("Program") gbPrgm.setFlat(True) tvPrgm = QTreeView() tvPrgm.setHeaderHidden(True) tvPrgm.setRootIsDecorated(False) tvPrgm.setModel(self.program_model) tvPrgm.resizeColumnToContents(0) gbPrgm.addWidget(tvPrgm) self.esp_model = QStandardItemModel() for d in [ "ESP Chip Id", "Flash Chip Id", "Flash Size", "Program Flash Size", "Program Size", "Free Program Space", "Free Memory" ]: k = QStandardItem(d) k.setEditable(False) v = QStandardItem() v.setTextAlignment(Qt.AlignVCenter | Qt.AlignRight) v.setEditable(False) self.esp_model.appendRow([k, v]) gbESP = GroupBoxH("ESP") gbESP.setFlat(True) tvESP = QTreeView() tvESP.setHeaderHidden(True) tvESP.setRootIsDecorated(False) tvESP.setModel(self.esp_model) tvESP.resizeColumnToContents(0) gbESP.addWidget(tvESP) # self.emul_model = QStandardItemModel() # for d in ["Emulation", "mDNS Discovery"]: # k = QStandardItem(d) # k.setEditable(False) # v = QStandardItem() # v.setTextAlignment(Qt.AlignVCenter | Qt.AlignRight) # v.setEditable(False) # self.emul_model.appendRow([k, v]) # # gbEmul = GroupBoxH("Emulation") # gbEmul.setFlat(True) # tvEmul = QTreeView() # tvEmul.setHeaderHidden(True) # tvEmul.setRootIsDecorated(False) # tvEmul.setModel(self.emul_model) # tvEmul.resizeColumnToContents(0) # gbEmul.addWidget(tvEmul) self.wifi_model = QStandardItemModel() for d in [ "AP1 SSId (RSSI)", "Hostname", "IP Address", "Gateway", "Subnet Mask", "DNS Server", "MAC Address" ]: k = QStandardItem(d) k.setEditable(False) v = QStandardItem() v.setTextAlignment(Qt.AlignVCenter | Qt.AlignRight) v.setEditable(False) self.wifi_model.appendRow([k, v]) gbWifi = GroupBoxH("Wifi") gbWifi.setFlat(True) tvWifi = QTreeView() tvWifi.setHeaderHidden(True) tvWifi.setRootIsDecorated(False) tvWifi.setModel(self.wifi_model) tvWifi.resizeColumnToContents(0) gbWifi.addWidget(tvWifi) self.mqtt_model = QStandardItemModel() for d in [ "MQTT Host", "MQTT Port", "MQTT User", "MQTT Client", "MQTT Topic", "MQTT Group Topic", "MQTT Full Topic", "MQTT Fallback Topic" ]: k = QStandardItem(d) k.setEditable(False) v = QStandardItem() v.setTextAlignment(Qt.AlignVCenter | Qt.AlignRight) v.setEditable(False) self.mqtt_model.appendRow([k, v]) gbMQTT = GroupBoxH("MQTT") gbMQTT.setFlat(True) tvMQTT = QTreeView() tvMQTT.setHeaderHidden(True) tvMQTT.setRootIsDecorated(False) tvMQTT.setModel(self.mqtt_model) tvMQTT.resizeColumnToContents(0) gbMQTT.addWidget(tvMQTT) hl = HLayout(0) vl_lc = VLayout(0, 3) vl_rc = VLayout(0, 3) vl_lc.addWidgets([gbPrgm, gbESP]) vl_rc.addWidgets([gbWifi, gbMQTT]) vl_rc.setStretch(0, 2) vl_rc.setStretch(1, 2) vl_rc.setStretch(2, 1) hl.addLayout(vl_lc) hl.addLayout(vl_rc) vl.addLayout(hl) info.setLayout(vl) return info
def rebuild(self): self.listModel.clear() if not self.ui.groupBox.isChecked() and self.ui.groupBox.isCheckable(): self.parts=None self.listModel.clear() self.update() return field=self.ui.comboBox.itemData(self.ui.comboBox.currentIndex()) minimum=None if self.ui.minCheckBox.isChecked(): minimum=self.ui.minSpinBox.value() maximum=None if self.ui.maxCheckBox.isChecked(): maximum=self.ui.maxSpinBox.value() bins=None if self.ui.binCheckBox.isChecked(): bins=self.ui.binSpinBox.value() self.parts=self.model.partition(field,minimum,maximum,bins) lst=list(sorted(self.parts.keys())) keep=np.zeros(self.model.data.shape,dtype=bool) for i,s in enumerate(lst): c=self.model.cfg.color(field,s,i) item=QStandardItem(s) if self.colors: item.setData(QColor(c),Qt.DecorationRole) if self.checkable: item.setCheckable(True) item.setCheckState(Qt.Checked) item.setData(s) self.listModel.appendRow(item) keep |= self.parts[s] keep = np.logical_not(keep) if np.count_nonzero(keep): self.parts[MyPartitionWidget.unassignedStr] = keep item=QStandardItem(MyPartitionWidget.unassignedStr) if self.colors: item.setData(QColor("white"),Qt.DecorationRole) if self.checkable: item.setCheckable(True) item.setCheckState(Qt.Unchecked) item.setData("NaN / Outside Range") self.listModel.appendRow(item) self.update()
def setup_ui(self): """ Setup Ui """ main_wrap = QVBoxLayout() main_wrap.setContentsMargins(0, 0, 0, 0) # updatebar on top self.update_bar = UpdateBar(self) self.update_bar.onUpdateNowClicked.connect(self._update_dwarf) self.update_bar.setVisible(False) main_wrap.addWidget(self.update_bar) # main content h_box = QHBoxLayout() h_box.setContentsMargins(15, 15, 15, 15) wrapper = QVBoxLayout() # wrapper.setGeometry(QRect(0, 0, 400, 200)) head = QHBoxLayout() head.setContentsMargins(0, 10, 0, 10) # dwarf icon icon = QLabel() icon.setContentsMargins(40, 0, 0, 0) dwarf_logo = QPixmap(utils.resource_path('assets/dwarf.svg')) icon.setPixmap(dwarf_logo) head.addWidget(icon) # main title v_box = QVBoxLayout() title = QLabel('Dwarf') title.setContentsMargins(0, 0, 50, 0) title.setFont(QFont('Anton', 90, QFont.Bold)) title.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) title.setFixedHeight(self.height() * .35) title.setAlignment(Qt.AlignCenter) v_box.addWidget(title) sub_title_text = (self._pick_random_word(0) + ' ' + self._pick_random_word(1) + ' ' + self._pick_random_word(2) + ' ' + self._pick_random_word(3) + ' ' + self._pick_random_word(4)) sub_title_text = sub_title_text[:1].upper() + sub_title_text[1:] sub_title = QLabel(sub_title_text) sub_title.setFont(QFont('OpenSans', 14, QFont.Bold)) sub_title.setFixedHeight(title.height() * .25) sub_title.setAlignment(Qt.AlignCenter) sub_title.setContentsMargins(0, 0, 50, 0) sub_title.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) v_box.addWidget(sub_title) head.addLayout(v_box) wrapper.addLayout(head) recent = QLabel('Last saved Sessions') font = recent.font() font.setBold(True) #font.setPointSize(10) recent.setFont(font) wrapper.addWidget(recent) wrapper.addWidget(self._recent_list) h_box.addLayout(wrapper, stretch=False) buttonSpacer = QSpacerItem(15, 100, QSizePolicy.Fixed, QSizePolicy.Minimum) h_box.addItem(buttonSpacer) wrapper = QVBoxLayout() btn = QPushButton() ico = QIcon(QPixmap(utils.resource_path('assets/android.svg'))) btn.setIconSize(QSize(75, 75)) btn.setIcon(ico) btn.setToolTip('New Android Session') btn.clicked.connect(self._on_android_button) wrapper.addWidget(btn) btn = QPushButton() ico = QIcon(QPixmap(utils.resource_path('assets/apple.svg'))) btn.setIconSize(QSize(75, 75)) btn.setIcon(ico) btn.setToolTip('New iOS Session') btn.clicked.connect(self._on_ios_button) wrapper.addWidget(btn) btn = QPushButton() ico = QIcon(QPixmap(utils.resource_path('assets/local.svg'))) btn.setIconSize(QSize(75, 75)) btn.setIcon(ico) btn.setToolTip('New Local Session') btn.clicked.connect(self._on_local_button) wrapper.addWidget(btn) btn = QPushButton() ico = QIcon(QPixmap(utils.resource_path('assets/remote.svg'))) btn.setIconSize(QSize(75, 75)) btn.setIcon(ico) btn.setToolTip('New Remote Session') btn.clicked.connect(self._on_remote_button) wrapper.addWidget(btn) session_history = self._prefs.get(prefs.RECENT_SESSIONS, default=[]) invalid_session_files = [] for recent_session_file in session_history: if os.path.exists(recent_session_file): with open(recent_session_file, 'r') as f: exported_session = json.load(f) hooks = '0' watchers = '0' on_loads = 0 bookmarks = '0' #have_user_script = False if 'hooks' in exported_session and exported_session['hooks'] is not None: hooks = str(len(exported_session['hooks'])) if 'watchers' in exported_session and exported_session['watchers'] is not None: watchers = str(len(exported_session['watchers'])) if 'nativeOnLoads' in exported_session and exported_session['nativeOnLoads'] is not None: on_loads += len(exported_session['nativeOnLoads']) if 'javaOnLoads' in exported_session and exported_session['javaOnLoads'] is not None: on_loads += len(exported_session['javaOnLoads']) if 'bookmarks' in exported_session and exported_session['bookmarks'] is not None: bookmarks = str(len(exported_session['bookmarks'])) if 'user_script' in exported_session and exported_session['user_script']: have_user_script = exported_session['user_script'] != '' #user_script_item = QStandardItem() #if have_user_script: #user_script_item.setIcon(self._dot_icon) on_loads = str(on_loads) recent_session_file_item = QStandardItem(recent_session_file) recent_session_file_item.setData(exported_session, Qt.UserRole + 2) item_1 = QStandardItem(exported_session['session']) item_1.setTextAlignment(Qt.AlignCenter) item_2 = QStandardItem(hooks) item_2.setTextAlignment(Qt.AlignCenter) item_3 = QStandardItem(watchers) item_3.setTextAlignment(Qt.AlignCenter) item_4 = QStandardItem(on_loads) item_4.setTextAlignment(Qt.AlignCenter) item_5 = QStandardItem(bookmarks) item_5.setTextAlignment(Qt.AlignCenter) #item_6 = QStandardItem(user_script_item) #item_6.setTextAlignment(Qt.AlignCenter) self._recent_list_model.insertRow(self._recent_list_model.rowCount(), [ recent_session_file_item, item_1, item_2, item_3, item_4, item_5 ]) else: invalid_session_files.append(recent_session_file) for invalid in invalid_session_files: session_history.pop(session_history.index(invalid)) self._prefs.put(prefs.RECENT_SESSIONS, session_history) h_box.addLayout(wrapper, stretch=False) main_wrap.addLayout(h_box) self.setLayout(main_wrap)
def initLandmarkList(self): # initialize the landmarkTableModel (QTableView) landmarkModel = QStandardItemModel(0, 0) landmarkModel.setHorizontalHeaderItem(0, QStandardItem('')) landmarkModel.setHorizontalHeaderItem(1, QStandardItem('Source x')) landmarkModel.setHorizontalHeaderItem(2, QStandardItem('Source y')) landmarkModel.setHorizontalHeaderItem(3, QStandardItem('Target x')) landmarkModel.setHorizontalHeaderItem(4, QStandardItem('Target y')) landmarkModel.setHorizontalHeaderItem(5, QStandardItem('Set')) landmarkModel.setHorizontalHeaderItem(6, QStandardItem('Move')) landmarkModel.setHorizontalHeaderItem(7, QStandardItem('Clear')) self.lTable.setModel(landmarkModel) header = self.lTable.horizontalHeader() for i in range(8): if i not in [3, 4]: # fixed width for target columns header.setSectionResizeMode(i, QHeaderView.ResizeToContents) self.lTable.setColumnWidth(3, 70) self.lTable.setColumnWidth(4, 70) self.lTable.verticalHeader().setSectionResizeMode( QHeaderView.ResizeToContents) landmarkModel = self.lTable.model() landmarks = json.loads(self.cfg['magc']['landmarks']) for id, (key, sourceTarget) in enumerate(landmarks.items()): item0 = QStandardItem(str(key)) item1 = QStandardItem(str(sourceTarget['source'][0])) item2 = QStandardItem(str(sourceTarget['source'][1])) item5 = QPushButton('Set') item5.setFixedSize(QSize(50, 40)) item5.clicked.connect(self.set_landmark(id)) item6 = QPushButton('Go to') item6.setFixedSize(QSize(60, 40)) item6.clicked.connect(self.goto_landmark(id)) if self.cfg['sys']['simulation_mode'] == 'True': item5.setEnabled(False) item6.setEnabled(False) item7 = QPushButton('Clear') item7.setFixedSize(QSize(60, 40)) item7.clicked.connect(self.clear_landmark(id)) if 'target' in sourceTarget: item0.setBackground(QColor(Qt.green)) item3 = QStandardItem(str(sourceTarget['target'][0])) item3.setBackground(QColor(Qt.green)) item4 = QStandardItem(str(sourceTarget['target'][1])) item4.setBackground(QColor(Qt.green)) else: item0.setBackground(QColor(Qt.lightGray)) item3 = QStandardItem('') item3.setBackground(QColor(Qt.lightGray)) item4 = QStandardItem('') item4.setBackground(QColor(Qt.lightGray)) item6.setEnabled(False) item7.setEnabled(False) item3.setCheckable(False) item4.setCheckable(False) landmarkModel.appendRow([item0, item1, item2, item3, item4]) self.lTable.setIndexWidget(landmarkModel.index(id, 5), item5) self.lTable.setIndexWidget(landmarkModel.index(id, 6), item6) self.lTable.setIndexWidget(landmarkModel.index(id, 7), item7)
def import_metadata(self): color_not_acquired = QColor(Qt.lightGray) color_acquired = QColor(Qt.green) color_acquiring = QColor(Qt.yellow) #----------------------------- # read sections from MagC yaml file_path = os.path.normpath(self.lineEdit_fileName.text()) if not os.path.isfile(file_path): self.add_to_main_log('MagC file not found') else: self.cfg['magc']['sections_path'] = file_path with open(file_path, 'r') as f: sectionsYAML = yaml.full_load(f) sections, landmarks = utils.sectionsYAML_to_sections_landmarks( sectionsYAML) if 'sourceROIsUpdatedFromSBEMimage' in sectionsYAML: result = QMessageBox.question( self, 'Section import', 'Using section locations that have been previously updated in SBEMImage ?', QMessageBox.Yes | QMessageBox.No) if result == QMessageBox.Yes: for sectionId, sectionXYA in \ sectionsYAML['sourceROIsUpdatedFromSBEMimage'].items(): sections[int(sectionId)] = { 'center': [float(a) for a in sectionXYA[:2]], 'angle': float((-sectionXYA[2] + 90) % 360) } self.cfg['magc']['roi_mode'] = 'False' n_sections = len([k for k in sections.keys() if str(k).isdigit()]) self.add_to_main_log( str(n_sections) + ' MagC sections have been loaded.') #----------------------------- #-------------------------------------- # import wafer overview if file present dir_sections = os.path.dirname(os.path.normpath(file_path)) im_names = [ im_name for im_name in os.listdir(dir_sections) if ('wafer' in im_name) and ( os.path.splitext(im_name)[1] in ['.tif', '.png']) ] if im_names == []: self.add_to_main_log('No wafer picture was found.') elif len(im_names) == 1: im_path = os.path.normpath( os.path.join(dir_sections, im_names[0])) selection_success = True selected_filename = os.path.basename(im_path) timestamp = str(datetime.datetime.now()) # Remove some characters from timestamp to get valid file name: timestamp = timestamp[:19].translate( {ord(c): None for c in ' :-.'}) target_path = os.path.join( self.target_dir, os.path.splitext(selected_filename)[0] + '_' + timestamp + '.png') if os.path.isfile(im_path): # Copy file to data folder as png: try: imported_img = Image.open(im_path) imported_img.save(target_path) except Exception as e: QMessageBox.warning( self, 'Error', 'Could not load image file.' + str(e), QMessageBox.Ok) selection_success = False if selection_success: new_img_number = self.ovm.get_number_imported() self.ovm.add_imported_img() width, height = imported_img.size self.ovm.set_imported_img_file(new_img_number, target_path) self.ovm.set_imported_img_name(new_img_number, selected_filename) self.ovm.set_imported_img_size_px_py( new_img_number, width, height) self.ovm.set_imported_img_pixel_size( new_img_number, 1000) self.cs.set_imported_img_centre_s( new_img_number, [width // 2, height // 2]) self.viewport.mv_load_last_imported_image() self.viewport.mv_draw() else: QMessageBox.warning(self, 'Error', 'Specified file not found.', QMessageBox.Ok) selection_success = False else: self.add_to_main_log( 'There are more than 1 picture available in the folder containing the .magc section description file. Please place only one wafer picture (.tif) in the folder.' ) #-------------------------------------- #--------------------------------------- # populate the grids and the sectionList tile_size_selector = self.comboBox_tileSize.currentIndex() pixel_size = self.doubleSpinBox_pixelSize.value() tile_overlap = self.doubleSpinBox_tileOverlap.value() sectionListView = self.gui_items['sectionList'] sectionListModel = sectionListView.model() sectionListModel.clear() sectionListModel.setHorizontalHeaderItem(0, QStandardItem('Section')) sectionListModel.setHorizontalHeaderItem(1, QStandardItem('State')) header = sectionListView.horizontalHeader() for i in range(2): header.setSectionResizeMode(i, QHeaderView.ResizeToContents) header.setStretchLastSection(True) self.gm.delete_all_grids() for section in range(n_sections): self.gm.add_new_grid() for idx, section in sections.items(): if str(idx).isdigit(): # to exclude tissueROI and landmarks self.gm.set_grid_size( idx, (self.spinBox_rows.value(), self.spinBox_cols.value())) self.gm.set_tile_size_selector(idx, tile_size_selector) self.gm.set_pixel_size(idx, pixel_size) self.gm.set_overlap(idx, tile_overlap) self.gm.select_all_tiles(idx) self.gm.set_rotation(idx, (180 - float(section['angle'])) % 360) self.gm.set_grid_center_s( idx, list(map(float, section['center']))) self.gm.calculate_grid_map(grid_number=idx) # populate the sectionList item1 = QStandardItem(str(idx)) item1.setCheckable(True) item2 = QStandardItem('') item2.setBackground(color_not_acquired) item2.setCheckable(False) item2.setSelectable(False) sectionListModel.appendRow([item1, item2]) sectionListView.setRowHeight(idx, 40) #--------------------------------------- #--------------------------------------- # Update config with MagC items self.cfg['sys']['magc_mode'] = 'True' self.cfg['magc']['sections'] = json.dumps(sections) self.cfg['magc']['selected_sections'] = '[]' self.cfg['magc']['checked_sections'] = '[]' self.cfg['magc']['landmarks'] = json.dumps(landmarks) # xxx does importing a new magc file always require a wafer_calibration ? self.queue.put('SAVE INI') self.trigger.s.emit() # --------------------------------------- # enable wafer configuration button self.queue.put('MAGC ENABLE CALIBRATION') self.trigger.s.emit() self.queue.put('MAGC WAFER NOT CALIBRATED') self.trigger.s.emit() self.accept()
def addGCodeFileLine(self, num: int): item = QStandardItem("") self.__gcodeFileUiModel.insertRow(num + 1, item)
def __init__(self, parent, info, title="Channel Properties"): super().__init__(parent) self.setWindowTitle(title) self.model = QStandardItemModel(info["nchan"], 4) self.model.setHorizontalHeaderLabels(["#", "Label", "Type", "Bad"]) for index, ch in enumerate(info["chs"]): item = QStandardItem() item.setData(index, Qt.DisplayRole) item.setFlags(item.flags() & ~Qt.ItemIsEditable) self.model.setItem(index, 0, item) self.model.setItem(index, 1, QStandardItem(ch["ch_name"])) kind = channel_type(info, index).upper() self.model.setItem(index, 2, QStandardItem(str(kind))) bad = QStandardItem() bad.setData(ch["ch_name"] in info["bads"], Qt.UserRole) bad.setCheckable(True) bad.setEditable(False) checked = ch["ch_name"] in info["bads"] bad.setCheckState(Qt.Checked if checked else Qt.Unchecked) self.model.setItem(index, 3, bad) self.model.itemChanged.connect(bad_changed) self.proxymodel = MySortFilterProxyModel() self.proxymodel.setDynamicSortFilter(False) self.proxymodel.setSourceModel(self.model) self.view = QTableView() self.view.setModel(self.proxymodel) self.view.setItemDelegateForColumn(2, ComboBoxDelegate(self.view)) self.view.setEditTriggers(QAbstractItemView.AllEditTriggers) self.view.verticalHeader().setVisible(False) self.view.horizontalHeader().setStretchLastSection(True) self.view.setShowGrid(False) self.view.setSelectionMode(QAbstractItemView.NoSelection) self.view.setSortingEnabled(True) self.view.sortByColumn(0, Qt.AscendingOrder) vbox = QVBoxLayout(self) vbox.addWidget(self.view) self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) vbox.addWidget(self.buttonbox) self.buttonbox.accepted.connect(self.accept) self.buttonbox.rejected.connect(self.reject) self.resize(475, 650) self.view.setColumnWidth(0, 70) self.view.setColumnWidth(1, 155) self.view.setColumnWidth(2, 90)
def _on_add_breakpoint(self, breakpoint): type_ = QStandardItem() type_.setFont(self._bold_font) type_.setTextAlignment(Qt.AlignCenter) if breakpoint.breakpoint_type == BREAKPOINT_NATIVE: type_.setText('N') type_.setToolTip('Native breakpoint') elif breakpoint.breakpoint_type == BREAKPOINT_JAVA: type_.setText('J') type_.setToolTip('Java breakpoint') elif breakpoint.breakpoint_type == BREAKPOINT_INITIALIZATION: type_.setText('C') type_.setToolTip('Initialization breakpoint') elif breakpoint.breakpoint_type == BREAKPOINT_OBJC: type_.setText('O') type_.setToolTip('ObjC breakpoint') else: type_.setText('U') type_.setToolTip('Unknown Type') addr = QStandardItem() if breakpoint.breakpoint_type == BREAKPOINT_JAVA: addr.setText(breakpoint.get_target()) elif breakpoint.breakpoint_type == BREAKPOINT_OBJC: addr.setText(breakpoint.get_target()) elif breakpoint.breakpoint_type == BREAKPOINT_INITIALIZATION: addr.setText(breakpoint.get_target()) addr.setData(breakpoint.debug_symbol, Qt.UserRole + 2) else: str_fmt = '0x{0:x}' if self._breakpoints_list.uppercase_hex: str_fmt = '0x{0:X}' # addr.setTextAlignment(Qt.AlignCenter) addr.setText(str_fmt.format(breakpoint.get_target())) condition = QStandardItem() condition.setTextAlignment(Qt.AlignCenter) condition.setFont(self._bold_font) if breakpoint.condition and breakpoint.condition != 'null' and breakpoint.condition != 'undefined': condition.setText('ƒ') condition.setToolTip(breakpoint.condition) condition.setData(breakpoint.condition, Qt.UserRole + 2) self._breakpoints_model.appendRow([addr, type_, condition]) self._breakpoints_list.resizeColumnToContents(0)
def fill_pages(self): self.loadingPages = True self.pagesModel.clear() if len(self.pagesWatcher.files()) > 0: self.pagesWatcher.removePaths(self.pagesWatcher.files()) pagesList = [] if "pages" in self.setupDictionary.keys(): pagesList = self.setupDictionary["pages"] progress = QProgressDialog() progress.setMinimum(0) progress.setMaximum(len(pagesList)) progress.setWindowTitle(i18n("Loading Pages...")) for url in pagesList: absurl = os.path.join(self.projecturl, url) relative = os.path.relpath(absurl, self.projecturl) if (os.path.exists(absurl)): #page = Application.openDocument(absurl) page = zipfile.ZipFile(absurl, "r") thumbnail = QImage.fromData(page.read("preview.png")) pageItem = QStandardItem() dataList = self.get_description_and_title( page.read("documentinfo.xml")) if (dataList[0].isspace() or len(dataList[0]) < 1): dataList[0] = os.path.basename(url) pageItem.setText(dataList[0].replace("_", " ")) pageItem.setDragEnabled(True) pageItem.setDropEnabled(False) pageItem.setEditable(False) pageItem.setIcon(QIcon(QPixmap.fromImage(thumbnail))) pageItem.setData(dataList[1], role=CPE.DESCRIPTION) pageItem.setData(relative, role=CPE.URL) self.pagesWatcher.addPath(absurl) pageItem.setData(dataList[2], role=CPE.KEYWORDS) pageItem.setData(dataList[3], role=CPE.LASTEDIT) pageItem.setData(dataList[4], role=CPE.EDITOR) pageItem.setToolTip(relative) page.close() self.pagesModel.appendRow(pageItem) progress.setValue(progress.value() + 1) progress.setValue(len(pagesList)) self.loadingPages = False
def makeItem(text, data=None): item = QStandardItem(text) item.setFlags(Qt.ItemIsEnabled) item.setData(data) return item
elif checked: header.updateCheckState(i, 1) else: header.updateCheckState(i, 0) app = QApplication(sys.argv) tableView = QTableView() model = QStandardItemModel() model.itemChanged.connect(modelChanged) model.setHorizontalHeaderLabels(['Title 1\nA Second Line', 'Title 2']) header = CheckBoxHeader([0, 1], parent=tableView) header.clicked.connect(updateModel) # populate the models with some items for i in range(3): item1 = QStandardItem('Item %d' % i) item1.setCheckable(True) item2 = QStandardItem('Another Checkbox %d' % i) item2.setCheckable(True) model.appendRow([item1, item2]) tableView.setModel(model) tableView.setHorizontalHeader(header) tableView.setSortingEnabled(True) tableView.show() sys.exit(app.exec_())
def get_list_item(self): name = self.get_name() icon = self.get_icon() return QStandardItem(icon, self.__class__.__name__), QStandardItem(name)