def __init__(self, parent=None, **kwargs): FramelessWindow.__init__(self, parent, **kwargs) self.setWindowFlags(Qt.Popup) self.__filterFunc = None self.__setupUi() self.__loop = None self.__model = QStandardItemModel() self.__triggeredAction = None
def __init__(self, tableType, parent): # generate a model based on orb columns items = {} model = QStandardItemModel(parent) if tableType: self.__populate(tableType.schema().columns(), model) self._tableType = tableType super(XOrbColumnCompleter, self).__init__(model, parent)
def __init__(self, parent=None, **kwargs): super(AddonManagerWidget, self).__init__(parent, **kwargs) self.setLayout(QVBoxLayout()) self.__header = QLabel( wordWrap=True, textFormat=Qt.RichText ) self.__search = QLineEdit( placeholderText=self.tr("Filter") ) self.layout().addWidget(self.__search) self.__view = view = QTreeView( rootIsDecorated=False, editTriggers=QTreeView.NoEditTriggers, selectionMode=QTreeView.SingleSelection, alternatingRowColors=True ) self.__view.setItemDelegateForColumn(0, TristateCheckItemDelegate()) self.layout().addWidget(view) self.__model = model = QStandardItemModel() model.setHorizontalHeaderLabels(["", "Name", "Version", "Action"]) model.dataChanged.connect(self.__data_changed) proxy = QSortFilterProxyModel( filterKeyColumn=1, filterCaseSensitivity=Qt.CaseInsensitive ) proxy.setSourceModel(model) self.__search.textChanged.connect(proxy.setFilterFixedString) view.setModel(proxy) view.selectionModel().selectionChanged.connect( self.__update_details ) header = self.__view.header() header.setResizeMode(0, QHeaderView.Fixed) header.setResizeMode(2, QHeaderView.ResizeToContents) self.__details = QTextBrowser( frameShape=QTextBrowser.NoFrame, readOnly=True, lineWrapMode=QTextBrowser.WidgetWidth, openExternalLinks=True, ) self.__details.setWordWrapMode(QTextOption.WordWrap) palette = QPalette(self.palette()) palette.setColor(QPalette.Base, Qt.transparent) self.__details.setPalette(palette) self.layout().addWidget(self.__details)
def __init__(self, parent=None): super().__init__(parent) self.train_data = None self.test_data = None #: An Ordered dictionary with current inputs and their testing #: results. self.learners = OrderedDict() sbox = gui.widgetBox(self.controlArea, "Sampling") rbox = gui.radioButtons( sbox, self, "resampling", callback=self._param_changed ) gui.appendRadioButton(rbox, "Cross validation") ibox = gui.indentedBox(rbox) gui.spin(ibox, self, "k_folds", 2, 50, label="Number of folds:", callback=self.kfold_changed) gui.appendRadioButton(rbox, "Leave one out") gui.appendRadioButton(rbox, "Random sampling") ibox = gui.indentedBox(rbox) gui.spin(ibox, self, "n_repeat", 2, 50, label="Repeat train/test", callback=self.bootstrap_changed) gui.widgetLabel(ibox, "Relative training set size:") gui.hSlider(ibox, self, "sample_p", minValue=1, maxValue=100, ticks=20, vertical=False, labelFormat="%d %%", callback=self.bootstrap_changed) gui.appendRadioButton(rbox, "Test on train data") gui.appendRadioButton(rbox, "Test on test data") rbox.layout().addSpacing(5) gui.button(rbox, self, "Apply", callback=self.apply) gui.rubber(self.controlArea) self.view = QTreeView( rootIsDecorated=False, uniformRowHeights=True, wordWrap=True, editTriggers=QTreeView.NoEditTriggers ) header = self.view.header() header.setResizeMode(QHeaderView.ResizeToContents) header.setDefaultAlignment(Qt.AlignCenter) header.setStretchLastSection(False) self.result_model = QStandardItemModel() self.view.setModel(self.result_model) self.view.setItemDelegate(ItemDelegate()) self._update_header() box = gui.widgetBox(self.mainArea, "Evaluation Results") box.layout().addWidget(self.view)
def _configure_model(self): model = QStandardItemModel(0, 3, self) # Set headers headers = [ self.tr('Name'), self.tr('Data Type'), self.tr('Description') ] model.setHorizontalHeaderLabels(headers) self.setModel(model)
def __init__(self, name='', desc='', survey_date=None, run_no=''): self.name = name self.desc = desc self.survey_date = survey_date self.run_no = run_no self.model = QStandardItemModel() #self.model=route_model.route_model() self.model.setColumnCount(len(cols)) [self.model.setHeaderData(cols[c], Qt.Horizontal, c) for c in cols]
def __init__(self, parent=None): super(FormWidget, self).__init__(parent) self.setupUi(self) self.form = None self.fieldsmodel = QgsFieldModel() self.widgetmodel = WidgetsModel() self.possiblewidgetsmodel = QStandardItemModel() self.formlayersmodel = QgsLayerModel(watchregistry=True) self.formlayers = CaptureLayerFilter() self.formlayers.setSourceModel(self.formlayersmodel) self.layerCombo.setModel(self.formlayers) self.useablewidgets.setModel(self.possiblewidgetsmodel) self.fieldList.setModel(self.fieldsmodel) self.userwidgets.setModel(self.widgetmodel) self.userwidgets.selectionModel().currentChanged.connect(self.load_widget) self.widgetmodel.rowsRemoved.connect(self.setwidgetconfigvisiable) self.widgetmodel.rowsInserted.connect(self.setwidgetconfigvisiable) self.widgetmodel.modelReset.connect(self.setwidgetconfigvisiable) self.addWidgetButton.pressed.connect(self.newwidget) self.removeWidgetButton.pressed.connect(self.removewidget) self.formfolderLabel.linkActivated.connect(self.openformfolder) self.expressionButton.clicked.connect(self.opendefaultexpression) self.fieldList.currentIndexChanged.connect(self.updatewidgetname) self.fieldwarninglabel.hide() self.formtab.currentChanged.connect(self.formtabchanged) for item, data in readonlyvalues: self.readonlyCombo.addItem(item, data) self.loadwidgettypes() self.formLabelText.textChanged.connect(self.form_name_changed) self.layerCombo.currentIndexChanged.connect(self.layer_updated) self.fieldList.currentIndexChanged.connect(self._save_current_widget) self.nameText.textChanged.connect(self._save_current_widget) self.useablewidgets.currentIndexChanged.connect(self._save_current_widget) self.useablewidgets.currentIndexChanged.connect(self.swapwidgetconfig) menu = QMenu("Field Actions") action = menu.addAction("Auto add all fields") action.triggered.connect(self.auto_add_fields) self.addWidgetButton.setMenu(menu) self.addWidgetButton.setPopupMode(QToolButton.MenuButtonPopup) self.defaultLayerCombo.layerChanged.connect(self.default_layer_changed)
def __init__(self): super().__init__() self.data = None self.results = None self.learners = [] self.headers = [] box = gui.widgetBox(self.controlArea, "Learners") self.learners_box = gui.listBox( box, self, "selected_learner", "learners", callback=self._learner_changed ) box = gui.widgetBox(self.controlArea, "Show") gui.comboBox(box, self, "selected_quantity", items=self.quantities, callback=self._update) box = gui.widgetBox(self.controlArea, "Select") gui.button(box, self, "Correct", callback=self.select_correct, autoDefault=False) gui.button(box, self, "Misclassified", callback=self.select_wrong, autoDefault=False) gui.button(box, self, "None", callback=self.select_none, autoDefault=False) self.outputbox = box = gui.widgetBox(self.controlArea, "Output") gui.checkBox(box, self, "append_predictions", "Predictions", callback=self._invalidate) gui.checkBox(box, self, "append_probabilities", "Probabilities", callback=self._invalidate) gui.auto_commit(self.controlArea, self, "autocommit", "Send Data", "Auto send is on") grid = QGridLayout() self.tablemodel = QStandardItemModel(self) view = self.tableview = QTableView( editTriggers=QTableView.NoEditTriggers) view.setModel(self.tablemodel) view.horizontalHeader().hide() view.verticalHeader().hide() view.horizontalHeader().setMinimumSectionSize(60) view.selectionModel().selectionChanged.connect(self._invalidate) view.setShowGrid(False) view.clicked.connect(self.cell_clicked) grid.addWidget(view, 0, 0) self.mainArea.layout().addLayout(grid)
def __init__(self, iface, spatial_unit_dock): """ The method initializes the dockwidget. :param iface: QGIS user interface class :type class qgis.utils.iface :param plugin: The STDM plugin :type class :return: None """ from stdm.ui.entity_browser import _EntityDocumentViewerHandler DetailsDockWidget.__init__(self, iface, spatial_unit_dock) DetailsDBHandler.__init__(self) self.spatial_unit_dock = spatial_unit_dock self.view = QTreeView() self.view.setSelectionBehavior( QAbstractItemView.SelectRows ) #self.feature_ids = [] self.layer_table = None self.entity = None self.feature_models = {} self.party_models = {} self.STR_models = {} self.feature_STR_model = {} self.removed_feature = None self.selected_root = None self.model = QStandardItemModel() self.view.setModel(self.model) self.view.setUniformRowHeights(True) self.view.setRootIsDecorated(True) self.view.setAlternatingRowColors(True) self.view.setWordWrap(True) self.view.setHeaderHidden(True) self.view.setEditTriggers( QAbstractItemView.NoEditTriggers ) self.current_profile = current_profile() self.social_tenure = self.current_profile.social_tenure self.spatial_unit = self.social_tenure.spatial_unit self.party = self.social_tenure.party self.view.setMinimumWidth(250) self.doc_viewer_title = QApplication.translate( 'EntityBrowser', 'Document Viewer' ) self.doc_viewer = _EntityDocumentViewerHandler( self.doc_viewer_title, self.iface.mainWindow() )
def update_commands(self, meas_prog_list_byname): global Regexprogramfile Regexprogramfile = "(" + "|".join(meas_prog_list_byname) + ")" self.valid_list_of_commands = self.get_list_of_commands() #initiate syntax highlighting for the macro editor self.highlighter = MacroHighlighter(self.ui.macro_textbox.document(), self.valid_list_of_commands) #update the list of available macro commands in the user interface model = QStandardItemModel() parentItem = model.invisibleRootItem() for command in self.valid_list_of_commands: parentItem.appendRow(QStandardItem(command.label)) self.ui.macrocommandtree.setModel(model)
def __init__(self): super(PrvTreeviewNest, self).__init__() loadUi('treeview_nest.ui') # row can be 0 even when it's more than 0. self._datamodel = QStandardItemModel(0, 2) self.setModel(self._datamodel) for i in range(4): self.add_widget(i + 1) self.show()
def __init__(self, parent): QDockWidget.__init__(self, parent) self.parent = parent self.setupUi(self) self.block_model = QStandardItemModel() self.segment_model = QStandardItemModel() self.channelgroup_model = QStandardItemModel() self.channel_model = QStandardItemModel() self.unit_model = QStandardItemModel() self.neoBlockList.setModel(self.block_model) self.neoSegmentList.setModel(self.segment_model) self.neoChannelGroupList.setModel(self.channelgroup_model) self.neoChannelList.setModel(self.channel_model) self.neoUnitList.setModel(self.unit_model) self.neoBlockList.doubleClicked.connect( lambda x: self._edit_item_annotations(x, self.block_model)) self.neoSegmentList.doubleClicked.connect( lambda x: self._edit_item_annotations(x, self.segment_model)) self.neoChannelGroupList.doubleClicked.connect( lambda x: self._edit_item_annotations(x, self.channelgroup_model)) self.neoChannelList.doubleClicked.connect( lambda x: self._edit_item_annotations(x, self.channel_model)) self.neoUnitList.doubleClicked.connect( lambda x: self._edit_item_annotations(x, self.unit_model)) self.neoBlockList.selectionModel().selectionChanged.connect( self.selected_blocks_changed) self.neoChannelGroupList.selectionModel().selectionChanged.connect( self.selected_channel_groups_changed) self.neoChannelList.selectionModel().selectionChanged.connect( self.selected_channels_changed) self.neoUnitList.selectionModel().selectionChanged.connect( self.selected_units_changed) self.neoSegmentList.selectionModel().selectionChanged.connect( self.selected_segments_changed)
def initializePage(self): model = QStandardItemModel() # using a document model, we can obtain all the documents to list inside this view... all_docs = DocumentStorage.documents() for doc_filename in all_docs: # find out the last scan date, number of files, etc document = PersistentScanningState(doc_filename) logger.debug("found info: {0}".format(document.info)) creation_date_str = str(document.info.date_created) last_date = str(document.info.date_last_scanned) num_scanned = "{0:,}".format(document.info.files_scanned) num_merged = "{0:,}".format(document.info.files_merged) is_merged = document.info.merge_complete if not is_merged: last_date_str = "" else: last_date_str = last_date doc = os.path.split(doc_filename)[1][:-len('.sqlite')] items = [ QStandardItem(doc), QStandardItem(str(num_scanned)), QStandardItem(creation_date_str), QStandardItem(str(num_merged)), QStandardItem(last_date_str), ] items[1].setData(Qt.AlignRight, Qt.TextAlignmentRole) items[3].setData(Qt.AlignRight, Qt.TextAlignmentRole) model.invisibleRootItem().appendRow(items) self.ui.treeView.setModel(model) header = self.ui.treeView.header() model.setHeaderData(0, Qt.Horizontal, "Name") model.setHeaderData(1, Qt.Horizontal, "# First Scan") model.setHeaderData(2, Qt.Horizontal, "Date Created") model.setHeaderData(3, Qt.Horizontal, "# Second Scan") model.setHeaderData(4, Qt.Horizontal, "Date Scanned") header.setResizeMode(0, QHeaderView.ResizeToContents) header.setResizeMode(1, QHeaderView.ResizeToContents) header.setResizeMode(2, QHeaderView.ResizeToContents) header.setResizeMode(3, QHeaderView.ResizeToContents) header.setResizeMode(4, QHeaderView.ResizeToContents) self.ui.treeView.selectionModel().currentRowChanged.connect( self.__onSelectionChanged)
def show_result(self, search_time): self.set_results_heading_text("{} Ergebnisse in {:.2f} Sekunden".format(len(self.result), search_time)) result = self.result model = QStandardItemModel(self.list_results) for index in range(min(len(result), self.max_results)): node = result.get_node(index) context = result.get_context(index) item_text = [str(index + 1) + ". " + node.get_title(), node.get_urls()[0], "\t" + context] item = QStandardItem("\n".join(item_text)) model.appendRow(item) self.list_results.setModel(model) self.list_results.show()
def populateTable(self, table): cols = len(self.param.cols) rows = len(table) model = QStandardItemModel(rows, cols) # Set headers model.setHorizontalHeaderLabels(self.param.cols) # Populate table for i in xrange(rows): for j in xrange(cols): item = QStandardItem(table[i][j]) model.setItem(i, j, item) self.tblView.setModel(model)
def __init__(self, window): super(NameList, self).__init__('Current Plots') self.namelist_model = QStandardItemModel() self.namelist_view = QListView() self.namelist_view.setModel(self.namelist_model) self.setWidget(self.namelist_view) self.window = window self.plot_dict = {} self.namelist_view.doubleClicked.connect(self.activate_item) self.namelist_view.setContextMenuPolicy(QtConst.ActionsContextMenu) delete_action = QAction("Delete Selected", self.namelist_view) delete_action.triggered.connect(self.delete_item) self.namelist_view.addAction(delete_action)
def __init__(self, xmlPath, treeControl, parent=None): """ Constructor """ if xmlPath is None or not os.path.isfile(xmlPath): msg = "..." q = QMessageBox(QMessageBox.Warning, "Could not find that file", msg) q.setStandardButtons(QMessageBox.Ok) i = QIcon() i.addPixmap(QPixmap("..."), QIcon.Normal) q.setWindowIcon(i) q.exec_() else: self.tree = treeControl self.model = QStandardItemModel() # Set up an invisible root item for the tree. #self.treeRoot = self.model.invisibleRootItem() self.treeRoot = QStandardItem("Root Item") self.model.appendRow(self.treeRoot) self.tree.setModel(self.model) self.tree.doubleClicked.connect(self.item_doubleClicked) self.tree.customContextMenuRequested.connect(self.openMenu) self.tree.setDragEnabled(True) self.xmlTreeDir = os.path.join(os.path.dirname(__file__), "Resources/XML/") self.xmlProjfile = xmlPath self.xmlProjDir = os.path.dirname(xmlPath) self.namespace = "{http://tempuri.org/ProjectDS.xsd}" self.xmlTreePath = None # Load the GCD Project (the raw data that will be used to populate the tree) # instead of ET.fromstring(xml) self.xmlProjectDoc = self.LoadXMLFile(self.xmlProjfile) if self.FindTreeParser(): print "got ya" # Load the tree file (the rules we use to build the tree) else: print "This is an error" # Set up the first domino for the recursion projectName = self.xmlProjectDoc.find("Project/name") if projectName is not None: self.treeRoot.setText(projectName.text) self.LoadNode(None, self.xmlTemplateDoc.find("node"), self.xmlProjectDoc) self.tree.expandToDepth(5)
def get_attributes(self): """Place excludable attributes in model list""" # Model Structure used from Tutorial at # http://pythoncentral.io/pyside-pyqt-tutorial-qlistview-and-qstandarditemmodel/ self.model = QStandardItemModel(self.listTblAttrib) self.hasGeometry = self.iface.activeLayer().hasGeometryType() self.provider = self.iface.activeLayer().dataProvider() fields = self.iface.activeLayer().pendingFields() for field in fields: item = QStandardItem(field.name()) item.setCheckable(True) self.model.appendRow(item) self.listTblAttrib.setModel(self.model)
def init_quest_list(self): self.bot.QuestManager.EnumActiveQuests() self.model = QStandardItemModel(self.quest_list) for quest in [ self.bot.QuestManager.GetQuest(quest_id) for quest_id in self.bot.QuestManager.GetQuestIds() ]: item = QStandardItem(quest.GetTitle()) item.setEditable(False) self.model.appendRow(item) self.quest_list.setModel(self.model) self.quest_list.connect(self.quest_list, SIGNAL('itemActivated(QModelIndex)'), self.quest_id_edit, SLOT('setText'))
def __init__(self, parent=None): QTableView.__init__(self, parent) self.setEditTriggers(QAbstractItemView.DoubleClicked | QAbstractItemView.SelectedClicked) self.setSelectionBehavior(QAbstractItemView.SelectRows) self._pair_model = QStandardItemModel(1, 2, self) self._pair_model.dataChanged.connect(self._on_pair_data_changed) self.setModel(self._pair_model) self.horizontalHeader().setResizeMode(QHeaderView.Stretch) self._combo_delegate = PairComboBoxDelegate(self) self.setItemDelegate(self._combo_delegate)
def __init__(self, engine, gui_parent, parent=None): """ Constructor @param parent reference to the parent widget (QWidget) """ super().__init__(parent) self.setupUi(self) self.setWindowTitle("Enregistrement d'une formation") self.engine = engine self.dateEdit.setDate(pendulum.now('Europe/Paris')) self.cmr_bdd = Bdd_Cmr(self.engine) gen_cmr = self.cmr_bdd.recup_cmr_en_activite() self.remplir_tableau_cmr(next(gen_cmr)) # self.threadpool = QThreadPool() self.gui_parent = gui_parent ####Threads self.thread_finish = False # self.affectation_lancement_threads() init_domaine = Insertion_Domaine(self.engine) areas = init_domaine.recuperation_domaine() # print(areas) self.model = QStandardItemModel((len(areas) + 1), 1) # 5 rows, 1 col firstItem = QStandardItem("---- Select domaine(s) ----") firstItem.setBackground(QBrush(QColor(200, 200, 200))) firstItem.setSelectable(False) self.model.setItem(0, 0, firstItem) for i, area in enumerate(areas): item = QStandardItem(area) item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled) item.setData(Qt.Unchecked, Qt.CheckStateRole) self.model.setItem(i + 1, 0, item) self.comboBox_domaine.setModel(self.model) self.gui_parent.formation_a_modifier.connect( self.reaffectation_formation)
def __init__(self, other_or_parent=None, parent=None): if isinstance(other_or_parent, QObject) and parent is None: parent, other_or_parent = other_or_parent, None QObject.__init__(self, parent) WidgetRegistry.__init__(self, other_or_parent) # Should the QStandardItemModel be subclassed? self.__item_model = QStandardItemModel(self) for i, desc in enumerate(self.categories()): cat_item = self._cat_desc_to_std_item(desc) self.__item_model.insertRow(i, cat_item) for j, wdesc in enumerate(self.widgets(desc.name)): widget_item = self._widget_desc_to_std_item(wdesc, desc) cat_item.insertRow(j, widget_item)
def __init__(self, parent=None, profile=None, social_tenure=None): super(STRPartyListView, self).__init__(parent) self._model = QStandardItemModel(self) self._model.setColumnCount(1) self.setModel(self._model) self.setEditTriggers(QAbstractItemView.NoEditTriggers) self._model.itemChanged.connect(self._on_item_changed) self._profile = profile if not self._profile is None: self._load_profile_entities() self._social_tenure = social_tenure if not self._social_tenure is None: self.select_parties(self._social_tenure.parties)
def set_headers(self, qtable): feature_type = utils_giswater.get_item_data( self.dlg_lot, self.dlg_lot.cmb_visit_class, 2).lower() columns_name = self.controller.get_columns_list('om_visit_lot_x_' + str(feature_type)) columns_name.append(['validate']) standard_model = QStandardItemModel() qtable.setModel(standard_model) qtable.horizontalHeader().setStretchLastSection(True) # # Get headers headers = [] for x in columns_name: headers.append(x[0]) # Set headers standard_model.setHorizontalHeaderLabels(headers)
def __init__(self, parent=None, selectMode=True): QDialog.__init__(self, parent) self.setupUi(self) self.notifBar = NotificationBar(self.vlNotification) if selectMode: self.buttonBox.setVisible(True) self.manageButtonBox.setVisible(False) currHeight = self.size().height() self.resize(200, currHeight) else: self.buttonBox.setVisible(False) self.manageButtonBox.setVisible(True) self.setWindowTitle( QApplication.translate("TemplateDocumentSelector", "Template Manager")) #Configure manage buttons btnEdit = self.manageButtonBox.button(QDialogButtonBox.Ok) btnEdit.setText( QApplication.translate("TemplateDocumentSelector", "Edit...")) btnEdit.setIcon(QIcon(":/plugins/stdm/images/icons/edit.png")) btnDelete = self.manageButtonBox.button(QDialogButtonBox.Save) btnDelete.setText( QApplication.translate("TemplateDocumentSelector", "Delete")) btnDelete.setIcon(QIcon(":/plugins/stdm/images/icons/delete.png")) #Connect signals self.buttonBox.accepted.connect(self.onAccept) btnEdit.clicked.connect(self.onEditTemplate) btnDelete.clicked.connect(self.onDeleteTemplate) #Get saved document templates then add to the model templates = documentTemplates() self._docItemModel = QStandardItemModel(parent) self._docItemModel.setColumnCount(2) for name, path in templates.iteritems(): docNameItem = self._createDocNameItem(name) filePathItem = QStandardItem(path) self._docItemModel.appendRow([docNameItem, filePathItem]) self.lstDocs.setModel(self._docItemModel)
def getSampleModel(spl, flags='peak', **kw): from gui.MetBaseGui import MSStandardItem if flags not in ('peak', 'cluster', 'id'): return model = QStandardItemModel() if flags == 'peak': from utils.misc import Hot areas = [peak.area for peak in spl.rawPeaks.ipeaks()] mxInt = max(areas) model.setHorizontalHeaderLabels(MSSample.peakModelLabel) for i, peak in enumerate(spl.rawPeaks.ipeaks()): model.setItem(i, 0, MSStandardItem(str(peak.mass()))) model.item(i, 0).setBackground( QBrush(Hot._get_color(areas[i] / mxInt, True, alpha=0.5))) model.setItem(i, 1, MSStandardItem(str(peak.rt))) model.item(i, 1).setBackground( QBrush(Hot._get_color(areas[i] / mxInt, True, alpha=0.5))) model.setItem(i, 2, MSStandardItem(str(peak.area))) model.item(i, 2).setBackground( QBrush(Hot._get_color(areas[i] / mxInt, True, alpha=0.5))) model.setItem(i, 3, MSStandardItem(str(peak.sn))) model.item(i, 3).setBackground( QBrush(Hot._get_color(areas[i] / mxInt, True, alpha=0.5))) model.setItem(i, 4, MSStandardItem(str(peak.r_coef))) model.item(i, 4).setBackground( QBrush(Hot._get_color(areas[i] / mxInt, True, alpha=0.5))) elif flags == 'cluster': model.setHorizontalHeaderLabels(MSSample.clusterModelLabel) for i, peak in enumerate(spl.mappedPeaks.ipeaks()): model.setItem(i, 0, MSStandardItem(str(peak.mass()))) model.setItem(i, 1, MSStandardItem(str(peak.rt))) model.setItem(i, 2, MSStandardItem(str(peak.area))) info_iso = "" info_frag = "" for iso in peak.isoCluster: info_iso += '%s/%s\t' % (str(iso.mass()), str(iso.rt)) for add in peak.fragCluster: info_frag += '%s/%s\t' % (str(add.mass()), str(add.rt)) model.setItem(i, 3, MSStandardItem(info_iso)) model.setItem(i, 4, MSStandardItem(info_frag)) return model
def __init__(self): """""" super(dbmanagerUI, self).__init__() self.setupUi(self) self.statusbar.showMessage("Ready") exitAction = QtGui.QAction(QtGui.QIcon('exit.png'), '&Exit', self) exitAction.setShortcut('Ctrl+Q') exitAction.setStatusTip('Exit Masar Configuration Manager.') exitAction.triggered.connect(QtGui.qApp.quit) self.groupdatabasemenubar() #default database source, could be 0: SQLite, 1: MongoDB, and 2: MySQL self.dbsource = None self.defaultdbinfo = self._loadmasarconfig() self.usedefaultdb = True self.comboxboxSignalMapper = QtCore.QSignalMapper(self) self.comboxboxSignalMapper.mapped[QtGui.QWidget].connect( self.comboboxSignalMapperMapped) self.pushbuttonSignalMapper = QtCore.QSignalMapper(self) self.pushbuttonSignalMapper.mapped[QtGui.QWidget].connect( self.pushbuttonSignalMapperMapped) self.showpvbuttonSignalMapper = QtCore.QSignalMapper(self) self.showpvbuttonSignalMapper.mapped[QtGui.QWidget].connect( self.showpvbuttonSignalMapperMapped) self.choosepvbuttonSignalMapper = QtCore.QSignalMapper(self) self.choosepvbuttonSignalMapper.mapped[QtGui.QWidget].connect( self.choosepvbuttonSignalMapperMapped) self.currentselectedrow4config = -1 self.selectedsystem = "Others" # self.pvgrouptreeview = QTreeView() self.pvGroupTreeView.setSelectionBehavior(QAbstractItemView.SelectRows) self.pvgroupmodel = QStandardItemModel() # self.pvgroupmodel.setHorizontalHeaderLabels(['id', 'date', 'version', "description"]) self.pvgroupmodel.setHorizontalHeaderLabels(["PV Groups"]) self.pvGroupTreeView.setModel(self.pvgroupmodel) self.pvGroupTreeView.setUniformRowHeights(True) self.test_in_progress_flag = 0
def populate_columns_list(self): """ Populate the columns view. :return: :rtype: """ options = {} options['type'] = 'combobox' delegate = GenericDelegate( self.separators, options, self.column_code_view) # Set delegate to add widget self.column_code_view.setItemDelegate( delegate ) self.column_code_view.setItemDelegateForColumn( 1, delegate ) model = QStandardItemModel(2, 2) i = 0 for row, col in enumerate(self._columns): column_item = QStandardItem(self._entity.columns[col].header()) column_item.setCheckable(True) model.setItem(i, 0, column_item) column_item.setData(col) self.column_code_view.setModel(model) i = i + 1 for col in self._entity.columns.values(): if col.name == 'id': continue if col.name not in self._columns: # Correct row by reducing by one due to removal of id column_item = QStandardItem(col.header()) column_item.setCheckable(True) model.setItem(i, 0, column_item) column_item.setData(col.name) self.column_code_view.setModel(model) i = i + 1
def __init__(self): super(ListViewWindow, self).__init__() # ui_full_path = find_file_in_product('list_ui_widget.ui') ui_full_path = find_resource_in_pkg('list_window.ui') self.ui = uic.loadUi(ui_full_path, self) self.model = QStandardItemModel() self._mouse_button = None self.listView.setModel(self.model) # self.show() self.listView.clicked.connect(self.item_clicked) # self.listView.doubleClicked.connect(self.handle_right_click) self.minimized = True self.click_handler = None self.right_click_handler = None self.list_view_mouse_pressed = self.listView.mousePressEvent self.listView.mousePressEvent = self.mousePressEvent
def fillCalculations(self): self.calculations = [ 'Stack optics (A,R,T)', 'Ellipsometry', 'Field intensity', 'Layerwise optics (absorption, collection, QE)', 'Generation' ] self.calcListModel = QStandardItemModel() calculationsToShow = self.defaults['defaultCalculations'] for value in self.calculations: item = QStandardItem(value) check = Qt.Checked if value in calculationsToShow else Qt.Unchecked item.setCheckState(check) item.setCheckable(True) #item.setEnabled(False) self.calcListModel.appendRow(item) self.calculationsListView.setModel(self.calcListModel)