def __init__(self, parent):
super(QWidget, self).__init__(parent)
self.pozycja = 'Brak'
self.proxy = QSortFilterProxyModel(self)
self.proxy_poz = QSortFilterProxyModel(self)
self.edit_wysz = QLineEdit(self)
self.combo_typ = QComboBox(self)
self.lbl_wysz = QLabel("Wyszukaj")
self.lbl_typ = QLabel("Wybierz typ narzędzia:")
self.combo_poz = QComboBox(self)
self.lbl_poz = QLabel("Wybierz pozycję:")
self.listaPozycji = []
self.table = QTableView(self)
self.table_narz = QTableView(self)
sciezka = czy_istnieje()
db = QSqlDatabase.addDatabase('QSQLITE')
db.setDatabaseName(sciezka)
if db.open():
print('Otworzono bazę danych')
self.model = QSqlTableModel(self, db)
self.model_poz = QSqlTableModel(self, db)
self.parent = parent
self.formularz = QGroupBox("Przypisz narzędzia")
self.initUI()
def __init__(self, parent):
super().__init__(parent)
self.setWindowFlags(Qt.Tool | Qt.CustomizeWindowHint
| Qt.WindowCloseButtonHint)
uic.loadUi(
os.path.join(os.path.dirname(__file__),
'plugins_manager_dialog.ui'), self)
self.tabWidget.setCurrentIndex(0)
self.tvAvailable.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
model = QSortFilterProxyModel()
model.setSourceModel(AvailablePluginsModel())
self.tvAvailable.setModel(model)
self.tvAvailable.selectionModel().selectionChanged.connect(
lambda selected, _: self.update_description(
self.lblADescription, selected))
self.tvUpdates.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
model = QSortFilterProxyModel()
model.setSourceModel(UpdatesPluginsModel())
self.tvUpdates.setModel(model)
self.tvUpdates.selectionModel().selectionChanged.connect(
lambda selected, _: self.update_description(
self.lblUDescription, selected))
self.tvInstalled.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
model = QSortFilterProxyModel()
model.setSourceModel(InstalledPluginsModel())
self.tvInstalled.setModel(model)
self.tvInstalled.selectionModel().selectionChanged.connect(
lambda selected, _: self.update_description(
self.lblIDescription, selected))
for edit in (self.leASearch, self.leUSearch, self.leISearch):
edit.textChanged.connect(self.on_do_search)
edit.returnPressed.connect(self.on_do_search)
for button in (self.btASearch, self.btUSearch, self.btISearch):
button.clicked.connect(self.on_do_search)
self.btReloadPlugins = self.buttonBox.addButton(
"Reload Plugins", QDialogButtonBox.ActionRole)
self.btReloadPlugins.setIcon(QIcon(":/icons/images/refresh.svg"))
self.btReloadPlugins.clicked.connect(self.reload_plugins)
self.btInstall.clicked.connect(self.on_install_clicked)
self.btUpdate.clicked.connect(self.on_update_clicked)
self.btUninstall.clicked.connect(self.on_uninstall_clicked)
self._workers = WorkerQueue(self, ProgressDialog(self))
self.update_plugins_lists()
def __init__(self):
super(MainWindow, self).__init__()
# Products Data Init
self.product_fields = []
self.product_data = Product.objects.all()
self.product_model = QStandardItemModel(len(self.product_data), 7)
self.product_model.setHorizontalHeaderLabels(
['Id', 'Product', 'TVA', 'Price TTC', 'In stock', 'Barcode'])
self.product_filter_proxy_model = QSortFilterProxyModel()
self.product_filter_proxy_model.setSourceModel(self.product_model)
self.selected_product = ""
# Customers Data Init
self.customer_fields = []
self.customer_data = Customer.objects.all()
self.customer_dicts = Customer.objects.values()
self.customer_model = QStandardItemModel(len(self.customer_data), 2)
self.customer_filter_proxy_model = QSortFilterProxyModel()
self.customer_filter_proxy_model.setSourceModel(self.customer_model)
self.selected_customer = ''
# Basket Data
self.products_in_basket = {}
self.basket_model = QStandardItemModel(
len(self.products_in_basket.keys()), 4)
self.client_for_basket = ''
self.payment_sources = PaymentSource.objects.all()
self.total_basket = 0.00
self.setupUi(self)
self.initiate_module_menu()
self.showMaximized()
# MENU ACTIONS
self.actionEstablishment.triggered.connect(self.establishmentInfo)
self.populate_products_list()
self.populate_customers_list()
for item in self.payment_sources:
self.comboBox.addItem(item.name)
self.pushButton_10.clicked.connect(self.remove_item_from_basket)
self.pushButton_11.clicked.connect(self.clear_basket)
self.SubmitSaleButton.clicked.connect(self.submit_basket)
self.SaveForLaterButton.clicked.connect(self.save_basket)
self.refreshButton.clicked.connect(self.refresh_all)
self.pushButton_3.clicked.connect(self.open_baskets_dialog)
self.pushButton_13.clicked.connect(self.open_orders_dialog)
self.initiate_basket_view()
def __init__(self):
'''Initializes a MainModel instance.'''
self._searchText = ''
self._matchCase = False
self._includePrivateMembers = False
self._includeInheritedMembers = False
self._sortByType = True
# Initialize icons.
iconDir = f'{dirname(dirname(__file__))}/icons'
self._icons = {
'module': QIcon(f'{iconDir}/module.svg'),
'abstract base class': QIcon(f'{iconDir}/abstract.svg'),
'class': QIcon(f'{iconDir}/class.svg'),
'function': QIcon(f'{iconDir}/function.svg'),
'property': QIcon(f'{iconDir}/property.svg'),
'object': QIcon(f'{iconDir}/object.svg')
}
# Create the unfiltered tree model.
self._treeModel = QStandardItemModel()
# Create regular expressions that exclude or include private members.
self._excludePrivateRegEx = QRegularExpression('^[^_]|^__')
self._includePrivateRegEx = QRegularExpression('')
# Create regular expressions that exclude or include inherited members.
self._excludeInheritedRegEx = QRegularExpression('^$')
self._includeInheritedRegEx = QRegularExpression('')
# Create a filtered tree model used to exclude or include private members.
self._intermediateTreeModel = QSortFilterProxyModel()
self._intermediateTreeModel.setSourceModel(self._treeModel)
privateRegEx = self._includePrivateRegEx if self._includePrivateMembers else self._excludePrivateRegEx
self._intermediateTreeModel.setFilterRegularExpression(privateRegEx)
# Create a filtered tree model used to exclude or include inherited members.
self._secondIntermediateTreeModel = QSortFilterProxyModel()
self._secondIntermediateTreeModel.setSourceModel(self._intermediateTreeModel)
self._secondIntermediateTreeModel.setFilterKeyColumn(2)
inheritedRegEx = self._includeInheritedRegEx if self._includeInheritedMembers else self._excludeInheritedRegEx
self._secondIntermediateTreeModel.setFilterRegularExpression(inheritedRegEx)
# Create a filtered tree model that matches the search text.
self._filteredTreeModel = QSortFilterProxyModel()
self._filteredTreeModel.setSourceModel(self._secondIntermediateTreeModel)
self._filteredTreeModel.setRecursiveFilteringEnabled(True)
self._filteredTreeModel.setFilterFixedString(self._searchText)
self._filteredTreeModel.setFilterCaseSensitivity(1 if self._matchCase else 0)
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 __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent widget (QWidget)
"""
super(PasswordsDialog, self).__init__(parent)
self.setupUi(self)
self.__showPasswordsText = self.tr("Show Passwords")
self.__hidePasswordsText = self.tr("Hide Passwords")
self.passwordsButton.setText(self.__showPasswordsText)
self.removeButton.clicked.connect(self.passwordsTable.removeSelected)
self.removeAllButton.clicked.connect(self.passwordsTable.removeAll)
import Helpviewer.HelpWindow
from .PasswordModel import PasswordModel
self.passwordsTable.verticalHeader().hide()
self.__passwordModel = PasswordModel(
Helpviewer.HelpWindow.HelpWindow.passwordManager(), self)
self.__proxyModel = QSortFilterProxyModel(self)
self.__proxyModel.setSourceModel(self.__passwordModel)
self.searchEdit.textChanged.connect(
self.__proxyModel.setFilterFixedString)
self.passwordsTable.setModel(self.__proxyModel)
fm = QFontMetrics(QFont())
height = fm.height() + fm.height() // 3
self.passwordsTable.verticalHeader().setDefaultSectionSize(height)
self.passwordsTable.verticalHeader().setMinimumSectionSize(-1)
self.__calculateHeaderSizes()
def __init__(self, model, parent, db):
super().__init__(parent, db)
self.model = model
self._proxyModel = QSortFilterProxyModel(self)
self._proxyModel.setSortLocaleAware(True)
self._proxyModel.setSourceModel(self)
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)
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)
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)
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
def set_model(self, regions):
self.sorter = QSortFilterProxyModel()
self.sorter.setDynamicSortFilter(True)
self.sorter.setSourceModel(RegionList(regions))
self.setModel(self.sorter)
self.resizeColumnsToContents()
self.setSortingEnabled(True)
def __init__(self, parent=None):
super(BrowseWidget, self).__init__(parent)
self.parent = parent
self.horizontalLayout = QtWidgets.QHBoxLayout(self.parent)
self.usersFrame = QtWidgets.QFrame(self.parent)
self.verticalLayout_3 = QtWidgets.QVBoxLayout(self.usersFrame)
self.browseUsersFrame = QtWidgets.QFrame(self.usersFrame)
self.horizontalLayout_2 = QtWidgets.QHBoxLayout(self.browseUsersFrame)
self.browseUsersLabel = QtWidgets.QLabel(self.browseUsersFrame)
self.browseUsersLineEdit = QtWidgets.QLineEdit(self.browseUsersFrame)
self.usersList = QtWidgets.QListView(self.usersFrame)
self.buttonsFrame = QtWidgets.QFrame(self.parent)
self.verticalLayout_4 = QtWidgets.QVBoxLayout(self.buttonsFrame)
self.downloadButton = QtWidgets.QPushButton(self.buttonsFrame)
self.treeFrame = QtWidgets.QFrame(self.parent)
self.verticalLayout_5 = QtWidgets.QVBoxLayout(self.treeFrame)
self.browseFileFrame = QtWidgets.QFrame(self.treeFrame)
self.horizontalLayout_4 = QtWidgets.QHBoxLayout(self.browseFileFrame)
self.browseFileLabel = QtWidgets.QLabel(self.browseFileFrame)
self.browseFileLineEdit = QtWidgets.QLineEdit(self.browseFileFrame)
self.fileTreeView = QtWidgets.QTreeView(self.treeFrame)
self.foldIcon = QtGui.QIcon()
self.fileIcon = QtGui.QIcon()
self.filterType = 0
self.lastSearchedTreeFilter = None
self.chosenUserTreeFile = None
self.usersModel = None
self.fileTreeModel = None
self.worker = None
self.thread = None
self.fileProxyModel = QSortFilterProxyModel()
self.setupUi()
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 initUI(self):
# Layout UI elements of table
mainLayout = QVBoxLayout()
self.proxyModel = QSortFilterProxyModel()
self.proxyModel.setDynamicSortFilter(True)
self.sourceModel = QStandardItemModel(0, len(self.columns), self)
for i, column in enumerate(self.columns):
self.sourceModel.setHeaderData(i, Qt.Horizontal, column)
self.proxyModel.setSourceModel(self.sourceModel)
self.proxyGroupBox = QGroupBox(self.name)
self.proxyView = DeselectableTreeView()
self.proxyView.setRootIsDecorated(False)
self.proxyView.setAlternatingRowColors(True)
self.proxyView.setModel(self.proxyModel)
if not self.checkable:
self.proxyView.setSortingEnabled(True)
self.proxyView.sortByColumn(0, Qt.AscendingOrder)
self.proxyView.setEditTriggers(QAbstractItemView.NoEditTriggers)
proxyLayout = QGridLayout()
proxyLayout.addWidget(self.proxyView, 0, 0, 1, 3)
self.proxyGroupBox.setLayout(proxyLayout)
mainLayout.addWidget(self.proxyGroupBox)
self.setLayout(mainLayout)
self.update(self.data)
def init_ui(self):
self.resize(600, 500)
hbox = QHBoxLayout()
tableview = QTableView()
hbox.addWidget(tableview)
self.setLayout(hbox)
model = QStandardItemModel()
model.setHorizontalHeaderLabels(['年龄', '身高', '体重'])
items = [[19, 180, 60], [20, 179, 61], [21, 178, 62], [22, 177, 63]]
for ele1 in items:
for idx, ele2 in enumerate(ele1):
ele1[idx] = QStandardItem(str(ele2))
for item in items:
model.appendRow(item)
sort_model = QSortFilterProxyModel()
sort_model.setDynamicSortFilter(True)
sort_model.setSourceModel(model)
tableview.setModel(sort_model)
tableview.setSortingEnabled(True)
def __init__(self, manager, parent=None):
super(MasternodesWidget, self).__init__(parent)
self.manager = manager
self.model = MasternodesModel(self.manager)
self.proxy_model = QSortFilterProxyModel()
self.proxy_model.setSourceModel(self.model)
self.view = QTableView()
self.view.setModel(self.proxy_model)
for header in [self.view.horizontalHeader(), self.view.verticalHeader()]:
header.setHighlightSections(False)
header = self.view.horizontalHeader()
header.setSectionResizeMode(MasternodesModel.ALIAS, QHeaderView.ResizeToContents)
header.setSectionResizeMode(MasternodesModel.VIN, QHeaderView.Stretch)
header.setSectionResizeMode(MasternodesModel.COLLATERAL, QHeaderView.ResizeToContents)
header.setSectionResizeMode(MasternodesModel.DELEGATE, QHeaderView.ResizeToContents)
self.view.verticalHeader().setVisible(False)
self.view.setSelectionMode(QAbstractItemView.SingleSelection)
self.view.setSelectionBehavior(QAbstractItemView.SelectRows)
self.view.setSortingEnabled(True)
self.view.sortByColumn(self.model.ALIAS, Qt.AscendingOrder)
vbox = QVBoxLayout()
vbox.setContentsMargins(0, 0, 0, 0)
vbox.addWidget(self.view)
self.setLayout(vbox)
def setup_language_combobox(cls, dialog, combobox):
"""
#def setup_language_combobox(cls, dialog: PyQt5.QtWidgets, combobox: PyQt5.QtWidgets.QComboBox):
Setup language chooser ``combobox`` in ``dialog``
Makes it very easy to setup a language changer with on-the-fly setup of ui language
:param dialog: the parent dialog widget of ``combobox``
:param combobox: the language combobox
"""
cls.cfg.combobox = combobox
cls.cfg.dialog = dialog
cls.cfg.combobox.clear()
cls.cfg.combobox.addItem("System", "")
for filePath in QDir(cls.cfg._app_locale_path).entryList():
fileName = os.path.basename(filePath)
fileMatch = re.match(cls.cfg.applangprefix + "_([a-z]{2,}).qm",
fileName)
if fileMatch:
cls.cfg.combobox.addItem(fileMatch.group(1), filePath)
cls.cfg.dialog.sortFilterProxyModelLanguage = QSortFilterProxyModel(
cls.cfg.combobox)
cls.cfg.dialog.sortFilterProxyModelLanguage.setSourceModel(
cls.cfg.combobox.model())
cls.cfg.combobox.model().setParent(
cls.cfg.dialog.sortFilterProxyModelLanguage)
cls.cfg.combobox.setModel(cls.cfg.dialog.sortFilterProxyModelLanguage)
cls.cfg.combobox.currentIndexChanged.connect(
cls.cfg.on_comboBoxLanguage_currentIndexChanged)
cls.cfg.combobox.model().sort(0)
def loadBoard(self, checked, filename=None):
print(filename)
lastdir = self.get_lastdir()
if filename is None:
filename, _ = QFileDialog.getOpenFileName(self,
"select board file",
lastdir,
_KICAD_BOARD_FILTER)
if len(filename) == 0:
return
self._model = RemapTable(filename, self.ui.sortOrder.currentIndex(),
self.style())
self._filterproxy = QSortFilterProxyModel()
self._filterproxy.setSourceModel(self._model)
self.ui.remapView.setModel(self._filterproxy)
self.ui.remapView.selectionModel().currentChanged.connect(
self.componentSelected)
self.ui.remapView.setSortingEnabled(True)
self.settings.setValue("lastVisitedDir", os.path.dirname(filename))
self.ui.sortOrder.currentIndexChanged.connect(self._model.resortdata)
self.ui.prepareSchematicButton.setEnabled(True)
self.statusBar().showMessage("Board loaded OK")
self.ui.remapView.resizeColumnsToContents()
self.ui.commitboardbutton.setEnabled(True)
def __init__(self, parent):
super(QWidget, self).__init__(parent)
self.skrot = QShortcut(QKeySequence(Qt.Key_Return), self)
self.naglowki = {
'iddetale': 'ID',
'nr_detalu': 'Detal',
'maszyna': 'Maszyna',
"ilosc_m": 'Ilość maszyn',
'ilosc_szt': 'Ilość sztuk na operację',
'nazwa_op': 'Nazwa operacji',
'nr_op': 'Nr operacji',
'tm': 'Czas Tm [s]',
'tp': 'Czas Tp [s]',
'tj': 'Czas Tj [h]',
'norma': 'Norma [szt.]',
'uwagi': 'Uwagi',
'id_uzytkownika': 'Użytkownik'
}
self.proxy = QSortFilterProxyModel(self)
self.parent = parent
self.formularz = QGroupBox("Normy")
self.lbl_w = QLabel("Wyszukaj")
self.edit_w = QLineEdit(self)
self.table = QTableView(self)
self.btn_odswiez = QPushButton("Odśwież bazę")
sciezka = czy_istnieje()
self.db = QSqlDatabase.addDatabase('QSQLITE')
self.db.setDatabaseName(sciezka)
if self.db.open():
print('Otworzono bazę danych')
self.model = QSqlRelationalTableModel(self, self.db)
self.initUI()
def __init__(self, application):
super().__init__()
self.application = application
self.tabulator_dialog = None
self.sound = QSound('laser.wav')
self.window = Ui_MainWindow()
self.window.setupUi(self)
self.setWindowIcon(QIcon('aswan-icon.png'))
# Data binding
self.proxy_model = QSortFilterProxyModel()
self.proxy_model.setSourceModel(self.application.REPORT)
self.window.treeView.setModel(self.proxy_model)
# Command binding
self.window.actionQuit.triggered.connect(qApp.quit)
self.window.actionColumns.triggered.connect(self.cmd_view_columns)
self.window.actionClear.triggered.connect(self.cmd_view_clear)
self.window.actionFit_Columns_To_Contents.triggered.connect(
self.cmd_view_fit_columns_to_contents)
self.window.actionDocumentation.triggered.connect(
self.cmd_help_documentation)
# Start the report updates
self.update()
def __init__(self, parent=None):
super(AdvComboBox, self).__init__(parent)
self.setFocusPolicy(QtCore.Qt.StrongFocus)
self.setEditable(True)
# add a filter model to filter matching items
self.pFilterModel = QSortFilterProxyModel(self)
self.pFilterModel.setFilterCaseSensitivity(QtCore.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
def filter_function(text):
self.pFilterModel.setFilterFixedString(str(text))
self.lineEdit().textEdited.connect(filter_function)
self.completer.activated.connect(self.on_completer_activated)
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent widget (QWidget)
"""
super(UserAgentsDialog, self).__init__(parent)
self.setupUi(self)
self.removeButton.clicked.connect(self.userAgentsTable.removeSelected)
self.removeAllButton.clicked.connect(self.userAgentsTable.removeAll)
self.userAgentsTable.verticalHeader().hide()
self.__userAgentModel = UserAgentModel(
Helpviewer.HelpWindow.HelpWindow.userAgentsManager(), self)
self.__proxyModel = QSortFilterProxyModel(self)
self.__proxyModel.setSourceModel(self.__userAgentModel)
self.searchEdit.textChanged.connect(
self.__proxyModel.setFilterFixedString)
self.userAgentsTable.setModel(self.__proxyModel)
fm = QFontMetrics(QFont())
height = fm.height() + fm.height() // 3
self.userAgentsTable.verticalHeader().setDefaultSectionSize(height)
self.userAgentsTable.verticalHeader().setMinimumSectionSize(-1)
self.userAgentsTable.resizeColumnsToContents()
self.userAgentsTable.horizontalHeader().setStretchLastSection(True)
def setupUi(self):
self.load_ui("rolequery.ui")
# populate role list
self.role_model = SEToolsListModel(self)
self.role_model.item_list = sorted(r for r in self.policy.roles())
self.roles.setModel(self.role_model)
# populate type list
self.type_model = SEToolsListModel(self)
self.type_model.item_list = sorted(self.policy.types())
self.types.setModel(self.type_model)
# set up results
self.table_results_model = RoleTableModel(self)
self.sort_proxy = QSortFilterProxyModel(self)
self.sort_proxy.setSourceModel(self.table_results_model)
self.table_results.setModel(self.sort_proxy)
self.table_results.sortByColumn(0, Qt.AscendingOrder)
# setup indications of errors on level/range
self.orig_palette = self.name.palette()
self.error_palette = self.name.palette()
self.error_palette.setColor(QPalette.Base, Qt.red)
self.clear_name_error()
# set up processing thread
self.thread = QThread()
self.worker = QueryResultsUpdater(self.query, self.table_results_model)
self.worker.moveToThread(self.thread)
self.worker.raw_line.connect(self.raw_results.appendPlainText)
self.worker.finished.connect(self.update_complete)
self.worker.finished.connect(self.thread.quit)
self.thread.started.connect(self.worker.update)
# create a "busy, please wait" dialog
self.busy = QProgressDialog(self)
self.busy.setModal(True)
self.busy.setRange(0, 0)
self.busy.setMinimumDuration(0)
self.busy.canceled.connect(self.thread.requestInterruption)
self.busy.reset()
# update busy dialog from query INFO logs
self.handler = LogHandlerToSignal()
self.handler.message.connect(self.busy.setLabelText)
logging.getLogger("setools.rolequery").addHandler(self.handler)
# Ensure settings are consistent with the initial .ui state
self.notes.setHidden(not self.notes_expander.isChecked())
# connect signals
self.roles.doubleClicked.connect(self.get_detail)
self.roles.get_detail.triggered.connect(self.get_detail)
self.name.textEdited.connect(self.clear_name_error)
self.name.editingFinished.connect(self.set_name)
self.name_regex.toggled.connect(self.set_name_regex)
self.types.selectionModel().selectionChanged.connect(self.set_types)
self.invert_types.clicked.connect(self.invert_type_selection)
self.buttonBox.clicked.connect(self.run)
def __init__(self, parent=None):
super().__init__(parent)
self.setupUi(self)
self.icon = None
self.extensions = (".svg", ".png", ".jpg", ".gif", ".jpeg", ".bmp",
".ico")
self.resource_model = RessourceModel(self.extensions, self)
self.proxy_model = QSortFilterProxyModel()
self.proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.proxy_model.setSourceModel(self.resource_model)
self.view.setModel(self.proxy_model)
self.view.setContextMenuPolicy(Qt.CustomContextMenu)
self.view.customContextMenuRequested.connect(self.on_context_menu)
self.filterLineEdit.textChanged.connect(
self.proxy_model.setFilterRegExp)
self.view.clicked.connect(self.on_click)
self.view.doubleClicked.connect(self.on_double_click)
self.splitter.setStretchFactor(0, 0)
self.splitter.setStretchFactor(1, 1)
self.default_item = None
self.ressourceTree.setColumnCount(2)
self.build_resource_tree(self.ressourceTree.invisibleRootItem(), "")
self.ressourceTree.setColumnHidden(1, True)
self.ressourceTree.currentItemChanged.connect(
self.on_ressource_changed)
self.ressourceTree.expandItem(self.default_item)
self.ressourceTree.setCurrentItem(self.default_item)
def __init__(self, ProxyModel=None):
QWidget.__init__(self)
self.setupUi(self)
self.model = None
if ProxyModel is None:
self.proxyModel = QSortFilterProxyModel(self)
# Hide filter label and combobox
self.label_filter.setVisible(False)
self.filterComboBox.setVisible(False)
self.line.setVisible(False)
else:
self.proxyModel = ProxyModel(self)
# Show filter label and combobox
self.label_filter.setVisible(True)
self.filterComboBox.setVisible(True)
self.line.setVisible(True)
self.filterComboBox.addItems(ProxyModel.options)
self.filterComboBox.currentIndexChanged.connect(self.proxyModel.set_custom_filter)
self.proxyModel.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive)
self.proxyModel.setFilterKeyColumn(-1)
self.proxyModel.setDynamicSortFilter(True)
self.dataView.setModel(self.proxyModel)
self.proxyModel.sort(0)
self.addItemButton.setText("Add {}".format(self.data_type))
self.editItemButton.setText(self.tr("Edit {}".format(self.data_type)))
self.deleteItemButton.setText(self.tr("Delete {}".format(self.data_type)))
self.searchInput.textChanged.connect(self.proxyModel.setFilterFixedString)
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 display(self, incidents, locations):
self.model = IncidentModel(incidents, locations, self)
self.proxy = QSortFilterProxyModel(self)
self.proxy.setSourceModel(self.model)
self.proxy.setFilterRole(self.model.filter_role)
self.proxy.setFilterRegExp(QRegExp(self.filter.text()))
self.view.setModel(self.proxy)
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 __init__(self, dialog, model, parent=None):
super(ProposalsWidget, self).__init__(parent)
self.dialog = dialog
self.manager = dialog.manager
self.model = model
self.proxy_model = QSortFilterProxyModel()
self.proxy_model.setSourceModel(self.model)
self.view = QTableView()
self.view.setModel(self.proxy_model)
self.view.setSortingEnabled(True)
self.view.setSelectionMode(QAbstractItemView.SingleSelection)
self.view.setSelectionBehavior(QAbstractItemView.SelectRows)
header = self.view.horizontalHeader()
header.setHighlightSections(False)
header.setResizeMode(self.model.NAME, QHeaderView.ResizeToContents)
header.setResizeMode(self.model.URL, QHeaderView.Stretch)
header.setResizeMode(self.model.ADDRESS, QHeaderView.ResizeToContents)
header.setResizeMode(self.model.TXID, QHeaderView.ResizeToContents)
self.view.verticalHeader().setVisible(False)
self.view.sortByColumn(self.model.NAME, Qt.AscendingOrder)
self.view.selectionModel().selectionChanged.connect(
self.on_view_selection_changed)
self.editor = ProposalEditor(self)
vbox = QVBoxLayout()
vbox.setContentsMargins(0, 0, 0, 0)
vbox.addWidget(QLabel(_('Proposals:')))
vbox.addWidget(self.view)
vbox.addWidget(self.editor)
self.setLayout(vbox)
