def __init__(self): super().__init__() self.resize(800, 600) mainLayout = QVBoxLayout() players = ("Nadal", "Djokovic", "Federer", "Thiem", "Medvedev") model = QStandardItemModel(len(players), 1) model.setHorizontalHeaderLabels(["Player"]) for row, player in enumerate(players): item = QStandardItem(player) model.setItem(row, 0, item) filter_proxy_model = QSortFilterProxyModel() filter_proxy_model.setSourceModel(model) # case sensitive comment out this line filter_proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive) filter_proxy_model.setFilterKeyColumn(0) search_field = QLineEdit() search_field.setStyleSheet("font-size: 25px; height 30px") search_field.textChanged.connect(filter_proxy_model.setFilterRegExp) mainLayout.addWidget(search_field) table = QTableView() table.setStyleSheet("font-size: 25px") table.verticalHeader().setSectionResizeMode(QHeaderView.Stretch) table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch) table.setModel(filter_proxy_model) mainLayout.addWidget(table) self.setLayout(mainLayout)
def addTasksToDoneTable(self, task): model = QStandardItemModel(len(task), 7) model.setHorizontalHeaderLabels(['_ID', 'TOPIC', 'DETAIL', 'STATUS', 'OWNER', 'CREATEDATE', 'DEADLINE']) for i, j in enumerate(task): id = QStandardItem(str(j['_id'])) topic = QStandardItem(j['topic']) detail = QStandardItem(j['detail']) status = QStandardItem(j['status']) owner = QStandardItem(j['owner']) createdate = QStandardItem(j['createdate']) deadline = QStandardItem(j['deadline']) model.setItem(i, 0, id) model.setItem(i, 1, topic) model.setItem(i, 2, detail) model.setItem(i, 3, status) model.setItem(i, 4, owner) model.setItem(i, 5, createdate) model.setItem(i, 6, deadline) filter_proxy_model = QSortFilterProxyModel() filter_proxy_model.setSourceModel(model) filter_proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive) filter_proxy_model.setFilterKeyColumn(1) self.ui.txtSearch.textChanged.connect(filter_proxy_model.setFilterRegExp) self.ui.tableDone.setModel(filter_proxy_model) self.ui.tableDone.setColumnHidden(0, True) self.ui.tableDone.setColumnHidden(2, True) self.ui.tableDone.setColumnHidden(3, True) self.ui.tableDone.setColumnHidden(4, True) self.ui.tableDone.setColumnHidden(5, True) self.ui.tableDone.setColumnHidden(6, True)
class Autocomplete(QComboBox): def __init__(self, parent = None): super(Autocomplete, self).__init__(parent) self.setFocusPolicy(Qt.StrongFocus) self.setEditable(True) # add a filter model to filter matching items self.pFilterModel = QSortFilterProxyModel(self) self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive) self.pFilterModel.setSourceModel(self.model()) # add a completer, which uses the filter model self.completer = QCompleter(self.pFilterModel, self) # always show all (filtered) completions self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion) self.setCompleter(self.completer) self.resize(500, 30) # connect signals def filter(text): self.pFilterModel.setFilterFixedString(str(text)) self.lineEdit().textEdited.connect(filter) self.completer.activated.connect(self.on_completer_activated) # on selection of an item from the completer, select the corresponding item from combobox def on_completer_activated(self, text): if text: index = self.findText(str(text)) self.setCurrentIndex(index)
def TableViewInsert(self): # INGRESA LOS DATOS A LA TABLA Y HACE BUSQUEDA EN DESCRIPCION self.q = pd.read_sql('SELECT corta, descripcion FROM clave WHERE tipo = %s' %self.x2, engine) print(self.q) self.numero = session.query(Clave.corta).filter_by(tipo=self.x2).count() #aqui se le indica el numero de comlumnas que tendra la tabla self.model = QStandardItemModel(self.numero, 2) #se le da un encabezado a la tabla self.model.setHorizontalHeaderLabels(['Clave', 'Descripcion']) self.tableView.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch) #se meten los datos a la talba for z in range(self.numero): for m in range(2): item = QStandardItem(self.q.iloc[z, m]) if m == 1: item.setToolTip(str(self.q.iloc[z, m])) self.model.setItem(z, m, item) #se instancia la clase , esa clase nos ayuda que al escribir busque algo buscador = QSortFilterProxyModel() #este sirve para que puedan buscar alguna cosa no importa si es en mayusculas o minusculas buscador.setFilterCaseSensitivity(Qt.CaseInsensitive) buscador.setSourceModel(self.model) #aqui le indicamos en que columba de la tabla va a filter cosas segun lo que se escriba buscador.setFilterKeyColumn(1) #aqui envia la señal que si cambia el texto vaya buscando self.LineClaveBusqueda.textChanged.connect(buscador.setFilterRegExp) self.tableView.setModel(buscador)
class ExtendedComboBox(QComboBox): def __init__(self): QComboBox.__init__(self) self.setFocusPolicy(Qt.StrongFocus) self.setEditable(True) self.filter_model = QSortFilterProxyModel(self) self.filter_model.setFilterCaseSensitivity(Qt.CaseInsensitive) self.filter_model.setSourceModel(self.model()) self.completer = QCompleter(self.filter_model, self) self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion) self.setCompleter(self.completer) self.lineEdit().textEdited.connect( self.filter_model.setFilterFixedString) self.completer.activated.connect(self.on_completer_activated) def on_completer_activated(self, text): if text: index = self.findText(text) self.setCurrentIndex(index) self.activated[str].emit(self.itemText(index)) def setModel(self, model): self.setModel(model) self.filter_model.setSourceModel(model) self.completer.setModel(self.filter_model) def setModelColumn(self, column): self.completer.setCompletionColumn(column) self.filter_model.setFilterKeyColumn(column) self.setModelColumn(column)
def __init__(self, settings, directory, check_id_fct, annotations_path, parent=None): super().__init__(parent) # FIXME Delayed refactoring of check_id_fct and annotations_path. # Variables section. library_id = settings["libraryID"] library_type = settings["libraryType"] api_key = settings["apiKey"] self._zotero = ZoteroWrap(library_id, library_type, api_key, directory) # Widgets section. model = ZoteroTableModel(self._zotero, check_id_fct, annotations_path) model.load() proxy_model = QSortFilterProxyModel() proxy_model.setSourceModel(model) proxy_model.setDynamicSortFilter(True) proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive) proxy_model.setFilterKeyColumn(-1) # NB: All columns. self.view = QTableView(self) self.view.setModel(proxy_model) self.view.setCornerButtonEnabled(False) self.view.setEditTriggers(QAbstractItemView.NoEditTriggers) self.view.setSelectionBehavior(QAbstractItemView.SelectRows) self.view.setSelectionMode(QAbstractItemView.SingleSelection) # NB: Triggers a call to sortByColumn() which sorts by the first column. self.view.setSortingEnabled(True) self.view.setWordWrap(False) self.view.verticalHeader().hide() self.filter_edit = FilterEdit(self.view) # NB: The thread does not begin executing until start() is called. self.refresh_thread = ZoteroRefreshThread(model, self) # Layouts section. header_layout = QFormLayout() header_layout.addRow("Filter:", self.filter_edit) header_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow) utils.configure_form_layout(header_layout) main_layout = QVBoxLayout() main_layout.addLayout(header_layout) main_layout.addWidget(self.view) self.setLayout(main_layout) # Signals section. self.filter_edit.textChanged.connect(proxy_model.setFilterFixedString) self.refresh_thread.started.connect(self.refresh_started) self.refresh_thread.finished.connect(self.refresh_finished)
class CustomerSearchDialog(QDialog): def __init__(self): super(CustomerSearchDialog, self).__init__() # Set up the user interface from Designer. self.fields = [] self.data = Customer.objects.all() self.model = QStandardItemModel(len(self.data), 1) self.model.setHorizontalHeaderLabels(['Customer']) self.populate_model() self.filter_proxy_model = QSortFilterProxyModel() self.filter_proxy_model.setSourceModel(self.model) self.filter_proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive) self.filter_proxy_model.setFilterKeyColumn(0) self.ui = Ui_CustomerSearchWidget() self.ui.setupUi(self) self.ui.CustomerSearchField.textChanged.connect( self.filter_proxy_model.setFilterRegExp) self.ui.CustomerResultsTable.setModel(self.filter_proxy_model) # Connect up the buttons. self.ui.CustomerViewButton.clicked.connect(self.get_field_values) selection_model = self.ui.CustomerResultsTable.selectionModel() selection_model.selectionChanged.connect(self.on_selectionChanged) self.selected = "" def populate_model_fields(self): # for row in self.product_data: # print(row) fields = Customer._meta.get_fields(include_parents=False) for field in fields: if not str(field).startswith('<'): self.fields.append(str(field.name)) def get_field_values(self): customer_dicts = Customer.objects.values() for customer in customer_dicts: print(customer) def populate_model(self): for row, customer in enumerate(self.data): print(str(customer)) item = QStandardItem(str(customer)) self.model.setItem(row, 0, item) @pyqtSlot('QItemSelection', 'QItemSelection') def on_selectionChanged(self, selected): print("selected: ") for item in selected.indexes(): if item: self.ui.CustomerSelectionLabel.setText(item.product_data()) self.selected = item.product_data() print(self.selected)
class JoinChannelDialog(QDialog): def __init__(self, parent=None): super().__init__(parent) self.app = QApplication.instance() self.chans = ChatChannels() self.ui = ui_chatchannelslist.Ui_ChannelsListDialog() self.ui.setupUi(self) self.ui.joinButton.clicked.connect(self.onJoinClicked) self.ui.cancelButton.clicked.connect(functools.partial(self.done, 1)) self.channelsModel = QStandardItemModel() self.channelsModel.setHorizontalHeaderLabels(['Channel', 'Connected']) self.channelsProxyModel = QSortFilterProxyModel(self) self.channelsProxyModel.setSourceModel(self.channelsModel) self.channelsProxyModel.setFilterKeyColumn(0) self.channelsProxyModel.setFilterCaseSensitivity(Qt.CaseInsensitive) self.ui.channelsView.setModel(self.channelsProxyModel) self.ui.channelsView.doubleClicked.connect( lambda idx: self.onJoinClicked()) self.ui.channelsView.setEditTriggers(QAbstractItemView.NoEditTriggers) self.ui.searchLine.textChanged.connect(self.onApplySearch) @ipfsOp async def initDialog(self, ipfsop): dagChannels = ipfsop.ctx.currentProfile.dagChatChannels for channel in dagChannels.channels: self.channelsModel.appendRow([ UneditableItem(channel), UneditableItem(str(await self.chans.cnCountByChannel(channel))) ]) await ipfsop.sleep() def onApplySearch(self): self.channelsProxyModel.setFilterRegExp(self.ui.searchLine.text()) def onJoinClicked(self): try: idx = self.ui.channelsView.selectionModel().selectedRows(0).pop() except Exception: return chan = self.channelsProxyModel.data(idx, Qt.DisplayRole) if chan: ensure(self.onJoinChannel(chan)) self.done(1) @ipfsOp async def onJoinChannel(self, ipfsop, channel): log.info(f'Joining channel: {channel}') widget = await self.chans.joinChannel(channel) self.app.mainWindow.registerTab(widget, name=channel, icon=getIcon('chat.png'), current=True, workspace=WS_PEERS)
def __init__(self): # TODO: Shouldnt we use super here? QListView.__init__(self) proxy = QSortFilterProxyModel(self) proxy.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive) self._model = QStandardItemModel(self) proxy.setSourceModel(self._model) self.setModel(proxy)
class ExtendedCombo(QComboBox): def __init__(self, items=None, parent=None): super().__init__(parent) self.setFocusPolicy(Qt.StrongFocus) self.setEditable(True) self.completer = QCompleter(self) # always show all completions self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion) self.pFilterModel = QSortFilterProxyModel(self) self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive) self.completer.setPopup(self.view()) self.setCompleter(self.completer) self.lineEdit().textEdited.connect(self.pFilterModel.setFilterFixedString) self.completer.activated.connect(self.setTextIfCompleterIsClicked) def setItems(self, items: list or set): self.items = list(items) model = QStandardItemModel() for i, student in enumerate(items): item = UserItem(student) model.setItem(i, 0, item) self.setModel(model) self.setModelColumn(0) def setModel(self, model): super(ExtendedCombo, self).setModel(model) self.pFilterModel.setSourceModel(model) self.completer.setModel(self.pFilterModel) def setModelColumn(self, column): self.completer.setCompletionColumn(column) self.pFilterModel.setFilterKeyColumn(column) super(ExtendedCombo, self).setModelColumn(column) def view(self): return self.completer.popup() def index(self): return self.currentIndex() def setTextIfCompleterIsClicked(self, text): if text: index = self.findText(text) self.setCurrentIndex(index) def currentItem(self): return self.items[self.currentIndex()]
class ClickToFlashWhitelistDialog(QDialog, Ui_ClickToFlashWhitelistDialog): """ Class implementing a dialog to manage the ClickToFlash whitelist. """ def __init__(self, whitelist, parent=None): """ Constructor @param whitelist list of whitelisted hosts (list of string) @param parent reference to the parent widget (QWidget) """ super(ClickToFlashWhitelistDialog, self).__init__(parent) self.setupUi(self) self.iconLabel.setPixmap(UI.PixmapCache.getPixmap("flashBlock48.png")) self.__model = QStringListModel(whitelist[:], self) self.__model.sort(0) self.__proxyModel = QSortFilterProxyModel(self) self.__proxyModel.setFilterCaseSensitivity(Qt.CaseInsensitive) self.__proxyModel.setSourceModel(self.__model) self.whitelist.setModel(self.__proxyModel) self.searchEdit.textChanged.connect( self.__proxyModel.setFilterFixedString) self.removeButton.clicked.connect(self.whitelist.removeSelected) self.removeAllButton.clicked.connect(self.whitelist.removeAll) @pyqtSlot() def on_addButton_clicked(self): """ Private slot to add an entry to the whitelist. """ host, ok = QInputDialog.getText( self, self.tr("ClickToFlash Whitelist"), self.tr("Enter host name to add to whitelist:"), QLineEdit.Normal) if ok and host != "" and host not in self.__model.stringList(): self.__model.insertRow(self.__model.rowCount()) self.__model.setData( self.__model.index(self.__model.rowCount() - 1), host) self.__model.sort(0) def getWhitelist(self): """ Public method to get the whitelisted hosts. @return list of whitelisted hosts (list of string) """ return self.__model.stringList()
class SpellingDictionaryEditDialog(QDialog, Ui_SpellingDictionaryEditDialog): """ Class implementing a dialog to edit the various spell checking dictionaries. """ def __init__(self, data, info, parent=None): """ Constructor @param data contents to be edited (string) @param info info string to show at the header (string) @param parent reference to the parent widget (QWidget) """ super(SpellingDictionaryEditDialog, self).__init__(parent) self.setupUi(self) self.infoLabel.setText(info) self.__model = QStringListModel( [line.strip() for line in data.splitlines() if line.strip()], self) self.__model.sort(0) self.__proxyModel = QSortFilterProxyModel(self) self.__proxyModel.setFilterCaseSensitivity(Qt.CaseInsensitive) self.__proxyModel.setDynamicSortFilter(True) self.__proxyModel.setSourceModel(self.__model) self.wordList.setModel(self.__proxyModel) self.searchEdit.textChanged.connect( self.__proxyModel.setFilterFixedString) self.removeButton.clicked.connect(self.wordList.removeSelected) self.removeAllButton.clicked.connect(self.wordList.removeAll) @pyqtSlot() def on_addButton_clicked(self): """ Private slot to handle adding an entry. """ self.__model.insertRow(self.__model.rowCount()) self.wordList.edit( self.__proxyModel.index(self.__model.rowCount() - 1, 0)) def getData(self): """ Public method to get the data. @return data of the dialog (string) """ return os.linesep.join([ line.strip() for line in self.__model.stringList() if line.strip() ]) + os.linesep
class E5ErrorMessageFilterDialog(QDialog, Ui_E5ErrorMessageFilterDialog): """ Class implementing a dialog to manage the list of messages to be ignored. """ def __init__(self, messageFilters, parent=None): """ Constructor @param messageFilters list of message filters to be edited (list of strings) @param parent reference to the parent widget (QWidget) """ super(E5ErrorMessageFilterDialog, self).__init__(parent) self.setupUi(self) self.__model = QStringListModel(messageFilters, self) self.__model.sort(0) self.__proxyModel = QSortFilterProxyModel(self) self.__proxyModel.setFilterCaseSensitivity(Qt.CaseInsensitive) self.__proxyModel.setSourceModel(self.__model) self.filterList.setModel(self.__proxyModel) self.searchEdit.textChanged.connect( self.__proxyModel.setFilterFixedString) self.removeButton.clicked.connect(self.filterList.removeSelected) self.removeAllButton.clicked.connect(self.filterList.removeAll) @pyqtSlot() def on_addButton_clicked(self): """ Private slot to add an entry to the list. """ filter, ok = QInputDialog.getText( self, self.tr("Error Messages Filter"), self.tr("Enter message filter to add to the list:"), QLineEdit.Normal) if ok and filter != "" and filter not in self.__model.stringList(): self.__model.insertRow(self.__model.rowCount()) self.__model.setData( self.__model.index(self.__model.rowCount() - 1), filter) self.__model.sort(0) def getFilters(self): """ Public method to get the list of message filters. @return error message filters (list of strings) """ return self.__model.stringList()[:]
def retranslateUi(self, main_window): _translate = QtCore.QCoreApplication.translate main_window.setWindowTitle(_translate("main_window", "MainWindow")) self.start_date_label.setText(_translate("main_window", "Start Date")) self.end_date_label.setText(_translate("main_window", "End Date")) self.start_lineEdit.setText(_translate("main_window", "MM/DD/YYYY")) self.end_lineEdit.setText(_translate("main_window", "MM/DD/YYYY")) self.submit.setText(_translate("main_window", "Submit")) self.satellite_selector.setItemText( 0, _translate("main_window", "Landsat - 8")) self.satellite_selector.setItemText( 1, _translate("main_window", "Landsat - 7")) self.satellite_selector.setItemText( 2, _translate("main_window", "Landsat - 5")) self.satellite_selector.setItemText( 3, _translate("main_window", "Sentinel - 2")) self.ndwi.setText(_translate("main_window", "NDWI")) self.msavi.setText(_translate("main_window", "MSAVI")) self.ndvi.setText(_translate("main_window", "NDVI")) self.ndmi.setText(_translate("main_window", "NDMI")) self.savi.setText(_translate("main_window", "SAVI")) self.RIC.setText(_translate("main_window", "RASTER IMAGE CALCULATOR")) # self.region_select_push.setText(_translate("main_window", "Select Region")) regions = csv_getter(path='./subdist_boundingBox.csv', just_get=True) model = QStandardItemModel(len(regions), 1) model.setHorizontalHeaderLabels(['Regions']) for row, company in enumerate(regions): item = QStandardItem(company) model.setItem(row, 0, item) filter_proxy_model = QSortFilterProxyModel() filter_proxy_model.setSourceModel(model) filter_proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive) filter_proxy_model.setFilterKeyColumn(0) self.region_tableView.setStyleSheet('font-size: 15px;') self.region_tableView.verticalHeader().setSectionResizeMode( QHeaderView.Stretch) self.region_tableView.horizontalHeader().setSectionResizeMode( QHeaderView.Stretch) self.region_tableView.setModel(filter_proxy_model) self.region_tableView.clicked.connect(self.region_widget.viewClicked)
class BasketDialog(QDialog): def __init__(self): super(BasketDialog, self).__init__() self.basket_data = Basket.objects.all() self.basket_fields = ['Id', 'Customer', 'Date', 'Total TTC'] self.basket_model = QStandardItemModel(len(self.basket_data), 4) self.basket_model.setHorizontalHeaderLabels(self.basket_fields) self.basket_filter_proxy_model = QSortFilterProxyModel() self.basket_filter_proxy_model.setSourceModel(self.basket_model) self.ui = Ui_BasketDialog() self.ui.setupUi(self) self.populate_basket_list() self.selected_basket = "" def populate_basket_list(self): self.populate_baskets_model() self.basket_filter_proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive) self.basket_filter_proxy_model.setFilterKeyColumn(0) self.ui.lineEdit.textChanged.connect(self.basket_filter_proxy_model.setFilterRegExp) self.ui.tableView.setModel(self.basket_filter_proxy_model) # TODO: Set multiple column filter for the model def populate_baskets_model(self): for row, basket in enumerate(self.basket_data): pid = QStandardItem(str(basket.id)) date = QStandardItem(str(basket.date_created.strftime('%d/%m/%Y %H:%M:%S'))) total = QStandardItem(str(000)) self.basket_model.setItem(row, 0, pid) self.basket_model.setItem(row, 1, date) self.basket_model.setItem(row, 2, total) def delete_basket(self): pass def convert_basket_to_sale(self): pass def convert_basket_to_proforma(self): pass def convert_basket_to_order(self): pass def convert_basket_to_invoice(self): pass
class NoCacheHostsDialog(QDialog, Ui_NoCacheHostsDialog): """ Class implementing a dialog to manage the list of hosts not to be cached. """ def __init__(self, parent=None): """ Constructor @param parent reference to the parent widget (QWidget) """ super(NoCacheHostsDialog, self).__init__(parent) self.setupUi(self) self.__model = QStringListModel( Preferences.getHelp("NoCacheHosts"), self) self.__model.sort(0) self.__proxyModel = QSortFilterProxyModel(self) self.__proxyModel.setFilterCaseSensitivity(Qt.CaseInsensitive) self.__proxyModel.setSourceModel(self.__model) self.noCacheList.setModel(self.__proxyModel) self.searchEdit.textChanged.connect( self.__proxyModel.setFilterFixedString) self.removeButton.clicked.connect(self.noCacheList.removeSelected) self.removeAllButton.clicked.connect(self.noCacheList.removeAll) @pyqtSlot() def on_addButton_clicked(self): """ Private slot to add an entry to the list. """ host, ok = QInputDialog.getText( self, self.tr("Not Cached Hosts"), self.tr("Enter host name to add to the list:"), QLineEdit.Normal) if ok and host != "" and host not in self.__model.stringList(): self.__model.insertRow(self.__model.rowCount()) self.__model.setData( self.__model.index(self.__model.rowCount() - 1), host) self.__model.sort(0) def accept(self): """ Public method to accept the dialog data. """ Preferences.setHelp("NoCacheHosts", self.__model.stringList()) super(NoCacheHostsDialog, self).accept()
class SendRefererWhitelistDialog(QDialog, Ui_SendRefererWhitelistDialog): """ Class implementing a dialog to manage the Send Referer whitelist. """ def __init__(self, parent=None): """ Constructor @param parent reference to the parent widget (QWidget) """ super(SendRefererWhitelistDialog, self).__init__(parent) self.setupUi(self) self.__model = QStringListModel( Preferences.getWebBrowser("SendRefererWhitelist"), self) self.__model.sort(0) self.__proxyModel = QSortFilterProxyModel(self) self.__proxyModel.setFilterCaseSensitivity(Qt.CaseInsensitive) self.__proxyModel.setSourceModel(self.__model) self.whitelist.setModel(self.__proxyModel) self.searchEdit.textChanged.connect( self.__proxyModel.setFilterFixedString) self.removeButton.clicked.connect(self.whitelist.removeSelected) self.removeAllButton.clicked.connect(self.whitelist.removeAll) @pyqtSlot() def on_addButton_clicked(self): """ Private slot to add an entry to the whitelist. """ host, ok = QInputDialog.getText( self, self.tr("Send Referer Whitelist"), self.tr("Enter host name to add to the whitelist:"), QLineEdit.Normal) if ok and host != "" and host not in self.__model.stringList(): self.__model.insertRow(self.__model.rowCount()) self.__model.setData( self.__model.index(self.__model.rowCount() - 1), host) self.__model.sort(0) def accept(self): """ Public method to accept the dialog data. """ Preferences.setWebBrowser("SendRefererWhitelist", self.__model.stringList()) super(SendRefererWhitelistDialog, self).accept()
class SpellingDictionaryEditDialog(QDialog, Ui_SpellingDictionaryEditDialog): """ Class implementing a dialog to edit the various spell checking dictionaries. """ def __init__(self, data, info, parent=None): """ Constructor @param data contents to be edited (string) @param info info string to show at the header (string) @param parent reference to the parent widget (QWidget) """ super(SpellingDictionaryEditDialog, self).__init__(parent) self.setupUi(self) self.infoLabel.setText(info) self.__model = QStringListModel(data.splitlines(), self) self.__model.sort(0) self.__proxyModel = QSortFilterProxyModel(self) self.__proxyModel.setFilterCaseSensitivity(Qt.CaseInsensitive) self.__proxyModel.setDynamicSortFilter(True) self.__proxyModel.setSourceModel(self.__model) self.wordList.setModel(self.__proxyModel) self.searchEdit.textChanged.connect( self.__proxyModel.setFilterFixedString) self.removeButton.clicked.connect(self.wordList.removeSelected) self.removeAllButton.clicked.connect(self.wordList.removeAll) @pyqtSlot() def on_addButton_clicked(self): """ Private slot to handle adding an entry. """ self.__model.insertRow(self.__model.rowCount()) self.wordList.edit( self.__proxyModel.index(self.__model.rowCount() - 1, 0)) def getData(self): """ Public method to get the data. @return data of the dialog (string) """ return os.linesep.join( [line for line in self.__model.stringList() if line])
class GuiWriteTreeDock(): ''' GuiWriteTreeDock ''' dock_name = "write-tree-dock" dock_displayed_name = _("Project") def __init__(self): ''' Constructor ''' super(GuiWriteTreeDock, self).__init__() self.widget = None self.core_part = None # CoreWriteTreeDock self.core_part = gui_cfg.core.write_panel_core.get_instance_of( self.dock_name) def get_widget(self): if self.widget is None: self.widget = QWidget() self.ui = write_tree_dock_ui.Ui_WriteTreeDock() self.ui.setupUi(self.widget) if self.core_part is not None: self.ui.treeView.hide() tree_view = write_tree_view.WriteTreeView() self.ui.mainVerticalLayout.addWidget(tree_view) # self.ui.treeView = write_tree_view.WriteTreeView() tree_model = self.core_part.write_tree_model #filter : self.filter = QSortFilterProxyModel(self.widget) self.filter.setFilterKeyColumn(-1) self.filter.setFilterCaseSensitivity(False) self.filter.setSourceModel(tree_model) #model : tree_view.setModel(self.filter) #connect : #self.ui.addPropButton.clicked.connect(self.add_property_row) #self.ui.removePropButton.clicked.connect(self.remove_property_row) self.ui.filterLineEdit.textChanged.connect( self.filter.setFilterFixedString) #TODO: #self.ui.treeView.clicked.connect(self.set_current_row) self.widget.gui_part = self return self.widget
class FilteringComboBox(QComboBox): """Combination of QCombobox and QLineEdit with autocompletionself. Line edit and completer model is taken from QSqlTable mod Args: table (str): db table name containing data for combobox column (str): column name containing data for combobox """ def __init__(self, table, column, placeholderText, parent=None): super(FilteringComboBox, self).__init__(parent) self.parent = parent self.setEditable(True) self.setFocusPolicy(Qt.StrongFocus) self.setInsertPolicy(QComboBox.NoInsert) self.lineEdit().setPlaceholderText(placeholderText) # setup data model self._model = QSqlTableModel(self) self._model.setTable(table) self._model.select() col_num = self._model.fieldIndex(column) self._model.sort(col_num, Qt.AscendingOrder) self.setModel(self._model) self.setModelColumn(col_num) # setup completer self._proxy = QSortFilterProxyModel(self) self._proxy.setFilterCaseSensitivity(Qt.CaseInsensitive) self._proxy.setSourceModel(self._model) self._proxy.setFilterKeyColumn(col_num) self._completer = QCompleter(self) self._completer.setModel(self._proxy) self._completer.setCompletionColumn(col_num) self._completer.activated.connect(self.onCompleterActivated) self._completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion) self.setCompleter(self._completer) self.lineEdit().textEdited.connect(self._proxy.setFilterFixedString) @pyqtSlot(str) def onCompleterActivated(self, text): if not text: return self.setCurrentIndex(self.findText(text)) self.activated[str].emit(self.currentText()) def updateModel(self): self._model.select()
def __init__(self, form_context, parent=None) -> None: super().__init__(parent) self._form_context = form_context self.setObjectName("PayeeSearchWidget") identities = form_context.wallet_api.get_identities() model = PayeeSearchModel(identities) edit_field = QLineEdit() edit_field.setMinimumWidth(200) edit_field.setPlaceholderText("Type a contact name here..") filter_model = QSortFilterProxyModel(edit_field) filter_model.setFilterCaseSensitivity(Qt.CaseInsensitive) filter_model.setSourceModel(model) contact_completer = QCompleter(filter_model, edit_field) contact_completer.setCompletionMode(QCompleter.PopupCompletion) contact_completer.setCaseSensitivity(False) # pylint: disable=unsubscriptable-object contact_completer.activated[QModelIndex].connect( self._on_entry_selected) edit_field.setCompleter(contact_completer) popup = contact_completer.popup() popup.setUniformItemSizes(True) popup.setItemDelegate(PayeeBadgeDelegate(form_context, edit_field)) popup.setSpacing(0) popup.setStyleSheet(""" .QListView { background-color: #F2F2F2; selection-background-color: #D8D8D8; } """) layout = QHBoxLayout() layout.setSpacing(0) layout.setContentsMargins(0, 0, 0, 0) layout.addWidget(edit_field) self.setLayout(layout) self._form_context.wallet_api.contact_changed.connect( self._on_contact_change) self._filter_model = filter_model self.focus_widget = edit_field
class ExtendedComboBox(QComboBox): def __init__(self, parent=None): super(ExtendedComboBox, self).__init__(parent) self.setFocusPolicy(Qt.StrongFocus) self.setEditable(True) # add a filter model to filter matching items self.pFilterModel = QSortFilterProxyModel(self) self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive) self.pFilterModel.setSourceModel(self.model()) # add a completer, which uses the filter model self.completer = QCompleter(self.pFilterModel, self) # always show all (filtered) completions self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion) self.setCompleter(self.completer) # connect signals self.lineEdit().textEdited.connect( self.pFilterModel.setFilterFixedString) self.completer.activated.connect(self.on_completer_activated) # on selection of an item from the completer, select the corresponding item from combobox def on_completer_activated(self, text): if text: index = self.findText(text) self.setCurrentIndex(index) self.activated[str].emit(self.itemText(index)) # on model change, update the models of the filter and completer as well def setModel(self, model): super(ExtendedComboBox, self).setModel(model) self.pFilterModel.setSourceModel(model) self.completer.setModel(self.pFilterModel) # on model column change, update the model column of the filter and completer as well def setModelColumn(self, column): self.completer.setCompletionColumn(column) self.pFilterModel.setFilterKeyColumn(column) super(ExtendedComboBox, self).setModelColumn(column) def wheelEvent(self, e: QtGui.QWheelEvent) -> None: """ 当鼠标轻放在框上,禁止鼠标滚轮滚动选项 :param e: :return: """ pass
class ExtendedCombo(QComboBox): def __init__(self, parent=None): super(ExtendedCombo, self).__init__(parent) self.setFocusPolicy(Qt.StrongFocus) self.setEditable(True) # add a filter model to filter matching items self.pFilterModel = QSortFilterProxyModel(self) self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive) self.pFilterModel.setSourceModel(self.model()) # add a completer, which uses the filter model self.completer = QCompleter(self.pFilterModel, self) # always show all (filtered) completions self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion) self.setCompleter(self.completer) # connect signals self.lineEdit().textEdited.connect( self.pFilterModel.setFilterFixedString) self.completer.activated.connect(self.on_completer_activated) self.cur_index = self.currentIndex() self.text = self.currentText() # on selection of an item from the completer, select the corresponding item from combobox def on_completer_activated(self, text): if text: index = self.findText(text) self.setCurrentIndex(index) C = TextInstance C.text = text else: C = TextInstance C.text = self.currentText() def update(self): return self.text # on model change, update the models of the filter and completer as well def setModel(self, model): super(ExtendedCombo, self).setModel(model) self.pFilterModel.setSourceModel(model) self.completer.setModel(self.pFilterModel) # on model column change, update the model column of the filter and completer as well def setModelColumn(self, column): self.completer.setCompletionColumn(column) self.pFilterModel.setFilterKeyColumn(column) super(ExtendedCombo, self).setModelColumn(column)
class CompletingComboBox(QComboBox): """An editable combo box that filters and autocompletes.""" def __init__(self, parent=None): super().__init__(parent) self.setEditable(True) self.filter = QSortFilterProxyModel(self) self.filter.setFilterCaseSensitivity(Qt.CaseInsensitive) self.filter.setSourceModel(self.model()) self.completer = QCompleter(self.filter, self) self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion) self.setCompleter(self.completer) self.lineEdit().textEdited.connect( self.filter.setFilterFixedString) self.currentIndexChanged.connect(self._index_changed) def _index_changed(self, index): self.lineEdit().selectAll()
class SearchableComboBox(QComboBox): def __init__(self, parent=None): QComboBox.__init__(self, parent) self.setFocusPolicy(Qt.StrongFocus) self.setEditable(True) self.completer = QCompleter(self) self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion) self.p_filter_model = QSortFilterProxyModel() self.p_filter_model.setFilterCaseSensitivity(Qt.CaseInsensitive) self.completer.setPopup(self.completer.popup()) self.setCompleter(self.completer) self.lineEdit().textEdited.connect( self.p_filter_model.setFilterFixedString) def setModel(self, model): super().setModel(model) self.p_filter_model.setSourceModel(model) self.completer.setModel(self.p_filter_model) def setModelColumn(self, column): self.completer.setCompletionColumn(column) self.p_filter_model.setFilterKeyColumn(column) super().setModelColumn(column) def setTextIfCompleterIsClicked(self, text): if text: self.setCurrentIndex(self.findText(text)) def setItems(self, items): self.clear() model = QStandardItemModel() for i, word in enumerate(items): item = QStandardItem(word) model.setItem(i, 0, item) self.setModel(model) self.setModelColumn(0)
class SearchableComboBox(QComboBox): def __init__(self, string_list, parent=None): super(SearchableComboBox, self).__init__(parent) self.setFocusPolicy(Qt.StrongFocus) self.setEditable(True) # add a filter model to filter matching items self.pFilterModel = QSortFilterProxyModel(self) self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive) self.pFilterModel.setSourceModel(self.model()) # add a completer, which uses the filter model self.completer = QCompleter(self.pFilterModel, self) # always show all (filtered) completions self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion) self.setCompleter(self.completer) # connect signals self.lineEdit().textEdited.connect(self.pFilterModel.setFilterFixedString) self.completer.activated.connect(self.on_completer_activated) # either fill the standard model of the combobox self.addItems(string_list) # on selection of an item from the completer, select the corresponding item from combobox def on_completer_activated(self, text): if text: index = self.findText(text) self.setCurrentIndex(index) self.activated[str].emit(self.itemText(index)) # on model change, update the models of the filter and completer as well def setModel(self, model): super(SearchableComboBox, self).setModel(model) self.pFilterModel.setSourceModel(model) self.completer.setModel(self.pFilterModel) # on model column change, update the model column of the filter and completer as well def setModelColumn(self, column): self.completer.setCompletionColumn(column) self.pFilterModel.setFilterKeyColumn(column) super(SearchableComboBox, self).setModelColumn(column)
def __init__(self, form_context, parent=None): super().__init__(parent) self._form_context = form_context self.setObjectName("PaymentAmount") amount_widget = QLineEdit() currency_widget = QLineEdit() currency_combo = QComboBox() currency_combo.setEditable(True) filter_model = QSortFilterProxyModel(currency_combo) filter_model.setFilterCaseSensitivity(Qt.CaseInsensitive) filter_model.setSourceModel(currency_combo.model()) contact_completer = QCompleter(filter_model, currency_combo) contact_completer.setCompletionMode( QCompleter.UnfilteredPopupCompletion) currency_combo.setCompleter(contact_completer) # base unit. # selected fiat currency. options = [] base_unit = form_context.wallet_api.get_base_unit() options.append(base_unit) fiat_unit = form_context.wallet_api.get_fiat_unit() if fiat_unit is not None: options.append(fiat_unit) currency_combo.addItems(options) currency_combo.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed) layout = QHBoxLayout() layout.setContentsMargins(0, 0, 0, 0) layout.addWidget(currency_combo) layout.addWidget(amount_widget) self.setLayout(layout) self._currency_combo_options = options self._currency_combo = currency_combo self._amount_widget = amount_widget self._form_context.set_payment_amount.connect(self._set_payment_amount)
class ExtendedCombo(QComboBox): def __init__(self): super().__init__() self.setFocusPolicy(Qt.StrongFocus) self.setEditable(True) self.completer = QCompleter(self) # always show all completions self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion) self.pFilterModel = QSortFilterProxyModel(self) self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive) self.completer.setPopup(self.view()) self.setCompleter(self.completer) self.lineEdit().textEdited[str].connect( self.pFilterModel.setFilterFixedString) self.completer.activated.connect(self.setTextIfCompleterIsClicked) def setModel(self, model): super(ExtendedCombo, self).setModel(model) self.pFilterModel.setSourceModel(model) self.completer.setModel(self.pFilterModel) def setModelColumn(self, column): self.completer.setCompletionColumn(column) self.pFilterModel.setFilterKeyColumn(column) super(ExtendedCombo, self).setModelColumn(column) def view(self): return self.completer.popup() def index(self): return self.currentIndex() def setTextIfCompleterIsClicked(self, text): if text: index = self.findText(text) self.setCurrentIndex(index)
class SelectionDialog(CustomStandardDialog, Ui_SelectionDialog): def __init__(self, source_table, selection_mode=QAbstractItemView.ExtendedSelection, selection_behavior=QAbstractItemView.SelectItems): CustomStandardDialog.__init__(self) self.setupUi(self) self.source_table = source_table self.resize(self.dataView.horizontalHeader().width(), self.height()) self.proxyModel = QSortFilterProxyModel(self) self.proxyModel.setSourceModel(source_table) self.proxyModel.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive) self.proxyModel.setFilterKeyColumn(-1) self.dataView.setModel(self.proxyModel) self.dataView.setSelectionBehavior(selection_behavior) self.dataView.setSelectionMode(selection_mode) self.proxyModel.sort(0) self.dataView.selectionModel().selectionChanged.connect( self.activate_button) self.dataView.doubleClicked.connect(self.accept) self.restore_dialog_geometry() def selected_items(self): return [ self.source_table.item_from_row(x) for x in self.dataView.get_selected_rows() ] @QtCore.pyqtSlot() def activate_button(self): self.buttonBox.button(QDialogButtonBox.Ok).setEnabled( len(self.dataView.selectedIndexes())) @QtCore.pyqtSlot(str) def update_filter(self, new): self.proxyModel.setFilterFixedString(new)
def __init__(self): super().__init__() self.resize(800, 600) mainLayout = QVBoxLayout() df = pd.read_csv( "C:\Users\TESstudent\Desktop\IB\Computer Science\python_scraping_demo\espn_ranking.csv" ) players = (df.iloc[:, 1]) model = QStandardItemModel(len(players), 1) model.setHorizontalHeaderLabels(["Player"]) for row, player in enumerate(players): item = QStandardItem(player) model.setItem(row, 0, item) filter_proxy_model = QSortFilterProxyModel() filter_proxy_model.setSourceModel(model) # case sensitive comment out this line filter_proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive) filter_proxy_model.setFilterKeyColumn(0) search_field = QLineEdit() search_field.setStyleSheet("font-size: 25px; height 30px") search_field.textChanged.connect(filter_proxy_model.setFilterRegExp) mainLayout.addWidget(search_field) table = QTableView() table.setStyleSheet("font-size: 25px") table.verticalHeader().setSectionResizeMode(QHeaderView.Stretch) table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch) table.setModel(filter_proxy_model) mainLayout.addWidget(table) self.setLayout(mainLayout)
class SecuritiesSelector(QComboBox): class SingletonStorage(metaclass=ThreadSafeSingleton): def __init__(self): self.__stock_list = [] self.__lock = threading.Lock() self.__refresh_thread = None def get_stock_list(self) -> list: with self.__lock: return self.__stock_list.copy() def refresh_stock_list(self, sas_if: sasIF): with self.__lock: if self.__refresh_thread is None: self.__refresh_thread = threading.Thread( target=self.__update_stock_list, name='SecuritiesSelectorRefresh', args=(sas_if, )) self.__refresh_thread.start() def __update_stock_list(self, sas_if: sasIF): stock_list = sas_if.sas_get_stock_info_list() with self.__lock: self.__stock_list = stock_list self.__refresh_thread = None def __init__(self, sas_if: sasIF, parent=None): super(SecuritiesSelector, self).__init__(parent) self.__sas_if: sasIF = sas_if self.__timer = QTimer() self.__timer.setInterval(1000) self.__timer.timeout.connect(self.on_timer) if self.__sas_if is not None: # Timer for update stock list self.__timer.start() self.setFocusPolicy(Qt.StrongFocus) self.setEditable(True) self.addItem('Loading...') # add a filter model to filter matching items self.pFilterModel = QSortFilterProxyModel(self) self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive) self.pFilterModel.setSourceModel(self.model()) # add a completer, which uses the filter model self.completer = QCompleter(self.pFilterModel, self) # always show all (filtered) completions self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion) self.setCompleter(self.completer) # connect signals self.lineEdit().textEdited.connect( self.pFilterModel.setFilterFixedString) self.completer.activated.connect(self.on_completer_activated) # def keyPressEvent(self, event): # super(SecuritiesSelector, self).keyPressEvent(event) # key = event.key() # if event.key() == QtCore.Qt.Key_Return: # print('return key pressed') # else: # print('key pressed: %i' % key) def on_timer(self): # Check stock list ready and update combobox # if self.__data_utility is not None and \ # self.__data_utility.stock_cache_ready(): # stock_list = self.__data_utility.get_stock_list() stock_list = SecuritiesSelector.SingletonStorage().get_stock_list() if len(stock_list) > 0: self.clear() for stock_identity, stock_name in stock_list: self.addItem(stock_identity + ' | ' + stock_name, stock_identity) self.__timer.stop() else: SecuritiesSelector.SingletonStorage().refresh_stock_list( self.__sas_if) # on selection of an item from the completer, select the corresponding item from combobox def on_completer_activated(self, text: str): if self.__data_utility is None or \ not self.__data_utility.stock_cache_ready(): return if text is not None and text != '': self.__data_utility.guess_securities(text) index = self.findData(text) self.setCurrentIndex(index) self.activated[str].emit(self.itemText(index)) def setModel(self, model): super(QComboBox, self).setModel(model) self.pFilterModel.setSourceModel(model) self.completer.setModel(self.pFilterModel) def setModelColumn(self, column): self.completer.setCompletionColumn(column) self.pFilterModel.setFilterKeyColumn(column) super(QComboBox, self).setModelColumn(column) def select_security(self, security: str, linkage: bool): for index in range(self.count()): stock_identity = self.itemData(index) if stock_identity == security: self.setCurrentIndex(index) break def get_input_securities(self) -> str: # select_index = self.currentIndex() # if select_index >= 0: # return self.itemData(select_index) # else: input_securities = self.currentText() if '|' in input_securities: input_securities = input_securities.split('|')[0].strip() return input_securities.strip() def get_select_securities(self) -> str: select_index = self.currentIndex() return self.itemData(select_index) if select_index >= 0 else ''
class ReferenceSpectraDialog(QDialog): fits_picked = pyqtSignal(str) 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 set_main_spectrum(self, spectrum): self.main_spectrum = spectrum 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 load_fits(self): original_index = self.model.mapToSource(self.ui.entries.selectionModel().selectedIndexes()[0]) entry = self.full_model.item(original_index.row()).data() self.fits_picked.emit(self.reference_catalogues.fits(entry)) def setup_menu(self, toolbar, axes, settings): self.current_line = None reference_action = QtCommons.addToolbarPopup(toolbar, "Reference") reference_action.menu().addAction("Reference library", lambda: self.show()) reference_action.menu().addAction("Load from FITS file", lambda: open_file_sticky('Open Reference Profile', FITS_EXTS, lambda f: self.__open_reference(f[0], axes), settings, REFERENCE )) self.close_action = reference_action.menu().addAction("Close", lambda: self.__close_reference(axes)) self.close_action.setEnabled(False) self.fits_picked.connect(lambda f: self.__open_reference(f, axes)) self.blackbody_menu = blackbody.BlackBodyAction(lambda bb: self.blackbody(bb, axes), reference_action.menu()) return reference_action.menu() def blackbody(self, blackbody, axes): self.__open(blackbody.spectrum(), axes) def __open_reference(self, file, axes): fits_spectrum = FitsSpectrum(fits.open(file)) self.__open(fits_spectrum.spectrum, axes) def __open(self, spectrum, axes): self.__close_reference(axes) if spectrum.dispersion() < 0.4 and spectrum.dispersion() > 0: spectrum.resample(spectrum.dispersion() /0.4) if(self.main_spectrum): print("Cutting spectrum: {0}, {1}".format(self.main_spectrum.wavelengths[0], self.main_spectrum.wavelengths[-1])) spectrum.cut_lambda(self.main_spectrum.wavelengths[0], self.main_spectrum.wavelengths[-1]) spectrum.normalize_to_max() self.current_line = Line2D(spectrum.wavelengths, spectrum.fluxes, color='gray') axes.add_line(self.current_line) axes.figure.canvas.draw() self.close_action.setEnabled(True) def __close_reference(self, axes): self.close_action.setEnabled(False) if self.current_line: try: # TODO: verify self.current_line.remove() self.current_line = None axes.figure.canvas.draw() except: pass
class GuiPropertyDock(): ''' GuiPropertyDock ''' dock_name = "properties-dock" dock_displayed_name = _("Properties") def __init__(self): ''' Constructor ''' super(GuiPropertyDock, self).__init__() self.widget = None self.core_part = None # CorePropertyDock self._sheet_id = None self.tree_sheet = None @property def sheet_id(self): return self._sheet_id @sheet_id.setter def sheet_id(self, sheet_id): if self._sheet_id == sheet_id: pass self._sheet_id = sheet_id if self.sheet_id is not None: self.tree_sheet = gui_cfg.core.tree_sheet_manager.get_tree_sheet_from_sheet_id( self.sheet_id) self.core_part = self.tree_sheet.get_instance_of(self.dock_name) self.core_part.sheet_id = sheet_id def get_widget(self): if self.widget is None: self.widget = QWidget() self.ui = properties_dock_ui.Ui_PropertiesDock() self.ui.setupUi(self.widget) if self.tree_sheet is not None and self.core_part is not None: table_model = self.core_part.property_table_model # filter : self.filter = QSortFilterProxyModel(self.widget) self.filter.setFilterKeyColumn(-1) self.filter.setFilterCaseSensitivity(False) self.filter.setSourceModel(table_model) # model : self.ui.tableView.setModel(self.filter) # connect : self.ui.addPropButton.clicked.connect(self.add_property_row) self.ui.removePropButton.clicked.connect( self.remove_property_row) self.ui.filterLineEdit.textChanged.connect( self.filter.setFilterFixedString) self.ui.tableView.clicked.connect(self.set_current_row) self.widget.gui_part = self return self.widget @pyqtSlot() def add_property_row(self): index = self.filter.mapToSource(self.ui.tableView.currentIndex()) self.core_part.add_property_row(index) @pyqtSlot() def remove_property_row(self): index = self.filter.mapToSource(self.ui.tableView.currentIndex()) self.core_part.remove_property_row(index) @pyqtSlot('QModelIndex') def set_current_row(self, model_index): self.ui.tableView.setCurrentIndex(model_index)
class TextEditHandler(logging.Handler): colorMap = { logging.DEBUG: Qt.gray, logging.INFO: Qt.green, logging.WARNING: Qt.darkYellow, logging.ERROR: Qt.red, } PREFIX_MAX_SIZE = 30 VALID_PREFIX = re.compile(r'[^\w ]') @contextmanager def useForLogger(self, loggerName: str): self.reset() tagLogger = logging.getLogger(loggerName) tagLogger.addHandler(self) yield tagLogger.removeHandler(self) def __init__(self, textEdit: QTextEdit, treeView: QTreeView, filterLineEdit: QLineEdit = None): super().__init__() self.treeView = treeView self.textEdit = textEdit self.filterLineEdit = filterLineEdit self.model = QStandardItemModel(self.treeView) self.filterModel = QSortFilterProxyModel(self.treeView) self.filterModel.setSourceModel(self.model) self.filterModel.setFilterCaseSensitivity(Qt.CaseInsensitive) self.filterModel.setRecursiveFilteringEnabled(True) self.treeView.setModel(self.filterModel) if self.filterLineEdit is not None: self.filterLineEdit.textChanged.connect( self.filterModel.setFilterRegExp) self.treeView.setHeaderHidden(True) self.topItem = None self._groups: List[str] = [] self._prefix: Dict[str, QStandardItem] = {} self.reset() def reset(self): self.model.clear() self.topItem = QStandardItem('Top Item') self.model.setItem(0, 0, self.topItem) self._groups.clear() self._prefix.clear() def emit(self, record: logging.LogRecord): msg = self.format(record) color = self.colorMap.get(record.levelno, Qt.black) self.addText(msg, color) self.addGroup(msg) self.treeView.expandToDepth(0) def addText(self, text: str, color: QColor = None): with changeColor(self.textEdit, color): self.textEdit.insertPlainText(text + '\n') self.textEdit.moveCursor(QTextCursor.End) def addGroup(self, text: str): self._groups.append(text) validPrefix = self.VALID_PREFIX.split(text, maxsplit=1)[0] item = QStandardItem(text) if existingItem := self._findItemWithExistingPrefix(validPrefix): parentItem = existingItem elif biggestPrefix := self._getBiggestCommonPrefix(validPrefix): assert biggestPrefix is not None item, biggestPrefixText, prefixSize = biggestPrefix parentItem = self._addPrefix(validPrefix, prefixSize) self._moveItems(parentItem, validPrefix)
class VistaListaProdotti(QWidget): def __init__(self, parent=None): super(VistaListaProdotti, self).__init__(parent) self.carrello = ControlloreCarrello() self.controller = ControlloreListaProdotti() self.setWindowIcon(QtGui.QIcon('logos/logo.png')) main_layout = QHBoxLayout() v_layout = QVBoxLayout() self.list_view = QListView() self.update_ui() #Crea un elenco fittizio sopra l'elenco reale per poter usare la barra di ricerca self.filter_proxy_model = QSortFilterProxyModel() self.filter_proxy_model.setSourceModel(self.listview_model) self.filter_proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive) self.filter_proxy_model.setFilterKeyColumn(0) self.list_view.setModel(self.filter_proxy_model) search_field = QLineEdit() search_field.setStyleSheet('font-size: 15px; height: 30px;') search_field.textChanged.connect( self.filter_proxy_model.setFilterRegExp) v_layout.addWidget(search_field) v_layout.addWidget(self.list_view) main_layout.addLayout(v_layout) buttons_layout = QVBoxLayout() buttons_layout.addItem(QSpacerItem(40, 40)) #Bottone per aprire un prodotto open_button = QPushButton("Apri") open_button.clicked.connect(self.show_selected_info) buttons_layout.addWidget(open_button) #Bottone per creare un nuovo prodotto new_button = QPushButton("Nuovo") new_button.clicked.connect(self.show_new_prodotto) buttons_layout.addWidget(new_button) buttons_layout.addStretch() main_layout.addLayout(buttons_layout) self.setLayout(main_layout) self.resize(600, 300) self.setWindowTitle("Lista Prodotti") #Metodo che mostra a schermo le informazioni del prodotto selezionato def show_selected_info(self): try: sourceindex = self.list_view.selectedIndexes()[0].row() prodotto_selezionato = self.controller.get_prodotto_by_index( sourceindex) self.vista_prodotto = VistaProdotto( prodotto_selezionato, self.controller.elimina_prodotto_by_id, self.update_ui, self.carrello) self.vista_prodotto.show() except IndexError: QMessageBox.critical(self, 'Errore', 'Per favore, seleziona un prodotto', QMessageBox.Ok, QMessageBox.Ok) #Metodo aprire la vista di inserimento del nuovo prodotto def show_new_prodotto(self): self.vista_inserisci_prodotto = VistaInserisciProdotto( self.controller, self.update_ui) self.vista_inserisci_prodotto.show() #Metodo che serve per generare e/o aggiornare la vista def update_ui(self): self.listview_model = QStandardItemModel(self.list_view) for prodotto in self.controller.get_lista_dei_prodotti(): item = QStandardItem() item.setText(prodotto.marca + " " + prodotto.nome) item.setEditable(False) font = item.font() font.setPointSize(18) item.setFont(font) self.listview_model.appendRow(item) self.list_view.setModel(self.listview_model) # salva i dati sul file pickle alla chiusura della view def closeEvent(self, event): self.controller.save_data() #Metodo per collegare l'indice selezionato all'elenco fittizio all'indice dell'elenco reale def toSourceIndex(self, index): return self.filter_proxy_model.mapToSource(index).row()
def main(icon_spec): app = QApplication(sys.argv) main_window = QMainWindow() def sigint_handler(*args): main_window.close() signal.signal(signal.SIGINT, sigint_handler) # the timer enables triggering the sigint_handler signal_timer = QTimer() signal_timer.start(100) signal_timer.timeout.connect(lambda: None) tool_bar = QToolBar() main_window.addToolBar(Qt.TopToolBarArea, tool_bar) table_view = QTableView() table_view.setSelectionBehavior(QAbstractItemView.SelectRows) table_view.setSelectionMode(QAbstractItemView.SingleSelection) table_view.setSortingEnabled(True) main_window.setCentralWidget(table_view) proxy_model = QSortFilterProxyModel() proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive) proxy_model.setFilterKeyColumn(1) table_view.setModel(proxy_model) proxy_model.layoutChanged.connect(table_view.resizeRowsToContents) item_model = QStandardItemModel() proxy_model.setSourceModel(item_model) # get all icons and their available sizes icons = [] all_sizes = set([]) for context, icon_names in icon_spec: for icon_name in icon_names: icon = QIcon.fromTheme(icon_name) sizes = [] for size in icon.availableSizes(): size = (size.width(), size.height()) sizes.append(size) all_sizes.add(size) sizes.sort() icons.append({ 'context': context, 'icon_name': icon_name, 'icon': icon, 'sizes': sizes, }) all_sizes = list(all_sizes) all_sizes.sort() # input field for filter def filter_changed(value): proxy_model.setFilterRegExp(value) table_view.resizeRowsToContents() filter_line_edit = QLineEdit() filter_line_edit.setMaximumWidth(200) filter_line_edit.setPlaceholderText('Filter name') filter_line_edit.setToolTip('Filter name optionally using regular expressions (' + QKeySequence(QKeySequence.Find).toString() + ')') filter_line_edit.textChanged.connect(filter_changed) tool_bar.addWidget(filter_line_edit) # actions to toggle visibility of available sizes/columns def action_toggled(index): column = 2 + index table_view.setColumnHidden(column, not table_view.isColumnHidden(column)) table_view.resizeColumnsToContents() table_view.resizeRowsToContents() signal_mapper = QSignalMapper() for i, size in enumerate(all_sizes): action = QAction('%dx%d' % size, tool_bar) action.setCheckable(True) action.setChecked(True) tool_bar.addAction(action) action.toggled.connect(signal_mapper.map) signal_mapper.setMapping(action, i) # set tool tip and handle key sequence tool_tip = 'Toggle visibility of column' if i < 10: digit = ('%d' % (i + 1))[-1] tool_tip += ' (%s)' % QKeySequence('Ctrl+%s' % digit).toString() action.setToolTip(tool_tip) signal_mapper.mapped.connect(action_toggled) # label columns header_labels = ['context', 'name'] for width, height in all_sizes: header_labels.append('%dx%d' % (width, height)) item_model.setColumnCount(len(header_labels)) item_model.setHorizontalHeaderLabels(header_labels) # fill rows item_model.setRowCount(len(icons)) for row, icon_data in enumerate(icons): # context item = QStandardItem(icon_data['context']) item.setFlags(item.flags() ^ Qt.ItemIsEditable) item_model.setItem(row, 0, item) # icon name item = QStandardItem(icon_data['icon_name']) item.setFlags(item.flags() ^ Qt.ItemIsEditable) item_model.setItem(row, 1, item) for index_in_all_sizes, size in enumerate(all_sizes): column = 2 + index_in_all_sizes if size in icon_data['sizes']: # icon as pixmap to keep specific size item = QStandardItem('') pixmap = icon_data['icon'].pixmap(size[0], size[1]) item.setData(pixmap, Qt.DecorationRole) item.setFlags(item.flags() ^ Qt.ItemIsEditable) item_model.setItem(row, column, item) else: # single space to be sortable against icons item = QStandardItem(' ') item.setFlags(item.flags() ^ Qt.ItemIsEditable) item_model.setItem(row, column, item) table_view.resizeColumnsToContents() # manually set row heights because resizeRowsToContents is not working properly for row, icon_data in enumerate(icons): if len(icon_data['sizes']) > 0: max_size = icon_data['sizes'][-1] table_view.setRowHeight(row, max_size[1]) # enable focus find (ctrl+f) and toggle columns (ctrl+NUM) def main_window_keyPressEvent(self, event, old_keyPressEvent=QMainWindow.keyPressEvent): if event.matches(QKeySequence.Find): filter_line_edit.setFocus() return if event.modifiers() == Qt.ControlModifier and event.key() >= Qt.Key_0 and event.key() <= Qt.Key_9: index = event.key() - Qt.Key_1 if event.key() == Qt.Key_0: index += 10 action = signal_mapper.mapping(index) if action: action.toggle() return old_keyPressEvent(self, event) main_window.keyPressEvent = MethodType(main_window_keyPressEvent, table_view) # enable copy (ctrl+c) name of icon to clipboard def table_view_keyPressEvent(self, event, old_keyPressEvent=QTableView.keyPressEvent): if event.matches(QKeySequence.Copy): selection_model = self.selectionModel() if selection_model.hasSelection(): index = selection_model.selectedRows()[0] source_index = self.model().mapToSource(index) item = self.model().sourceModel().item(source_index.row(), 1) icon_name = item.data(Qt.EditRole) app.clipboard().setText(icon_name.toString()) return old_keyPressEvent(self, event) table_view.keyPressEvent = MethodType(table_view_keyPressEvent, table_view) main_window.showMaximized() return app.exec_()
class TileStampsDock(QDockWidget): setStamp = pyqtSignal(TileStamp) def __init__(self, stampManager, parent = None): super().__init__(parent) self.mTileStampManager = stampManager self.mTileStampModel = stampManager.tileStampModel() self.mProxyModel = QSortFilterProxyModel(self.mTileStampModel) self.mFilterEdit = QLineEdit(self) self.mNewStamp = QAction(self) self.mAddVariation = QAction(self) self.mDuplicate = QAction(self) self.mDelete = QAction(self) self.mChooseFolder = QAction(self) self.setObjectName("TileStampsDock") self.mProxyModel.setSortLocaleAware(True) self.mProxyModel.setSortCaseSensitivity(Qt.CaseInsensitive) self.mProxyModel.setFilterCaseSensitivity(Qt.CaseInsensitive) self.mProxyModel.setSourceModel(self.mTileStampModel) self.mProxyModel.sort(0) self.mTileStampView = TileStampView(self) self.mTileStampView.setModel(self.mProxyModel) self.mTileStampView.setVerticalScrollMode(QAbstractItemView.ScrollPerPixel) self.mTileStampView.header().setStretchLastSection(False) self.mTileStampView.header().setSectionResizeMode(0, QHeaderView.Stretch) self.mTileStampView.header().setSectionResizeMode(1, QHeaderView.ResizeToContents) self.mTileStampView.setContextMenuPolicy(Qt.CustomContextMenu) self.mTileStampView.customContextMenuRequested.connect(self.showContextMenu) self.mNewStamp.setIcon(QIcon(":images/16x16/document-new.png")) self.mAddVariation.setIcon(QIcon(":/images/16x16/add.png")) self.mDuplicate.setIcon(QIcon(":/images/16x16/stock-duplicate-16.png")) self.mDelete.setIcon(QIcon(":images/16x16/edit-delete.png")) self.mChooseFolder.setIcon(QIcon(":images/16x16/document-open.png")) Utils.setThemeIcon(self.mNewStamp, "document-new") Utils.setThemeIcon(self.mAddVariation, "add") Utils.setThemeIcon(self.mDelete, "edit-delete") Utils.setThemeIcon(self.mChooseFolder, "document-open") self.mFilterEdit.setClearButtonEnabled(True) self.mFilterEdit.textChanged.connect(self.mProxyModel.setFilterFixedString) self.mTileStampModel.stampRenamed.connect(self.ensureStampVisible) self.mNewStamp.triggered.connect(self.newStamp) self.mAddVariation.triggered.connect(self.addVariation) self.mDuplicate.triggered.connect(self.duplicate) self.mDelete.triggered.connect(self.delete_) self.mChooseFolder.triggered.connect(self.chooseFolder) self.mDuplicate.setEnabled(False) self.mDelete.setEnabled(False) self.mAddVariation.setEnabled(False) widget = QWidget(self) layout = QVBoxLayout(widget) layout.setContentsMargins(5, 5, 5, 5) buttonContainer = QToolBar() buttonContainer.setFloatable(False) buttonContainer.setMovable(False) buttonContainer.setIconSize(QSize(16, 16)) buttonContainer.addAction(self.mNewStamp) buttonContainer.addAction(self.mAddVariation) buttonContainer.addAction(self.mDuplicate) buttonContainer.addAction(self.mDelete) stretch = QWidget() stretch.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum) buttonContainer.addWidget(stretch) buttonContainer.addAction(self.mChooseFolder) listAndToolBar = QVBoxLayout() listAndToolBar.setSpacing(0) listAndToolBar.addWidget(self.mFilterEdit) listAndToolBar.addWidget(self.mTileStampView) listAndToolBar.addWidget(buttonContainer) layout.addLayout(listAndToolBar) selectionModel = self.mTileStampView.selectionModel() selectionModel.currentRowChanged.connect(self.currentRowChanged) self.setWidget(widget) self.retranslateUi() def changeEvent(self, e): super().changeEvent(e) x = e.type() if x==QEvent.LanguageChange: self.retranslateUi() else: pass def keyPressEvent(self, event): x = event.key() if x==Qt.Key_Delete or x==Qt.Key_Backspace: self.delete_() return super().keyPressEvent(event) def currentRowChanged(self, index): sourceIndex = self.mProxyModel.mapToSource(index) isStamp = self.mTileStampModel.isStamp(sourceIndex) self.mDuplicate.setEnabled(isStamp) self.mDelete.setEnabled(sourceIndex.isValid()) self.mAddVariation.setEnabled(isStamp) if (isStamp): self.setStamp.emit(self.mTileStampModel.stampAt(sourceIndex)) else: variation = self.mTileStampModel.variationAt(sourceIndex) if variation: # single variation clicked, use it specifically self.setStamp.emit(TileStamp(Map(variation.map))) def showContextMenu(self, pos): index = self.mTileStampView.indexAt(pos) if (not index.isValid()): return menu = QMenu() sourceIndex = self.mProxyModel.mapToSource(index) if (self.mTileStampModel.isStamp(sourceIndex)): addStampVariation = QAction(self.mAddVariation.icon(), self.mAddVariation.text(), menu) deleteStamp = QAction(self.mDelete.icon(), self.tr("Delete Stamp"), menu) deleteStamp.triggered.connect(self.delete_) addStampVariation.triggered.connect(self.addVariation) menu.addAction(addStampVariation) menu.addSeparator() menu.addAction(deleteStamp) else : removeVariation = QAction(QIcon(":/images/16x16/remove.png"), self.tr("Remove Variation"), menu) Utils.setThemeIcon(removeVariation, "remove") removeVariation.triggered.connect(self.delete_) menu.addAction(removeVariation) menu.exec(self.mTileStampView.viewport().mapToGlobal(pos)) def newStamp(self): stamp = self.mTileStampManager.createStamp() if (self.isVisible() and not stamp.isEmpty()): stampIndex = self.mTileStampModel.index(stamp) if (stampIndex.isValid()): viewIndex = self.mProxyModel.mapFromSource(stampIndex) self.mTileStampView.setCurrentIndex(viewIndex) self.mTileStampView.edit(viewIndex) def delete_(self): index = self.mTileStampView.currentIndex() if (not index.isValid()): return sourceIndex = self.mProxyModel.mapToSource(index) self.mTileStampModel.removeRow(sourceIndex.row(), sourceIndex.parent()) def duplicate(self): index = self.mTileStampView.currentIndex() if (not index.isValid()): return sourceIndex = self.mProxyModel.mapToSource(index) if (not self.mTileStampModel.isStamp(sourceIndex)): return stamp = self.mTileStampModel.stampAt = TileStamp(sourceIndex) self.mTileStampModel.addStamp(stamp.clone()) def addVariation(self): index = self.mTileStampView.currentIndex() if (not index.isValid()): return sourceIndex = self.mProxyModel.mapToSource(index) if (not self.mTileStampModel.isStamp(sourceIndex)): return stamp = self.mTileStampModel.stampAt(sourceIndex) self.mTileStampManager.addVariation(stamp) def chooseFolder(self): prefs = Preferences.instance() stampsDirectory = prefs.stampsDirectory() stampsDirectory = QFileDialog.getExistingDirectory(self.window(), self.tr("Choose the Stamps Folder"), stampsDirectory) if (not stampsDirectory.isEmpty()): prefs.setStampsDirectory(stampsDirectory) def ensureStampVisible(self, stamp): stampIndex = self.mTileStampModel.index(stamp) if (stampIndex.isValid()): self.mTileStampView.scrollTo(self.mProxyModel.mapFromSource(stampIndex)) def retranslateUi(self): self.setWindowTitle(self.tr("Tile Stamps")) self.mNewStamp.setText(self.tr("Add New Stamp")) self.mAddVariation.setText(self.tr("Add Variation")) self.mDuplicate.setText(self.tr("Duplicate Stamp")) self.mDelete.setText(self.tr("Delete Selected")) self.mChooseFolder.setText(self.tr("Set Stamps Folder")) self.mFilterEdit.setPlaceholderText(self.tr("Filter"))
class E5StringListEditWidget(QWidget, Ui_E5StringListEditWidget): """ Class implementing a dialog to edit a list of strings. """ def __init__(self, parent=None): """ Constructor @param parent reference to the parent widget (QWidget) """ super(E5StringListEditWidget, self).__init__(parent) self.setupUi(self) self.__model = QStringListModel(self) self.__proxyModel = QSortFilterProxyModel(self) self.__proxyModel.setFilterCaseSensitivity(Qt.CaseInsensitive) self.__proxyModel.setSourceModel(self.__model) self.stringList.setModel(self.__proxyModel) self.searchEdit.textChanged.connect( self.__proxyModel.setFilterFixedString) self.removeButton.clicked.connect(self.stringList.removeSelected) self.removeAllButton.clicked.connect(self.stringList.removeAll) def setList(self, stringList): """ Public method to set the list of strings to be edited. @param stringList list of strings to be edited (list of string) """ self.__model.setStringList(stringList) self.__model.sort(0) def getList(self): """ Public method to get the edited list of strings. @return edited list of string (list of string) """ return self.__model.stringList()[:] def setListWhatsThis(self, txt): """ Public method to set a what's that help text for the string list. @param txt help text to be set (string) """ self.stringList.setWhatsThis(txt) @pyqtSlot() def on_addButton_clicked(self): """ Private slot to add an entry to the list. """ entry, ok = QInputDialog.getText( self, self.tr("Add Entry"), self.tr("Enter the entry to add to the list:"), QLineEdit.Normal) if ok and entry != "" and entry not in self.__model.stringList(): self.__model.insertRow(self.__model.rowCount()) self.__model.setData( self.__model.index(self.__model.rowCount() - 1), entry) self.__model.sort(0)