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 __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)
def __init__(self, parent=None): super().__init__(parent) self._model = LogRecordModel() filter_model = QSortFilterProxyModel() filter_model.setSourceModel(self._model) filter_model.setFilterKeyColumn(3) self.msg_filter = QLineEdit() self.log_view = QTableView() self.log_view.setModel(filter_model) header = self.log_view.horizontalHeader() #header.setSectionResizeMode(header.Stretch) header.setStretchLastSection(True) self.status_label = QLabel() # Connect signals: self.msg_filter.textChanged.connect(filter_model.setFilterFixedString) # Make nice layout: layout = QVBoxLayout(self) layout.addWidget(self.msg_filter) layout.addWidget(self.log_view) layout.addWidget(self.status_label) # Attach udp server: self._udpServer = UdpHandler(self._model) self._model.stats_changed.connect(self.status_label.setText)
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 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 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 SortFilterTableView(QTableView): def __init__(self, parent=None): super().__init__(parent) self._proxy_model = QSortFilterProxyModel(self) self._proxy_model.setDynamicSortFilter(True) super().setModel(self._proxy_model) header = FilterHeader(self) header.filter_changed.connect(self.set_filter) self.setHorizontalHeader(header) self.setSortingEnabled(True) self.setSelectionMode(QAbstractItemView.ContiguousSelection) self.import_export_manager = ImportExportManager(self) self.import_export_manager.connect_custom_context_menu() def set_filter(self, section, filter_text): log.debug("set_filter(section: %s, filter: %r)", section, filter_text) self._proxy_model.setFilterWildcard(filter_text) self._proxy_model.setFilterKeyColumn(section) def setModel(self, model): self.horizontalHeader().set_filter_boxes(model.columnCount()) self._proxy_model.setSourceModel(model) self._proxy_model.sort(0, Qt.AscendingOrder) super().setModel(self._proxy_model) font = model.data(0, Qt.FontRole) if font is None: font = self.font() metrics = QFontMetrics(font) self.verticalHeader().setDefaultSectionSize(metrics.lineSpacing() * 1.5) self.horizontalHeader().setDefaultSectionSize(metrics.maxWidth() * 5)
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)
class AllMoviesView(QWidget): def __init__(self, parent): super().__init__(parent) self.ui = Ui_allMovies_window() self.ui.setupUi(self) self.labels = ['Id', 'Title', 'Film director', 'Genre', 'Status'] self.ui.allMovies_tableView.clicked.connect(self.movie_details) self.show() def loadData(self): results = movie_session.query(Movie, Film_director, Genre, MovieStatus).select_from(Movie).join(Film_director).join(Genre).join(MovieStatus).all() self.model = QStandardItemModel(len(results), len(self.labels)) self.model.setHorizontalHeaderLabels(self.labels) self.filter_proxy_model = QSortFilterProxyModel() self.filter_proxy_model.setFilterKeyColumn(-1) self.filter_proxy_model.setSourceModel(self.model) for row, (movie, film_director, genre, movie_status) in enumerate(results): movie_id = QStandardItem(str(movie.id)) movie_id.setTextAlignment(Qt.AlignCenter) movie_title = QStandardItem(movie.title) movie_title.setTextAlignment(Qt.AlignCenter) filmDirector = QStandardItem(film_director.name + " " + film_director.surname) filmDirector.setTextAlignment(Qt.AlignCenter) genreI = QStandardItem(genre.name) genreI.setTextAlignment(Qt.AlignCenter) status = QStandardItem(movie_status.name) status.setTextAlignment(Qt.AlignCenter) status.setForeground(QBrush(getColorStatus(movie.status_id, movie))) self.model.setItem(row, 0, movie_id) self.model.setItem(row, 1, movie_title) self.model.setItem(row, 2, filmDirector) self.model.setItem(row, 3, genreI) self.model.setItem(row, 4, status) self.ui.allMovies_tableView.setModel(self.filter_proxy_model) self.ui.allMovies_tableView.setColumnHidden(0, True) self.ui.searchMovie_lineEdit.textChanged.connect(self.filter_proxy_model.setFilterRegExp) def movie_details(self): row = self.ui.allMovies_tableView.selectionModel().selectedRows()[0].row() id = self.filter_proxy_model.index(row, 0).data() result = movie_session.query(Movie, Film_director, Genre, MovieStatus).select_from(Movie).filter_by(id=id).join(Film_director).join(Genre).join(MovieStatus).first() movie, film_director, genre, status = result movie_view = self.parent().findChild(QWidget, 'movie_window') movie_view.updateValues(movie, film_director, genre, status) self.parent().setCurrentWidget(movie_view)
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()]
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)
def createModel(parent, rows, cols, colNames): model = QStandardItemModel(rows, cols + 1, parent) i = 0 for c in colNames: model.setHeaderData(i, Qt.Horizontal, colNames[i]) i += 1 proxyModel = QSortFilterProxyModel() proxyModel.setDynamicSortFilter(True) proxyModel.setSourceModel(model) proxyModel.setFilterKeyColumn(0) return proxyModel
def createModel(parent,rows,cols,colNames): model=QStandardItemModel(rows, cols+1, parent) i=0 for c in colNames: model.setHeaderData(i, Qt.Horizontal, c) i+=1 proxyModel=QSortFilterProxyModel() proxyModel.setDynamicSortFilter(True) proxyModel.setSourceModel(model) proxyModel.setFilterKeyColumn(0) return proxyModel
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 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()
class AllFilmDirectorsView(QWidget): def __init__(self, parent): super().__init__(parent) self.ui = Ui_AllFilmDirectors_window() self.ui.setupUi(self) self.labels = ['Id', 'Name', 'Surname'] self.ui.allFilmDirectors_tableView.clicked.connect( self.filmDirector_details) self.show() def loadData(self): filmDirectors = movie_session.query(Film_director).all() self.model = QStandardItemModel(len(filmDirectors), len(self.labels)) self.model.setHorizontalHeaderLabels(self.labels) self.filter_proxy_model = QSortFilterProxyModel() self.filter_proxy_model.setFilterKeyColumn(-1) self.filter_proxy_model.setSourceModel(self.model) for row, filmDirector in enumerate(filmDirectors): filmDirector_id = QStandardItem(str(filmDirector.id)) filmDirector_id.setTextAlignment(Qt.AlignCenter) filmDirector_name = QStandardItem(filmDirector.name) filmDirector_name.setTextAlignment(Qt.AlignCenter) filmDirector_surname = QStandardItem(filmDirector.surname) filmDirector_surname.setTextAlignment(Qt.AlignCenter) self.model.setItem(row, 0, filmDirector_id) self.model.setItem(row, 1, filmDirector_name) self.model.setItem(row, 2, filmDirector_surname) self.ui.allFilmDirectors_tableView.setModel(self.filter_proxy_model) self.ui.allFilmDirectors_tableView.setColumnHidden(0, True) self.ui.searchFilmDirector_lineEdit.textChanged.connect( self.filter_proxy_model.setFilterRegExp) def filmDirector_details(self): row = self.ui.allFilmDirectors_tableView.selectionModel().selectedRows( )[0].row() id = self.filter_proxy_model.index(row, 0).data() filmDirector = movie_session.query(Film_director).filter_by( id=id).first() filmDirector_view = self.parent().findChild(QWidget, 'filmDirector_window') filmDirector_view.updateValues(filmDirector) self.parent().setCurrentWidget(filmDirector_view)
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
def txt_dictFind_textChange(self, text): if len(text) == 0: self.tbl_dictList.setModel(self.dict_list_model) return filter_model = QSortFilterProxyModel() filter_model.setSourceModel(self.dict_list_model) filter_model.setFilterKeyColumn(0) regex = "^{}".format(text) filter_model.setFilterRegExp( QtCore.QRegExp(regex, QtCore.Qt.CaseInsensitive)) self.tbl_dictList.setModel(filter_model) pass
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 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)
class AllGenresView(QWidget): def __init__(self, parent): super().__init__(parent) self.ui = Ui_allGenres_window() self.ui.setupUi(self) self.labels = ['Id', 'Name'] self.ui.allGenres_tableView.clicked.connect(self.editGenre) self.show() def loadData(self): genres = movie_session.query(Genre).all() self.model = QStandardItemModel(len(genres), len(self.labels)) self.model.setHorizontalHeaderLabels(self.labels) self.filter_proxy_model = QSortFilterProxyModel() self.filter_proxy_model.setFilterKeyColumn(-1) self.filter_proxy_model.setSourceModel(self.model) for row, genre in enumerate(genres): genre_id = QStandardItem(str(genre.id)) genre_id.setTextAlignment(Qt.AlignCenter) genre_name = QStandardItem(genre.name) genre_name.setTextAlignment(Qt.AlignCenter) self.model.setItem(row, 0, genre_id) self.model.setItem(row, 1, genre_name) self.ui.allGenres_tableView.setModel(self.filter_proxy_model) self.ui.allGenres_tableView.setColumnHidden(0, True) self.ui.searchGenre_lineEdit.textChanged.connect( self.filter_proxy_model.setFilterRegExp) def editGenre(self): row = self.ui.allGenres_tableView.selectionModel().selectedRows( )[0].row() id = self.filter_proxy_model.index(row, 0).data() genre = movie_session.query(Genre).filter_by(id=id).first() genre_view = self.parent().findChild(QWidget, 'genre_window') genre_view.updateValues(genre) self.parent().setCurrentWidget(genre_view)
class Window(QWidget): def __init__(self): super().__init__() # Make widgets ################# self.edit = QLineEdit() self.table_view = QTableView() self.edit.setPlaceholderText("Filter text (on col. 1)") # Set the layout ############################ vbox = QVBoxLayout() vbox.addWidget(self.edit) vbox.addWidget(self.table_view) self.setLayout(vbox) # Set Model and ProxyModel ################## my_model = MyModel(None) self.proxy_model = QSortFilterProxyModel() # <-- self.proxy_model.setSourceModel(my_model) # <-- self.table_view.setModel(self.proxy_model) # <-- #self.table_view.setModel(my_model) #self.proxy_model.setFilterRegExp(QRegExp("1", Qt.CaseInsensitive, QRegExp.FixedString)) # <-- self.proxy_model.setFilterKeyColumn(0) # <-- #self.table_view.setSortingEnabled(True) # Set LineEdit slot ######################### self.edit.textChanged.connect(self.foo) def foo(self): filter_str = self.edit.text() self.proxy_model.setFilterRegExp( QRegExp(filter_str, Qt.CaseInsensitive, QRegExp.FixedString)) # <--
def __init__(self, username): super(search, self).__init__() loadUi("Search.ui", self) pixmap = QPixmap("Obj/ico/images.png") pixmap_1 = QPixmap("Obj/ico/microphone.png") self.label.setPixmap(pixmap) # self.Micro_Button.setSize(100,100) self.Micro_Button.setIcon(QIcon("Obj/ico/microphone.png")) self.username = username self.search_Button.clicked.connect(self.gotoback) ###model = #add the search list # mainLayout=form companies = [] task_list = Manage(self.username).show_tasks() self.x = len(task_list) for i in range(self.x): companies.append("Task id " + str(task_list[i]["id"]) + " " + task_list[i]["task name"]) # companies = ('Apple', 'Facebook', 'Google', 'Amazon', 'Walmart', 'Dropbox', 'Starbucks', 'eBay', 'Canon') model = QStandardItemModel(len(companies), 1) model.setHorizontalHeaderLabels(['Task Name']) for row, company in enumerate(companies): item = QStandardItem(company) model.setItem(row, 0, item) filter_proxy_model = QSortFilterProxyModel() filter_proxy_model.setSourceModel(model) filter_proxy_model.setFilterKeyColumn(0) search_filed = self.search_Edit search_filed.textChanged.connect(filter_proxy_model.setFilterRegExp) # table =QTableView() # table.setStyleSheet('font-size: 35px;') self.table.verticalHeader().setSectionResizeMode(QHeaderView.Stretch) self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch) self.table.setModel(filter_proxy_model) self.table.doubleClicked.connect(self.gotoshow) # form.addWidget(table) self.Micro_Button.clicked.connect(self.gotovoice)
class SortFilterTreeView(QTreeView): def __init__(self, parent=None): super().__init__(parent) self._proxy_model = QSortFilterProxyModel(self) self._proxy_model.setDynamicSortFilter(True) super().setModel(self._proxy_model) header = FilterHeader(self) header.filter_changed.connect(self.set_filter) self.setHeader(header) self.setSortingEnabled(True) def set_filter(self, section, filter_text): self._proxy_model.setFilterWildcard(filter_text) self._proxy_model.setFilterKeyColumn(section) def setModel(self, model): self.header().set_filter_boxes(model.columnCount()) self._proxy_model.setSourceModel(model) self.sortByColumn(0, Qt.AscendingOrder) super().setModel(self._proxy_model)
def __init__(self, parent=None): QWidget.__init__(self, parent) self.setupUi(self) self.toolBox.setStyleSheet(style.toolBoxSS()) self.mw = mainWindow() self.txtGeneralSplitScenes.setStyleSheet(style.lineEditSS()) # TreeView to select parent # We use a proxy to display only folders proxy = QSortFilterProxyModel() proxy.setFilterKeyColumn(Outline.type) proxy.setFilterFixedString("folder") proxy.setSourceModel(self.mw.mdlOutline) self.treeGeneralParent.setModel(proxy) for i in range(1, self.mw.mdlOutline.columnCount()): self.treeGeneralParent.hideColumn(i) self.treeGeneralParent.setCurrentIndex(self.getParentIndex()) self.chkGeneralParent.toggled.connect(self.treeGeneralParent.setVisible) self.treeGeneralParent.hide()
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 CompilerView(QTableView): def __init__(self, parent=None): super().__init__() self.sorter = None def set_model(self, data): self.sorter = QSortFilterProxyModel() self.sorter.setDynamicSortFilter(True) self.sorter.setSortRole(Qt.EditRole) self.sorter.setFilterKeyColumn(1) self.sorter.setSourceModel(CompilerModel(data)) self.setModel(self.sorter) self.resizeColumnsToContents() self.setColumnWidth(0, max(100, self.columnWidth(0))) self.setColumnWidth(1, max(100, self.columnWidth(1))) for x in range (4, 8): self.setColumnWidth(x, max(self.columnWidth(x), 100)) self.setSortingEnabled(True) self.setSelectionBehavior(QAbstractItemView.SelectRows)
def __init__(self, parent=None): QWidget.__init__(self, parent) self.setupUi(self) self.toolBox.setStyleSheet(style.toolBoxSS()) self.mw = mainWindow() self.txtGeneralSplitScenes.setStyleSheet(style.lineEditSS()) # TreeView to select parent # We use a proxy to display only folders proxy = QSortFilterProxyModel() proxy.setFilterKeyColumn(Outline.type) proxy.setFilterFixedString("folder") proxy.setSourceModel(self.mw.mdlOutline) self.treeGeneralParent.setModel(proxy) for i in range(1, self.mw.mdlOutline.columnCount()): self.treeGeneralParent.hideColumn(i) self.treeGeneralParent.setCurrentIndex(self.getParentIndex()) self.chkGeneralParent.toggled.connect( self.treeGeneralParent.setVisible) self.treeGeneralParent.hide()
class reportUI(QWidget): def __init__(self, parent=None): super().__init__(parent) self.index = 0 self.selectActiveOnly = False self.model = None self.reportChooser = QComboBox() self.reportChooser.addItems(["Active Folios", "All Folios"]) self.reportChooser.currentTextChanged.connect(self.filterChanged) self.reportTableView = QTableView() self.reportTableView.setSortingEnabled(True) layout = QVBoxLayout() layout.addWidget(self.reportChooser) layout.addWidget(self.reportTableView) groupbox = QGroupBox("Account Summary") groupbox.setLayout(layout) boxLayout = QVBoxLayout(self) boxLayout.addWidget(groupbox) def setModel(self, model): self.model = model self.proxyModel = QSortFilterProxyModel() self.proxyModel.setSourceModel(self.model) self.reportTableView.setModel(self.proxyModel) self.filterChanged(self.reportChooser.currentText()) @pyqtSlot(str) def filterChanged(self, filter): if filter == "Active Folios": self.proxyModel.setFilterRegExp("^[1-9].*") self.proxyModel.setFilterKeyColumn(9) else: self.proxyModel.setFilterRegExp("")
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 E5NetworkMonitor(QDialog, Ui_E5NetworkMonitor): """ Class implementing a network monitor dialog. """ _monitor = None @classmethod def instance(cls, networkAccessManager): """ Class method to get a reference to our singleton. @param networkAccessManager reference to the network access manager (QNetworkAccessManager) @return reference to the network monitor singleton (E5NetworkMonitor) """ if cls._monitor is None: cls._monitor = E5NetworkMonitor(networkAccessManager) return cls._monitor @classmethod def closeMonitor(cls): """ Class method to close the monitor dialog. """ if cls._monitor is not None: cls._monitor.close() def __init__(self, networkAccessManager, parent=None): """ Constructor @param networkAccessManager reference to the network access manager (QNetworkAccessManager) @param parent reference to the parent widget (QWidget) """ super(E5NetworkMonitor, self).__init__(parent) self.setupUi(self) self.__requestHeaders = QStandardItemModel(self) self.__requestHeaders.setHorizontalHeaderLabels( [self.tr("Name"), self.tr("Value")]) self.requestHeadersList.setModel(self.__requestHeaders) self.requestHeadersList.horizontalHeader().setStretchLastSection(True) self.requestHeadersList.doubleClicked.connect(self.__showHeaderDetails) self.__replyHeaders = QStandardItemModel(self) self.__replyHeaders.setHorizontalHeaderLabels( [self.tr("Name"), self.tr("Value")]) self.responseHeadersList.setModel(self.__replyHeaders) self.responseHeadersList.horizontalHeader().setStretchLastSection(True) self.responseHeadersList.doubleClicked.connect( self.__showHeaderDetails) self.requestsList.horizontalHeader().setStretchLastSection(True) self.requestsList.verticalHeader().setMinimumSectionSize(-1) self.__proxyModel = QSortFilterProxyModel(self) self.__proxyModel.setFilterKeyColumn(-1) self.searchEdit.textChanged.connect( self.__proxyModel.setFilterFixedString) self.removeButton.clicked.connect(self.requestsList.removeSelected) self.removeAllButton.clicked.connect(self.requestsList.removeAll) self.__model = E5RequestModel(networkAccessManager, self) self.__proxyModel.setSourceModel(self.__model) self.requestsList.setModel(self.__proxyModel) self.__proxyModel.rowsInserted.connect( self.requestsList.scrollToBottom) self.requestsList.selectionModel()\ .currentChanged[QModelIndex, QModelIndex]\ .connect(self.__currentChanged) fm = self.fontMetrics() em = fm.width("m") self.requestsList.horizontalHeader().resizeSection(0, em * 5) self.requestsList.horizontalHeader().resizeSection(1, em * 20) self.requestsList.horizontalHeader().resizeSection(3, em * 5) self.requestsList.horizontalHeader().resizeSection(4, em * 15) self.__headersDlg = None def closeEvent(self, evt): """ Protected method called upon closing the dialog. @param evt reference to the close event object (QCloseEvent) """ self.__class__._monitor = None super(E5NetworkMonitor, self).closeEvent(evt) def reject(self): """ Public slot to close the dialog with a Reject status. """ self.__class__._monitor = None super(E5NetworkMonitor, self).reject() def __currentChanged(self, current, previous): """ Private slot to handle a change of the current index. @param current new current index (QModelIndex) @param previous old current index (QModelIndex) """ self.__requestHeaders.setRowCount(0) self.__replyHeaders.setRowCount(0) if not current.isValid(): return row = self.__proxyModel.mapToSource(current).row() req = self.__model.requests[row].request for header in req.rawHeaderList(): self.__requestHeaders.insertRows(0, 1, QModelIndex()) self.__requestHeaders.setData( self.__requestHeaders.index(0, 0), str(header, "utf-8")) self.__requestHeaders.setData( self.__requestHeaders.index(0, 1), str(req.rawHeader(header), "utf-8")) self.__requestHeaders.item(0, 0).setFlags( Qt.ItemIsSelectable | Qt.ItemIsEnabled) self.__requestHeaders.item(0, 1).setFlags( Qt.ItemIsSelectable | Qt.ItemIsEnabled) for header in self.__model.requests[row].replyHeaders: self.__replyHeaders.insertRows(0, 1, QModelIndex()) self.__replyHeaders.setData( self.__replyHeaders.index(0, 0), header[0]) self.__replyHeaders.setData( self.__replyHeaders.index(0, 1), header[1]) self.__replyHeaders.item(0, 0).setFlags( Qt.ItemIsSelectable | Qt.ItemIsEnabled) self.__replyHeaders.item(0, 1).setFlags( Qt.ItemIsSelectable | Qt.ItemIsEnabled) def __showHeaderDetails(self, index): """ Private slot to show a dialog with the header details. @param index index of the entry to show (QModelIndex) """ if not index.isValid(): return headerList = self.sender() if headerList is None: return row = index.row() name = headerList.model().data(headerList.model().index(row, 0)) value = headerList.model().data(headerList.model().index(row, 1)) if self.__headersDlg is None: from .E5NetworkHeaderDetailsDialog import \ E5NetworkHeaderDetailsDialog self.__headersDlg = E5NetworkHeaderDetailsDialog(self) self.__headersDlg.setData(name, value) self.__headersDlg.show()
class UiMainWindow(QtWidgets.QMainWindow): def __init__(self): super().__init__() uic.loadUi('Ui/UiMainWindow.ui', self) self.books_window = None self.renters_window = None self.add_book_window = None self.add_new_book_rent_window = None self.data_proxy = DataProxy() self.populate_model() self.search_comboBox.addItems(self.rented_books_model.headers) self.update_counters() self.btn_show_books.clicked.connect(self.show_books_clicked) self.btn_show_renters.clicked.connect(self.show_renters_clicked) self.add_new_book_rent_button.clicked.connect(self.add_new_book_rent_button_clicked) self.search_comboBox.currentIndexChanged.connect(self.change_search_column) self.search_input.textChanged.connect(self.search) self.rented_books_model.dataChanged.connect(self.update_counters) self.rented_books_QTableView.resizeColumnsToContents() # self.rented_books_QTableView.setSortingEnabled(True) self.rented_books_QTableView.setContextMenuPolicy(Qt.CustomContextMenu) self.rented_books_QTableView.customContextMenuRequested.connect(self.show_context_menu) self.rented_books_QTableView.setSelectionBehavior(QAbstractItemView.SelectRows) self.show() def populate_model(self): self.rented_books_model = RentedBookModel(self.rented_books_QTableView) self.rented_books_proxy_model = QSortFilterProxyModel(self) self.rented_books_proxy_model.setSourceModel(self.rented_books_model) self.rented_books_QTableView.setModel(self.rented_books_proxy_model) def show_books_clicked(self): self.books_window = UiBooks() def show_renters_clicked(self): self.renters_window = UiRenters() def add_new_book_rent_button_clicked(self): self.add_new_book_rent_window = UiAddBookRent(self) def change_search_column(self, index): self.rented_books_proxy_model.setFilterKeyColumn(index) def search(self, text): search = QRegExp(text, Qt.CaseInsensitive, QRegExp.RegExp) self.rented_books_proxy_model.setFilterRegExp(search) def show_context_menu(self, event): index = self.rented_books_QTableView.indexAt(event) if index.isValid(): menu = QMenu(self) menu.addAction('Remove Rent', lambda: self.remove_rent(index)) menu.popup(QCursor.pos()) def remove_rent(self, index): rent_id = self.rented_books_model.get_data(index)['id'] if self.data_proxy.delete_rented_book(rent_id): self.populate_model() self.update_counters() def update_rented_books_count(self): self.rented_books_count.setText(str(self.rented_books_model.rowCount(self))) def update_overdue_counter(self): self.overdue_books_count.setText(str(self.rented_books_model.overdue_counter())) def update_counters(self): self.update_rented_books_count() self.update_overdue_counter()
class UiRenters(QtWidgets.QDialog): def __init__(self): super().__init__() uic.loadUi('Ui/UiRenters.ui', self) self.add_renter_window = None self.edit_renter_window = None self.data_proxy = DataProxy() self.populate_model() self.search_comboBox.addItems(self.renters_model.headers) self.renters_count.setText(str(self.renters_model.rowCount(self))) self.add_new_renter_button.clicked.connect(self.add_new_renter_button_clicked) self.search_comboBox.currentIndexChanged.connect(self.change_search_column) self.search_input.textChanged.connect(self.search) self.renters_model.dataChanged.connect(self.update_renters_count) self.close_button.clicked.connect(self.close) self.renters_QTableView.setContextMenuPolicy(Qt.CustomContextMenu) self.renters_QTableView.customContextMenuRequested.connect(self.show_context_menu) self.renters_QTableView.setSelectionBehavior(QAbstractItemView.SelectRows) self.setModal(True) self.renters_QTableView.resizeColumnsToContents() # self.renters_QTableView.setSortingEnabled(True) # Shouldn't be enabled, screws indexes badly, and needs # tons of boiler plate code to work. self.show() def populate_model(self): self.renters_model = RenterModel(self.renters_QTableView) self.renters_proxy_model = QSortFilterProxyModel(self) self.renters_proxy_model.setSourceModel(self.renters_model) self.renters_QTableView.setModel(self.renters_proxy_model) def add_new_renter_button_clicked(self): self.add_renter_window = UiAddRenter(self) def change_search_column(self, index): self.renters_proxy_model.setFilterKeyColumn(index) def search(self, text): search = QRegExp(text, Qt.CaseInsensitive, QRegExp.RegExp) self.renters_proxy_model.setFilterRegExp(search) def update_renters_count(self): self.renters_count.setText(str(self.renters_model.rowCount(self))) def show_context_menu(self, event): index = self.renters_QTableView.indexAt(event) if index.isValid(): menu = QMenu(self) menu.addAction('Edit Renter', lambda: self.edit_renter(index)) menu.addAction('Remove Renter', lambda: self.remove_renter(index)) menu.popup(QCursor.pos()) def edit_renter(self, index): self.edit_renter_window = UiEditRenter(self, index, self.renters_model.get_data(index)) def remove_renter(self, index): renter_id = self.renters_model.get_data(index)['id'] if self.data_proxy.delete_renter(renter_id): self.populate_model() self.update_renters_count()
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 FilterableTable(SQLTable): """a filterable Table Widget that displays content of an SQLite table; for individual widgets, subclass and overwrite the create_model method; add_color_proxy should be an (INT allele_status-column, INT lab_status-column) tuple """ def __init__(self, log, mydb = ": memory :", add_color_proxy = False, header_dic = None): super().__init__(log, mydb) self.add_color_proxy = add_color_proxy self.header_dic = header_dic self.create_model() self.fill_UI() self.create_filter_model() self.update_filterbox() def fill_UI(self): """sets up the layout """ self.log.debug("\t- Setting up the table...") self.table = QTableView() self.table.setContextMenuPolicy(Qt.CustomContextMenu) self.header = self.table.horizontalHeader() # table header self.header.setSectionResizeMode(QHeaderView.ResizeToContents) self.table.setSelectionBehavior(QAbstractItemView.SelectRows) self.table.setAlternatingRowColors(True) # self.header.sectionClicked.connect(self.on_header_sectionClicked) mode = QAbstractItemView.SingleSelection self.table.setSelectionMode(mode) self.grid.addWidget(self.table, 2, 0, 10, 10) self.filter_lbl = QLabel("Filter:", self) self.grid.addWidget(self.filter_lbl, 1, 2) self.filter_entry = QLineEdit(self) self.grid.addWidget(self.filter_entry, 1, 3) self.filter_entry.textChanged.connect(self.on_filter_entry_textChanged) self.filter_text = "" self.filter_cb = QComboBox(self) self.grid.addWidget(self.filter_cb, 1, 4) self.filter_cb.currentIndexChanged.connect(self.on_filter_cb_IndexChanged) self.filter_btn = QPushButton("Filter!", self) self.grid.addWidget(self.filter_btn, 1, 5) self.filter_btn.clicked.connect(self.on_filter_btn_clicked) self.unfilter_btn = QPushButton("Remove Filter", self) self.grid.addWidget(self.unfilter_btn, 1, 6) self.unfilter_btn.clicked.connect(self.on_actionAll_triggered) self.log.debug("\t=> Done!") def update_filterbox(self): """fills the filter-combobox with the header values after the model has been created and set """ column_num = self.model.columnCount() if self.header_dic: columns = [self.header_dic[i] for i in self.header_dic] else: columns = [self.proxy.headerData(i, Qt.Horizontal) for i in range(column_num)] self.filter_cb.addItems(columns) def create_filter_model(self): """creates the filter-proxy-model on top of self.model """ self.log.debug("Creating filter model...") self.proxy = QSortFilterProxyModel(self) if self.add_color_proxy: (allele_status_column, lab_status_column) = self.add_color_proxy self.log.debug("adding color filter to columns {} and {}".format(allele_status_column, lab_status_column)) self.color_proxy = ColorProxyModel(self, allele_status_column, lab_status_column) self.color_proxy.setSourceModel(self.model) self.proxy.setSourceModel(self.color_proxy) else: self.proxy.setSourceModel(self.model) self.table.setSortingEnabled(True) self.table.setModel(self.proxy) def on_filter_cb_IndexChanged(self, index): """restricts RegEx filter to selected column """ self.log.debug("Combobox: colum {} selected".format(index)) self.proxy.setFilterKeyColumn(index) def on_filter_entry_textChanged(self, text): """stores content of filter_entry as self.text """ self.log.debug("filter text: '{}'".format(text)) self.filter_text = text def on_filter_btn_clicked(self): """activates RegEx filter to current content of filter_entry and filter_cb """ column = self.filter_cb.currentIndex() self.log.debug("Filtering column {} for '{}'".format(column, self.filter_text)) self.proxy.setFilterKeyColumn(column) search = QRegExp(self.filter_text, Qt.CaseInsensitive, QRegExp.RegExp) self.proxy.setFilterRegExp(search) def on_header_sectionClicked(self, logicalIndex): """opens a dialog to choose between all unique values for this column, or revert to 'All' """ self.log.debug("Header clicked: column {}".format(logicalIndex)) self.logicalIndex = logicalIndex menuValues = QMenu(self) self.signalMapper = QSignalMapper(self) self.filter_cb.setCurrentIndex(self.logicalIndex) self.filter_cb.blockSignals(True) self.proxy.setFilterKeyColumn(self.logicalIndex) valuesUnique = [str(self.model.index(row, self.logicalIndex).data()) for row in range(self.model.rowCount()) ] actionAll = QAction("All", self) actionAll.triggered.connect(self.on_actionAll_triggered) menuValues.addAction(actionAll) menuValues.addSeparator() for actionNumber, actionName in enumerate(sorted(list(set(valuesUnique)))): action = QAction(actionName, self) self.signalMapper.setMapping(action, actionNumber) action.triggered.connect(self.signalMapper.map) menuValues.addAction(action) self.signalMapper.mapped.connect(self.on_signalMapper_mapped) headerPos = self.table.mapToGlobal(self.header.pos()) posY = headerPos.y() + self.header.height() posX = headerPos.x() + self.header.sectionViewportPosition(self.logicalIndex) menuValues.exec_(QPoint(posX, posY)) def on_actionAll_triggered(self): """reverts table to unfiltered state """ self.log.debug("Unfiltering...") filterString = QRegExp("", Qt.CaseInsensitive, QRegExp.RegExp) self.proxy.setFilterRegExp(filterString) self.filter_entry.setText("") def on_signalMapper_mapped(self, i): """filters current column to mapping text """ text = self.signalMapper.mapping(i).text() self.log.debug("Filtering column {} to '{}'".format(self.logicalIndex, text)) filterString = QRegExp(text, Qt.CaseSensitive, QRegExp.FixedString) self.proxy.setFilterRegExp(filterString)
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_()