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_()
