def __init__(self, parent=None):
super(ExtendedComboBox, self).__init__(parent)
#self.setFocusPolicy(Qt.StrongFocus)
#self.setSizeAdjustPolicy(QComboBox.AdjustToContents)
# self.setStyleSheet('''
#QComboBox { min-width: 1px}
#QComboBox QAbstractItemView::item { min-width: 200px;}"
#''')
self.setEditable(True)
self.setVisible(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)
def main():
# Try to close any existing dialogs so there aren't
# duplicates open.
global pyAssetTrackerDialog
try:
pyAssetTrackerDialog.ui.close()
except:
pass
# Instantiate the main dialog
pyAssetTrackerDialog = AssetTrackerDialog()
ui = pyAssetTrackerDialog.ui
# Create the source model, but map it to a proxy model to enable
# sorting, filtering, etc.
sourceModel = model.Model()
proxyModel = QSortFilterProxyModel()
proxyModel.setSourceModel(sourceModel)
# Assign the proxy model to the tree view
ui.treeView.setModel(proxyModel)
# Show the UI
ui.show()
ui.setWindowTitle("Better Asset Tracker")
def __init__(self, parent):
"""Initialize class"""
super().__init__(parent)
self.setWindowTitle('Install plugin')
QVBoxLayout(self)
self._line_edit = QLineEdit(self)
self._line_edit.setPlaceholderText("Search registry...")
self._list_view = QListView(self)
self._model = QSortFilterProxyModel(self)
self._source_model = _InstallPluginModel(self)
self._model.setSourceModel(self._source_model)
self._model.setFilterCaseSensitivity(Qt.CaseInsensitive)
self._list_view.setModel(self._model)
self._timer = QTimer(self)
self._timer.setInterval(200)
self._button_box = QDialogButtonBox(self)
self._button_box.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
self._button_box.button(QDialogButtonBox.Ok).setEnabled(False)
self.layout().addWidget(self._line_edit)
self.layout().addWidget(self._list_view)
self.layout().addWidget(self._button_box)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setMinimumWidth(400)
self._button_box.button(QDialogButtonBox.Cancel).clicked.connect(
self.close)
self._button_box.button(QDialogButtonBox.Ok).clicked.connect(
self._handle_ok_clicked)
self._list_view.doubleClicked.connect(self._emit_item_selected)
self._list_view.selectionModel().selectionChanged.connect(
self._update_ok_button_enabled)
self._line_edit.textEdited.connect(self._handle_search_text_changed)
self._timer.timeout.connect(self._filter_model)
def setProxyStuff(self, sortColumn, sortOrder):
"""Prepare the proxy model to filter and sort the view.
Parameter:
sortColumn: the index of the column to use
for sorting at the beginning
sortOrder: the order for sorting
(`Qt.AscendingOrder` or `Qt.DescendingOrder`)
"""
self.proxyModel = QSortFilterProxyModel(self)
self.proxyModel.setSourceModel(self.tableModel)
self.proxyModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.proxyModel.setSortCaseSensitivity(Qt.CaseInsensitive)
self.proxyModel.setFilterKeyColumn(-1)
self.tableview = PBTableView(self)
self.tableview.setModel(self.proxyModel)
self.tableview.setSortingEnabled(True)
self.tableview.setMouseTracking(True)
self.tableview.setSelectionBehavior(QAbstractItemView.SelectRows)
try:
self.tableview.sortByColumn(self.tableModel.header.index("bibkey"),
Qt.AscendingOrder)
except (IndexError, ValueError):
pass
self.tableview.sortByColumn(sortColumn, sortOrder)
try:
self.proxyModel.sort(self.tableModel.header.index("bibkey"),
Qt.AscendingOrder)
except (IndexError, ValueError):
pass
self.proxyModel.sort(sortColumn, sortOrder)
self.currLayout.addWidget(self.tableview)
def __init__(self, parent):
self._dialog = QDialog(parent)
self._dialog.setWindowIcon(QIcon(':/images/icon.png'))
self._ui = Ui_Dialog()
self._ui.setupUi(self._dialog)
self._ui.centralWidget.setFrameShape(QFrame.NoFrame)
self._ui.centralWidget.setLineWidth(1)
self._model = None
self._proxy_model = QSortFilterProxyModel()
self._view = self._ui.folder_list_view
self._view.setModel(self._proxy_model)
self._view.expanded.connect(self.on_item_expanded)
self._offline_paths = None
# for frameless window moving
self._x_coord = 0
self._y_coord = 0
self._dialog.mousePressEvent = self.on_mouse_press_event
self._dialog.mouseMoveEvent = self.on_mouse_move_event
self._loader_movie = QMovie(":/images/loader.gif")
self._ui.loader_label.setMovie(self._loader_movie)
def __init__(self, is_person=False, parent=None):
super().__init__(parent)
self.is_person = is_person
self.module: TableModule = locator.get_scoped("ModuleService").get_module("Characters")
self.proxy_model = QSortFilterProxyModel()
self.proxy_model.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive)
self.proxy_model.setSourceModel(self.module.entries_model)
self.characters_list_view.setModel(self.proxy_model)
self.selection: Optional[PropertyContainer] = None
self.character_details_form_1 = PropertyForm(self.module.element_template, category="character_description_1")
self.character_details_form_contents_1.setLayout(self.character_details_form_1)
self.character_details_form_2 = PropertyForm(self.module.element_template, category="character_description_2")
self.character_details_form_contents_2.setLayout(self.character_details_form_2)
self.character_details_form_2.fix_editor_width(100)
self.stats_editor = MergedStatsEditor(["Bases", "Growths", "Modifiers", "Penalties", "Bonuses"])
self.stats_form = PropertyForm(self.module.element_template, category="stats")
self.stats_layout.addWidget(self.stats_editor)
self.stats_layout.addLayout(self.stats_form)
self.skills_form = PropertyForm(self.module.element_template, category="skills", sort_editors=True)
self.skills_contents.setLayout(self.skills_form)
self.flags_editor = MergedFlagsEditor(
["Bitflags (1)", "Bitflags (2)", "Bitflags (3)", "Bitflags (4)"],
self.module.element_template
)
self.flags_editor_2 = MergedFlagsEditor(
["Bitflags (5)", "Bitflags (6)", "Bitflags (7)", "Bitflags (8)"],
self.module.element_template
)
self.misc_form = PropertyForm(self.module.element_template, category="misc")
self.misc_layout.addWidget(self.flags_editor)
self.misc_layout.addWidget(self.flags_editor_2)
self.misc_layout.addLayout(self.misc_form)
self.ids_form = PropertyForm(self.module.element_template, category="ids")
self.ids_tab.setLayout(self.ids_form)
self.classes_form = PropertyForm(self.module.element_template, category="classes", sort_editors=True)
self.classes_tab.setLayout(self.classes_form)
if not self.is_person:
self.dialogue_tab = DialogueEditor()
self.supports_tab = QWidget()
self.supports_layout = QHBoxLayout()
self.supports_widget = FE14SupportWidget()
self.supports_scroll = QScrollArea()
self.supports_scroll_contents = QWidget()
self.supports_scroll.setWidget(self.supports_scroll_contents)
self.supports_scroll.setWidgetResizable(True)
self.supports_layout.addWidget(self.supports_widget)
self.supports_layout.addWidget(self.supports_scroll)
self.supports_tab.setLayout(self.supports_layout)
self.supports_form = PropertyForm(self.module.element_template, category="supports")
self.supports_scroll_contents.setLayout(self.supports_form)
self.tab_widget.addTab(self.supports_tab, "Supports")
self.tab_widget.addTab(self.dialogue_tab, "Dialogue")
self.context_menu = QMenu(self)
self.context_menu.addActions([self.action_add, self.action_remove, self.action_copy_to])
self.clear_selection_shortcut = QShortcut(QKeySequence.Cancel, self)
self._install_signals()
self._clear()
def __init__(self, table_name="", update_field="", database=None, parent=None):
super(ExtendedComboBox, self).__init__(parent)
self.__type = Types.TEXT
self.setMinimumHeight(30)
self.setFocusPolicy(Qt.StrongFocus)
self.setEditable(True)
self._table_name = table_name
self._update_field = update_field
self._database = database
# 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):
super().__init__()
self.setupUi(self)
self.pushButton_2.setEnabled(False)
self.pushButton_3.setEnabled(False)
self.comboBox.setEnabled(False)
self.setWindowTitle("Support Editor")
self.setWindowIcon(QIcon("paragon.ico"))
self.error_dialog = None
module_service = locator.get_scoped("ModuleService")
self.service = None
self.current_character = None
self.current_supports = None
self.current_support = None
self.model = module_service.get_module("Characters").entries_model
self.proxy_model = QSortFilterProxyModel(self)
self.proxy_model.setSourceModel(self.model)
self.proxy_model.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive)
self.characters_list_view.setModel(self.proxy_model)
self.characters_list_view.selectionModel().currentRowChanged.connect(self._update_selection)
self.listWidget.selectionModel().currentRowChanged.connect(self._on_target_character_changed)
self.listWidget_2.selectionModel().currentRowChanged.connect(self._update_support_selection)
self.lineEdit.textChanged.connect(self._update_filter)
self.pushButton_2.clicked.connect(self._on_add_support_pressed)
self.pushButton_3.clicked.connect(self._on_remove_support_pressed)
self.comboBox.currentIndexChanged.connect(self._on_support_type_changed)
def __init__(self, close_handler, driver: Driver):
super().__init__()
self.setupUi(self)
self.driver = driver
self.open_editors = {}
self.close_handler = close_handler
self.setWindowTitle("Paragon")
self.setWindowIcon(QIcon("paragon.ico"))
self.proxy_model = QSortFilterProxyModel()
self.proxy_model.setSourceModel(self.driver.module_model)
self.module_list_view.setModel(self.proxy_model)
self.editors_list_view.setModel(self.driver.services_model)
self.open_file_model = OpenFilesModel()
self.file_list_view.setModel(self.open_file_model)
self.search_field.textChanged.connect(self.proxy_model.setFilterRegExp)
self.module_list_view.activated.connect(self._on_module_activated)
self.editors_list_view.activated.connect(self._on_editor_activated)
self.file_list_view.selectionModel().currentRowChanged.connect(
self._on_file_list_selection_change)
self.close_button.clicked.connect(self._on_close_file_pressed)
self.action_save.triggered.connect(self.save)
self.action_close.triggered.connect(self.close)
self.action_quit.triggered.connect(self.quit_application)
logging.info("Opened main window.")
def __init__(self, parent, tutor=None):
"""Initializes instance.
Args:
parent (QWidget): parent widget
tutor (QWidget, NoneType): another widget used for positioning.
"""
super().__init__(parent)
self._tutor = tutor
self._base_size = QSize()
self._base_offset = QPoint()
self._original_text = None
self._orig_pos = None
self.first_index = QModelIndex()
self.model = QStandardItemModel(self)
self.proxy_model = QSortFilterProxyModel(self)
self.proxy_model.setSourceModel(self.model)
self.proxy_model.filterAcceptsRow = self._proxy_model_filter_accepts_row
self.setModel(self.proxy_model)
self.verticalHeader().hide()
self.horizontalHeader().hide()
self.setShowGrid(False)
self.setMouseTracking(True)
self.setTabKeyNavigation(False)
delegate = _CustomLineEditDelegate(self)
delegate.text_edited.connect(self._handle_delegate_text_edited)
self.setItemDelegateForRow(0, delegate)
def __init__(self, parent: QObject, manager: Manager):
super().__init__(parent)
self._manager = manager
self.setWindowTitle("Tasks")
# Build widget
self.search_field = QLineEdit(self)
self.table = _base.ExcelLikeTableView(self)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.table.horizontalHeader().setStretchLastSection(True)
self.table.verticalHeader().setVisible(False)
self.button_add = QPushButton("Add", self)
self.button_remove = QPushButton("Remove", self)
self.button_import = QPushButton("Import", self)
self.button_export = QPushButton("Export", self)
# Build layout
layout_footer = QHBoxLayout()
layout_footer.addWidget(self.search_field)
layout_footer.addWidget(self.button_add)
layout_footer.addWidget(self.button_remove)
layout_footer.addWidget(self.button_import)
layout_footer.addWidget(self.button_export)
layout_content = QVBoxLayout()
layout_content.addLayout(layout_footer)
layout_content.addWidget(self.table)
main_widget = QWidget()
main_widget.setLayout(layout_content)
self.setWidget(main_widget)
# Configure model
self.model = TasksListModel(self, self._manager.context)
model_table = TasksListToTableProxyModel(self)
model_table.setSourceModel(self.model)
model_table_proxy = QSortFilterProxyModel(self)
model_table_proxy.setSourceModel(model_table)
# Configure view
self.table.setModel(model_table_proxy)
self.artist_delegate = ArtistDelegate(self, self._manager)
self.table.setItemDelegateForColumn(2, self.artist_delegate)
self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
# Connect signals
for signal, callback in (
(self.model.dataChanged, self._on_data_changed),
(self.button_add.pressed, self.add_task),
(self.button_remove.pressed, self.remove_tasks),
(self.button_export.pressed, self.export_tasks),
(self.button_import.pressed, self.import_tasks),
(
self.search_field.textChanged,
model_table_proxy.setFilterWildcard,
),
):
signal.connect(callback)
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):
super(PlaylistView, self).__init__(parent)
self.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.setDragEnabled(True)
self.setAcceptDrops(True)
self.setDragDropMode(QAbstractItemView.DragDrop)
self.setDropIndicatorShown(True)
self.proxy_model = QSortFilterProxyModel(self)
self.proxy_model.setSourceModel(PlaylistModel(self))
self.setModel(self.proxy_model)
# self.setModel(PlaylistModel())
self.setShowGrid(False)
self.setSelectionBehavior(QAbstractItemView.SelectRows)
self.verticalHeader().setDefaultSectionSize(16)
self.verticalHeader().hide()
self.horizontalHeader().setMinimumSectionSize(30)
self.horizontalHeader().setSectionResizeMode(QHeaderView.Interactive)
self.current_index = QModelIndex()
self.previousIndex = QModelIndex()
self.rubberBand: QRubberBand = QRubberBand(QRubberBand.Rectangle, self)
self.isDragging = False
self.wasSelected = False
self.context_menu = QMenu(self)
self.create_context_menu()
# self.current_index_changed.connect(self.proxy_model.sourceModel().set_current_index)
self.current_index_changed.connect(
self.proxy_model.sourceModel().set_current_index)
def __init__(self, parent, selection_callback=None):
super(QStringTable, self).__init__(parent)
self._selected = selection_callback
self._filter = None
self.setSelectionBehavior(QAbstractItemView.SelectRows)
self.setShowGrid(False)
self.verticalHeader().setVisible(False)
self.verticalHeader().setDefaultSectionSize(24)
self.setHorizontalScrollMode(self.ScrollPerPixel)
self._model = QStringModel(None)
self._proxy = QSortFilterProxyModel(self)
self._proxy.setSourceModel(self._model)
self._proxy.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.setModel(self._proxy)
self.setSortingEnabled(True)
self.setSelectionMode(QAbstractItemView.SingleSelection)
# let the last column (string) fill table width
self.horizontalHeader().setSectionResizeMode(QHeaderView.Fixed)
self.horizontalHeader().setSectionResizeMode(2, QHeaderView.Stretch)
self.doubleClicked.connect(self._on_string_selected)
def __init__(self, parent=None, include_targets=True, include_airbases=True,
include_frontlines=True, include_units=True, include_enemy=True, include_friendly=True):
super(QFilteredComboBox, self).__init__(parent)
self.setFocusPolicy(Qt.StrongFocus)
self.setEditable(True)
self.completer = QCompleter(self)
self.include_targets = include_targets
self.include_airbases = include_airbases
self.include_frontlines = include_frontlines
self.include_units = include_units
self.include_enemy = include_enemy
self.include_friendly = include_friendly
# 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 __init__(self, parent=None):
super(HPasteCollectionWidget.__HPasteCollectionWidget,
self).__init__(parent,
metadataExposedKeys=('raw_url', 'nettype'))
for x in xrange(1, 5):
self.ui.mainView.horizontalHeader().hideSection(x)
self.__nepane = None
self.__netType = ''
self.__nettypeFilter = QSortFilterProxyModel(self)
self.__nettypeFilter.setFilterKeyColumn(4)
self.__nettypeFilter.setFilterRegExp(
QRegExp("*", Qt.CaseInsensitive, QRegExp.Wildcard))
self.appendFilter(self.__nettypeFilter)
self.accepted.connect(self.doOnAccept)
self.__insideAuthCallback = False
#self.setProperty("houdiniStyle", True)
ss = "QTableView{border : 0px solid; gridline-color: rgb(48,48,48)}"
ss += "QHeaderView::section{border-style: none; border-bottom: 0px; border-right: 0px;}"
self.setStyleSheet(ss)
self.__savedNetworkViewPos = None
def restoreTemplate(self):
#Clear data on create side
self.createtablemodel.metadataList = []
self.createtablemodel.hiddenList = []
self.filterModel.displayed = []
#open template
linetext = QFileDialog.getOpenFileName(
self, self.tr("Select File"),
QStandardPaths.displayName(QStandardPaths.HomeLocation),
self.tr("Files (*.ez)"))[0]
if linetext != "":
infile = open(linetext, "r")
infile.readline()
fileType = infile.readline()
self.fileType = json.loads(fileType)
infile.readline()
newList = infile.readline()
newList = json.loads(newList)
newDict = infile.readline()
newDict = json.loads(newDict)
self.ui.dataTypeText.setText(self.fileType[0][-3:].upper())
self.ui.fileParserCombo.setCurrentIndex(
self.ui.fileParserCombo.findText(
self.fileType[0][-3:].upper() + " Parser"))
self.ui.dataFileLineEdit.setText(self.fileType[0])
self.createtablemodel = TableModelC(newDict, self)
self.filterModel.displayed = []
self.filterModel.setSourceModel(self.createtablemodel)
self.filterModel.fileType = self.fileType
self.createTableSearchFilterModel = QSortFilterProxyModel(self)
self.createTableSearchFilterModel.setSourceModel(self.filterModel)
self.createTableSearchFilterModel.setFilterKeyColumn(1)
self.createTableSearchFilterModel.setDynamicSortFilter(True)
self.ui.metadataTableView.setModel(
self.createTableSearchFilterModel)
self.treeModel = TreeModelR(["Available File Metadata"], newDict,
self.createtablemodel, newList,
self.filterModel)
for i in range(len(newList)):
if "Custom Input" in newList[i]["Source"]:
self.numCustoms += 1
self.customInputs.append(newList[i])
self.createtablemodel.beginInsertRows(
self.createtablemodel.index(
len(self.createtablemodel.metadataList), 0), i, i)
self.createtablemodel.metadataList.append(newList[i])
self.createtablemodel.endInsertRows()
self.createTreeSearchFilterModel = QSortFilterProxyModel(self)
self.createTreeSearchFilterModel.setSourceModel(self.treeModel)
self.createTreeSearchFilterModel.setFilterKeyColumn(0)
self.createTreeSearchFilterModel.setDynamicSortFilter(True)
self.createTreeSearchFilterModel.setRecursiveFilteringEnabled(True)
self.ui.metadataTreeView.setModel(self.createTreeSearchFilterModel)
self.treeModel.checkChanged.connect(self.filterModel.checkList)
self.createtrashDelegate.pressed.connect(self.handleRemoveCreate)
self.ui.TabWidget.setCurrentIndex(0)
def selectFile(self, fileLink=None):
if fileLink == False:
linetext = QFileDialog.getOpenFileName(
self, self.tr("Select File"),
QStandardPaths.displayName(QStandardPaths.HomeLocation),
self.tr("Files (*.*)"))[0]
else:
linetext = fileLink
if linetext != "":
self.setWindowTitle(linetext)
self.ui.dataFileLineEdit.setText(linetext)
self.ui.dataTypeText.setText(linetext.split(".")[1].upper())
if self.ui.fileParserCombo.findText(
linetext.split(".")[1].upper() + " Parser") != -1:
headerDict = {}
self.ui.fileParserCombo.setCurrentIndex(
self.ui.fileParserCombo.findText(
linetext.split(".")[1].upper() + " Parser"))
if linetext.split(".")[1].upper() == "CTF":
headerDict = ctf.parse_header_as_dict(linetext)
elif linetext.split(".")[1].upper() == "ANG":
headerDict = ang.parse_header_as_dict(linetext)
elif linetext.split(".")[1].upper() == "XML":
print("XML Parser used")
self.createtablemodel = TableModelC(headerDict, self)
self.filterModel.displayed = []
self.filterModel.setSourceModel(self.createtablemodel)
self.filterModel.fileType.append(linetext)
self.createTableSearchFilterModel = QSortFilterProxyModel(self)
self.createTableSearchFilterModel.setSourceModel(self.filterModel)
self.createTableSearchFilterModel.setFilterKeyColumn(1)
self.createTableSearchFilterModel.setDynamicSortFilter(True)
self.ui.metadataTableView.setModel(
self.createTableSearchFilterModel)
self.treeModel = TreeModel(["Available File Metadata"], headerDict,
self.createtablemodel)
if len(self.customInputs) != 0:
for i in range(len(self.customInputs)):
self.createtablemodel.beginInsertRows(
self.createtablemodel.index(
len(self.createtablemodel.metadataList), 0), i, i)
self.createtablemodel.metadataList.append(
self.customInputs[i])
self.createtablemodel.endInsertRows()
self.createTreeSearchFilterModel = QSortFilterProxyModel(self)
self.createTreeSearchFilterModel.setSourceModel(self.treeModel)
self.createTreeSearchFilterModel.setFilterKeyColumn(0)
self.createTreeSearchFilterModel.setDynamicSortFilter(True)
self.createTreeSearchFilterModel.setRecursiveFilteringEnabled(True)
self.ui.metadataTreeView.setModel(self.createTreeSearchFilterModel)
self.treeModel.checkChanged.connect(self.filterModel.checkList)
self.createtrashDelegate.pressed.connect(self.handleRemoveCreate)
self.toggleButtons()
return True
def __init__(self, source_model):
QSortFilterProxyModel.__init__(self)
self._source_model = source_model
self._type_filter = []
self._name_filter = []
self._author_filter = []
self._keyword_filter = []
self._description_filter = []
self._format_filter = []
def __init__(self, parent: QObject, manager: Manager, widget_tasks):
super().__init__(parent)
self._manager = manager
self._tasks_widgets = widget_tasks
self.setWindowTitle("Task Groups")
# Build widgets
self.search_field = QLineEdit(self)
self.table = ExcelLikeTableView(self)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.table.horizontalHeader().setStretchLastSection(True)
self.table.verticalHeader().setVisible(False)
self.button_add = QPushButton("Add", self)
self.button_remove = QPushButton("Remove", self)
self.button_import = QPushButton("Import", self)
self.button_export = QPushButton("Export", self)
# Build layout
layout_header = QHBoxLayout()
layout_header.addWidget(self.search_field)
layout_header.addWidget(self.button_add)
layout_header.addWidget(self.button_remove)
layout_header.addWidget(self.button_import)
layout_header.addWidget(self.button_export)
layout_main = QVBoxLayout()
layout_main.addLayout(layout_header)
layout_main.addWidget(self.table)
main_widget = QWidget(self)
main_widget.setLayout(layout_main)
self.setWidget(main_widget)
# Configure model
self.model = TaskGroupsItemModel(context=self._manager.context, parent=self)
self._model_table = TaskGroupsTableProxyModel()
self._model_table.setSourceModel(self.model)
self._model_table_proxy = QSortFilterProxyModel(self)
self._model_table_proxy.setSourceModel(self._model_table)
# Configure view
self.table.setModel(self._model_table_proxy)
# Connect signals
for signal, callback in (
(self.model.dataChanged, self._on_data_changed),
(self.button_add.pressed, self._on_add),
(self.button_remove.pressed, self._on_remove),
(self.button_export.pressed, self._on_export),
(self.button_import.pressed, self._on_import),
(
self.search_field.textChanged,
self._model_table_proxy.setFilterWildcard,
),
):
signal.connect(callback)
def __init__(self, game_model):
QSortFilterProxyModel.__init__(self)
self._game_model = game_model
self._modded_games_visible = False
self._private_games_visible = False
self._sort_by = GameSortOptions.AGE
self.setSourceModel(game_model)
self.sort(0)
def __init__(self, data_list, header, *args):
QWidget.__init__(self, *args)
# setGeometry(x_pos, y_pos, width, height)
self.setGeometry(300, 200, 570, 450)
self.setWindowTitle('Click on column title to sort')
# Setup the model and view
'''tmodel = MyTableModel(self, data_list, header)
tview = QTableView()
tview.setModel(tmodel)
delegate = MyDelegate()
tview.setItemDelegate(delegate)'''
# Setup the proxy model for sorting and filtering
tmodel = MyTableModel(self, data_list, header)
pmodel = QSortFilterProxyModel()
pmodel.setSourceModel(tmodel)
tview = QTableView()
tview.setModel(pmodel)
delegate = MyDelegate()
tview.setItemDelegate(delegate)
# TableView properties
tview.resizeColumnsToContents() # set column width to fit contents
tview.setShowGrid(False) # hide gridlines
#tview.verticalHeader().hide() # row labels
#tview.horizontalHeader().hide() # column labels
# Select a single row at a time
tview.setSelectionBehavior(QTableView.SelectRows)
tview.setSelectionMode(QTableView.SingleSelection)
# Enable sorting
tview.setSortingEnabled(True)
# Drag and drop reordering using header labels
'''tview.verticalHeader().setSectionsMovable(True)
tview.verticalHeader().setDragEnabled(True)
tview.verticalHeader().setDragDropMode(QAbstractItemView.InternalMove)
tview.horizontalHeader().setSectionsMovable(True)
tview.horizontalHeader().setDragEnabled(True)
tview.horizontalHeader().setDragDropMode(QAbstractItemView.InternalMove)'''
# Drag and drop reordering using rows
tview.setDragEnabled(True)
tview.setAcceptDrops(True)
tview.setDragDropMode(QTableView.InternalMove)
tview.setDragDropOverwriteMode(False)
layout = QVBoxLayout(self)
layout.addWidget(tview)
self.setLayout(layout)
def extractFile(self, fileLink=False):
if fileLink == False:
linetext = QFileDialog.getOpenFileName(
self, self.tr("Select File"),
QStandardPaths.displayName(QStandardPaths.HomeLocation),
self.tr("Files (*" + self.fileType + ")"))[0]
else:
linetext = fileLink
if linetext != "":
self.setWindowTitle(linetext)
self.ui.dataTypeText.setText(linetext.split(".")[1].upper())
self.ui.otherDataFileLineEdit.setText(linetext)
if self.ui.addMetadataFileCheckBox.checkState() == Qt.Checked:
self.uselistmodel.removeAllRows()
self.uselistmodel.addRow(linetext)
self.toggleButtons()
if self.ui.fileParserCombo.findText(
linetext.split(".")[1].upper() + " Parser") != -1:
headerDict = {}
self.ui.fileParserCombo.setCurrentIndex(
self.ui.fileParserCombo.findText(
linetext.split(".")[1].upper() + " Parser"))
if linetext.split(".")[1].upper() == "CTF":
headerDict = ctf.parse_header_as_dict(linetext)
elif linetext.split(".")[1].upper() == "ANG":
headerDict = ang.parse_header_as_dict(linetext)
elif linetext.split(".")[1].upper() == "XML":
print("XML Parser used")
if self.templatedata:
self.usetablemodel.metadataList = []
self.usefilterModel = FilterModelU(self)
self.usefilterModel.setSourceModel(self.usetablemodel)
self.unusedTreeModel = TreeModelU(["Available File Metadata"],
headerDict,
self.usetablemodel,
self.editableKeys)
self.templatelist = []
self.templatesources = []
for i in range(len(self.templatedata)):
self.templatelist.append(self.templatedata[i])
if "Custom Input" not in self.templatedata[i]["Source"]:
self.templatesources.append("/".join(
self.templatedata[i]['Source'].split("/")[1:]))
else:
self.usetablemodel.addExistingRow(self.templatedata[i])
self.usesearchFilterModel = QSortFilterProxyModel(self)
self.usesearchFilterModel.setSourceModel(self.usefilterModel)
self.usesearchFilterModel.setFilterKeyColumn(0)
self.usesearchFilterModel.setDynamicSortFilter(True)
self.ui.useTemplateTableView.setModel(
self.usesearchFilterModel)
self.toggleButtons()
def __init__(self, parent=None):
QSortFilterProxyModel.__init__(self, parent)
# char* m_filterRoles;
self.m_filterRoles = ""
# char* m_sortData;
self.m_sortData = ""
self.m_typeSort = 0
self.m_boolSignalReset = False
self.m_reguexp = QRegularExpression()
self.m_strexp = ""
self.m_boolstrexp = True
self.m_boolVacio = True
def setup_fridge_views(self):
self.fridge_model = FridgeModel(foods=self.person.foods)
self.fridge_filter_model = QSortFilterProxyModel(self)
self.fridge_filter_model.setSourceModel(self.fridge_model)
self.fridge_view.setModel(self.fridge_filter_model)
self.prices_view.setModel(self.fridge_filter_model)
self.constraints_view.setModel(self.fridge_filter_model)
self.nut_quant_view.setModel(self.fridge_filter_model)
self.fridge_filter_model.setFilterKeyColumn(NAME_COL)
# Hide col
hide_view_cols(self.fridge_view, F_COLS_TO_HIDE)
hide_view_cols(self.prices_view, P_COLS_TO_HIDE)
hide_view_cols(self.constraints_view, C_COLS_TO_HIDE)
hide_view_cols(self.nut_quant_view, N_COLS_TO_HIDE)
# Header must be explicitly set to visible even if set in Designer
self.fridge_view.horizontalHeader().setVisible(True)
self.prices_view.horizontalHeader().setVisible(True)
self.constraints_view.horizontalHeader().setVisible(True)
self.nut_quant_view.horizontalHeader().setVisible(True)
# Set column width
self.prices_view.setColumnWidth(PRICE_COL, VALUE_COL_WIDTH)
self.prices_view.setColumnWidth(PER_COL, PER_COL_WIDTH)
self.prices_view.setColumnWidth(PRICE_QUANTITY_COL, VALUE_COL_WIDTH)
self.constraints_view.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.nut_quant_view.setColumnWidth(NUT_QUANT_COL, VALUE_COL_WIDTH)
# Set row height
set_v_header_height(self.fridge_view, FRIDGE_V_HEADER_SIZE)
set_v_header_height(self.prices_view, FRIDGE_V_HEADER_SIZE)
set_v_header_height(self.constraints_view, FRIDGE_V_HEADER_SIZE)
set_v_header_height(self.nut_quant_view, FRIDGE_V_HEADER_SIZE)
set_header_font(self.fridge_view, FONT_MAIN_SIZE, QFont.DemiBold)
set_header_font(self.prices_view, FONT_MAIN_SIZE, QFont.DemiBold)
set_header_font(self.constraints_view, FONT_MAIN_SIZE, QFont.DemiBold)
set_header_font(self.nut_quant_view, FONT_MAIN_SIZE, QFont.DemiBold)
# Set header fixed
self.fridge_view.horizontalHeader().setSectionResizeMode(QHeaderView.Fixed)
self.prices_view.horizontalHeader().setSectionResizeMode(QHeaderView.Fixed)
#self.constraints_view.horizontalHeader().setSectionResizeMode(QHeaderView.Fixed)
self.nut_quant_view.horizontalHeader().setSectionResizeMode(QHeaderView.Fixed)
# Hide fridge scrollbar
self.fridge_view.verticalScrollBar().setStyleSheet(
"QScrollBar {width:0px;}")
def __init__(self, name, layers, filter, expand=True):
super().__init__()
self.setWindowModality(QtCore.Qt.WindowModal)
self.currently_expanded = True
self.main_layout = QVBoxLayout()
self.main_layout.setMargin(0)
self.main_layout.setSpacing(0)
self.main_layout.setContentsMargins(0, 0, 0, 0)
self.expand_button = QPushButton(name)
self.expand_button.setToolTip(f"List of {name} Layers")
self.expand_button.setIcon(
QIcon(os.path.join(PATH, 'LayersList_Down.png')))
self.layer_list = QListView()
self.layer_list.setDragEnabled(True)
self.layer_list.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.layer_list.setWrapping(False)
self.layer_list.setViewMode(self.layer_list.ListMode)
self.container_model = QStandardItemModel()
self.model = QSortFilterProxyModel()
self.model.setSourceModel(self.container_model)
self.model.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive)
#self.model.cas
filter.textChanged.connect(self.filter_model)
for l in layers:
self.container_model.appendRow(
QStandardItem(
QIcon(os.path.join(PATH, 'LayersList_Layer_Icon.png')), l))
self.layer_list.setModel(self.model)
self.main_layout.addWidget(self.expand_button, 0, Qt.AlignTop)
self.main_layout.addWidget(self.layer_list, 0, Qt.AlignTop)
self.expand_button.clicked.connect(self.expand)
self.setLayout(self.main_layout)
self.resized_size = len(layers) * (self.layer_list.sizeHintForRow(0) +
self.layer_list.frameWidth())
self.layer_list.setMaximumHeight(self.resized_size)
self.layer_list.setMinimumHeight(self.resized_size)
self.setMinimumWidth(self.layer_list.frameWidth())
self.set_styling()
if not expand:
self.expand()
def __init__(self, *args, **kwargs):
self._model = self.model_class()
self.proxy_model = QSortFilterProxyModel()
self.proxy_model.setSourceModel(self._model)
layout = QVBoxLayout()
self.table_view = QTableView()
self.table_view.setModel(self.proxy_model)
self.table_view.setSortingEnabled(True)
self.table_view.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table_view.doubleClicked.connect(self.table_double_clicked)
layout.addWidget(self.table_view)
self.extra_data = dict()
super().__init__(*args, **kwargs)
self.setLayout(layout)
def __init__(self, workbench: WorkbenchModel, parent: QWidget = None):
super().__init__(workbench, parent)
self.settingsPanel = _SettingsPanel(self)
self.chartView = InteractiveChartView(parent=self, setInWindow=False)
p: QSizePolicy = self.chartView.sizePolicy()
p.setHorizontalStretch(20)
self.chartView.setSizePolicy(p)
self.searchableIndexTableModel: QSortFilterProxyModel = QSortFilterProxyModel(
self)
self.splitter = QSplitter(Qt.Horizontal, self)
self.splitter.addWidget(self.chartView)
self.splitter.addWidget(self.settingsPanel)
# Adjust size policies
policy = self.settingsPanel.sizePolicy()
policy.setHorizontalStretch(2)
self.settingsPanel.setSizePolicy(policy)
# Add splitter to main layout
layout = QHBoxLayout(self)
layout.addWidget(self.splitter)
self.settingsPanel.createButton.clicked.connect(self.createChart)
self.settingsPanel.timeAxisFormatCB.currentTextChanged.connect(
self.changeTimeFormat)
def __init__(self, parent=None):
super(HPasteCollectionWidget.__HPasteCollectionWidget,
self).__init__(parent,
metadataExposedKeys=('raw_url', 'nettype'))
for x in xrange(1, 5):
self.ui.mainView.horizontalHeader().hideSection(x)
self.__nepane = None
self.__netType = ''
self.__nettypeFilter = QSortFilterProxyModel(self)
self.__nettypeFilter.setFilterKeyColumn(4)
self.__nettypeFilter.setFilterRegExp(
QRegExp("*", Qt.CaseInsensitive, QRegExp.Wildcard))
self.appendFilter(self.__nettypeFilter)
self.accepted.connect(self.doOnAccept)
def _proxy_model_filter_accepts_row(self, source_row, source_parent):
"""Always accept first row.
"""
if source_row == 0:
return True
return QSortFilterProxyModel.filterAcceptsRow(self.proxy_model,
source_row,
source_parent)
def setupTable(self):
proxyModel = QSortFilterProxyModel(self)
proxyModel.setSourceModel(self.tableModel)
proxyModel.setDynamicSortFilter(True)
self.tableView.setModel(proxyModel)
self.tableView.setSortingEnabled(True)
self.tableView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tableView.horizontalHeader().setStretchLastSection(True)
self.tableView.verticalHeader().hide()
self.tableView.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.tableView.setSelectionMode(QAbstractItemView.SingleSelection)
proxyModel.setFilterKeyColumn(0) # Filter on the "name" column
proxyModel.sort(0, Qt.AscendingOrder)
viewselectionmodel = self.tableView.selectionModel()
self.tableView.selectionModel().selectionChanged.connect(self.selectionChanged)
def setupTabs(self):
""" Setup the various tabs in the AddressWidget. """
groups = ["ABC", "DEF", "GHI", "JKL", "MNO", "PQR", "STU", "VW", "XYZ"]
for group in groups:
proxyModel = QSortFilterProxyModel(self)
proxyModel.setSourceModel(self.tableModel)
proxyModel.setDynamicSortFilter(True)
tableView = QTableView()
tableView.setModel(proxyModel)
tableView.setSortingEnabled(True)
tableView.setSelectionBehavior(QAbstractItemView.SelectRows)
tableView.horizontalHeader().setStretchLastSection(True)
tableView.verticalHeader().hide()
tableView.setEditTriggers(QAbstractItemView.NoEditTriggers)
tableView.setSelectionMode(QAbstractItemView.SingleSelection)
# This here be the magic: we use the group name (e.g. "ABC") to
# build the regex for the QSortFilterProxyModel for the group's
# tab. The regex will end up looking like "^[ABC].*", only
# allowing this tab to display items where the name starts with
# "A", "B", or "C". Notice that we set it to be case-insensitive.
reFilter = "^[%s].*" % group
proxyModel.setFilterRegExp(QRegExp(reFilter, Qt.CaseInsensitive))
proxyModel.setFilterKeyColumn(0) # Filter on the "name" column
proxyModel.sort(0, Qt.AscendingOrder)
# This prevents an application crash (see: http://www.qtcentre.org/threads/58874-QListView-SelectionModel-selectionChanged-Crash)
viewselectionmodel = tableView.selectionModel()
tableView.selectionModel().selectionChanged.connect(self.selectionChanged)
self.addTab(tableView, group)
