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