def add_item2model(self, filename: str, model: QStandardItemModel):
"""sample listview code"""
list_item = QStandardItem(filename)
list_item.setCheckable(True)
list_item.setEditable(False)
list_item.setSelectable(False)
model.appendRow(list_item)
def __init__(self, parent=None):
super(MyWidget, self).__init__(parent)
self.view = View()
self.grid = DateTimeGrid()
self.model = QStandardItemModel()
self.slider = QSlider()
self.view.setGraphicsView(MyGraphicsView())
## proxyModel.setSourceModel( &model );
for h in range(0, 2):
self.model.appendRow([
MyStandardItem("Item " + str(h)),
MyStandardItem(KDGantt.TypeTask),
MyStandardItem(QDateTime.currentDateTime().addDays(h),
KDGantt.StartTimeRole),
MyStandardItem(QDateTime.currentDateTime().addDays(h + 1),
KDGantt.EndTimeRole),
MyStandardItem(50)
])
self.slider.setOrientation(Qt.Horizontal)
self.slider.setRange(1, 10000)
self.slider.setValue(100)
l = QVBoxLayout(self)
l.addWidget(self.view)
l.addWidget(self.slider)
self.grid.setStartDateTime(QDateTime.currentDateTime().addDays(-3))
self.grid.setDayWidth(100)
## grid.setNoInformationBrush( Qt::NoBrush );
self.view.setGrid(self.grid)
self.view.setModel(self.model)
self.slider.valueChanged.connect(self.slotZoom)
def model(self) -> QStandardItemModel:
items: List[QTreeWidgetItem] = \
self.findItems('*', Qt.MatchWrap | Qt.MatchWildcard | Qt.MatchRecursive)
model = QStandardItemModel()
def standardItem(w: QTreeWidgetItem) -> QStandardItem:
s = QStandardItem()
s.setData(w.data(0, Qt.DisplayRole), Qt.DisplayRole)
s.setData(w.data(1, Qt.UserRole), Qt.UserRole)
s.setData(w.data(0, Qt.ToolTipRole), Qt.ToolTipRole)
return s
def filterItems(item: QTreeWidgetItem) -> bool:
op_class: type = item.data(1, Qt.UserRole)
keep: bool = bool(item.parent())
if keep and issubclass(op_class, GraphOperation):
keep &= op_class.minInputNumber() == op_class.maxInputNumber() == 1 \
and op_class.minOutputNumber() == 1
else:
keep &= item.isHidden()
return keep
items = list(map(standardItem, filter(filterItems, items)))
for i in items:
model.appendRow(i)
return model
class QInfoList(QListView):
def __init__(self, game: Game):
super(QInfoList, self).__init__()
self.model = QStandardItemModel(self)
self.setModel(self.model)
self.game = game
self.update_list()
self.selectionModel().setCurrentIndex(self.indexAt(QPoint(1, 1)),
QItemSelectionModel.Select)
self.selectionModel().selectionChanged.connect(
self.on_selected_info_changed)
def on_selected_info_changed(self):
index = self.selectionModel().currentIndex().row()
def update_list(self):
self.model.clear()
if self.game is not None:
for i, info in enumerate(reversed(self.game.informations)):
self.model.appendRow(QInfoItem(info))
self.selectionModel().setCurrentIndex(self.indexAt(QPoint(1, 1)),
QItemSelectionModel.Select)
def setGame(self, game):
self.game = game
self.update_list()
def __init__(self,
toolbox,
project,
logger,
name,
description,
x,
y,
cancel_on_error=False):
"""
Combiner class.
Args:
toolbox (ToolboxUI): a toolbox instance
project (SpineToolboxProject): the project this item belongs to
logger (LoggerInterface): a logger instance
name (str): Object name
description (str): Object description
x (float): Initial X coordinate of item icon
y (float): Initial Y coordinate of item icon
cancel_on_error (bool, optional): if True, changes will be reverted on errors
"""
super().__init__(name, description, x, y, project, logger)
self._toolbox = toolbox
self.logs_dir = os.path.join(self.data_dir, "logs")
try:
create_dir(self.logs_dir)
except OSError:
self._logger.msg_error.emit(
f"[OSError] Creating directory {self.logs_dir} failed. Check permissions."
)
self.cancel_on_error = cancel_on_error
self._references = dict()
self.reference_model = QStandardItemModel() # References to databases
self._spine_ref_icon = QIcon(QPixmap(":/icons/Spine_db_ref_icon.png"))
def dropEvent(self, e):
item = None
if e.mimeData().hasFormat('application/x-qabstractitemmodeldatalist'):
data = e.mimeData()
sourceItem = QStandardItemModel()
sourceItem.dropMimeData(data, QtCore.Qt.CopyAction, 0, 0,
QtCore.QModelIndex())
item = sourceItem.item(0, 0)
if item:
itemName = item.text()
currentCollection = self.actionManagerViewer.selectedCollectionName
collectionActionIds = self.actionManagerViewer.actionManager.getCollectionActionIds(
currentCollection)
if item.hasChildren():
# Add the children:
for childActionId in self.actionManagerViewer.actionManager.getActionIdsOfCategory(
itemName):
if self.actionManagerViewer.actionManager.isValidActionId(
childActionId
) and not childActionId in collectionActionIds:
self.actionManagerViewer.addCollectionActionEntry(
childActionId)
self.actionManagerViewer.actionManager.linkActionToCollection(
childActionId, currentCollection)
else:
self.actionManagerViewer.actionManager.linkActionToCollection(
itemName, currentCollection)
super().dropEvent(e)
def __init__(self, filter_id, columns, headersname, parent=None):
super(FiltersForm, self).__init__(parent)
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.setWindowModality(Qt.ApplicationModal)
self.setWindowTitle('Filter')
self.filter_id = filter_id
self.columns = columns
self.main_form = parent
#form
self.line_filters = [self.ui.lineEditfilter_1,
self.ui.lineEditfilter_2,
self.ui.lineEditfilter_3,
self.ui.lineEditfilter_4,
self.ui.lineEditfilter_5]
for line in self.line_filters:
line.setClearButtonEnabled(True)
line.setEnabled(False)
line.textChanged.connect(self.make_filter)
#table
self.table = self.ui.tableViewcolumns
self.sti = QStandardItemModel()
self.table.setModel(self.sti)
self.table.verticalHeader().setDefaultSectionSize(10)
self.table.horizontalHeader().setDefaultSectionSize(172)
self.table.setSortingEnabled(True)
#treeWidget
self.tw = self.ui.treeWidgetasignet
self.tw.setHeaderLabels(['Name'] + headersname)
self.tw.setAlternatingRowColors(True)
"""
set controls data
"""
self.sti.setHorizontalHeaderLabels(headersname)
self.sti.setColumnCount(len(headersname))
self.setrowdata(columns)
"""
signals
"""
self.ui.pushButtonaddnew.clicked.connect(self.add_new_parent_node)
self.tw.itemChanged.connect(self.uncheck_others_items_tree)
self.ui.pushButtonadddata.clicked.connect(self.add_children)
self.ui.pushButtonremovenodes.clicked.connect(self.delete_tree_items)
self.ui.checkBoxCheckAll.stateChanged.connect(lambda: self.select_deselect_rows(self.ui.checkBoxCheckAll))
self.ui.checkBoxnotassigne.stateChanged.connect(lambda: self.show_not_assigned_rows(self.ui.checkBoxnotassigne))
self.ui.pushButtonrun.clicked.connect(self.make_assigned)
self.ui.pushButtonremove_fitlers_text.clicked.connect(self.clear_all_filter_line)
"""
function
"""
self.get_data_from_database()
self.set_filter_line_enable()
self.start_rows = self.get_all_data_table()
def __init__(self, toolbox, name, description, references, x, y):
"""Class constructor."""
super().__init__(name, description)
self._toolbox = toolbox
self._project = self._toolbox.project()
self.item_type = "Data Connection"
# self._widget = DataConnectionWidget(self, self.item_type)
self.reference_model = QStandardItemModel() # References to files
self.data_model = QStandardItemModel(
) # Paths of project internal files. These are found in DC data directory
self.datapackage_icon = QIcon(QPixmap(":/icons/datapkg.png"))
self.data_dir_watcher = QFileSystemWatcher(self)
# Make project directory for this Data Connection
self.data_dir = os.path.join(self._project.project_dir,
self.short_name)
try:
create_dir(self.data_dir)
self.data_dir_watcher.addPath(self.data_dir)
except OSError:
self._toolbox.msg_error.emit(
"[OSError] Creating directory {0} failed."
" Check permissions.".format(self.data_dir))
# Populate references model
self.references = references
self.populate_reference_list(self.references)
# Populate data (files) model
data_files = self.data_files()
self.populate_data_list(data_files)
self._graphics_item = DataConnectionImage(self._toolbox, x - 35,
y - 35, 70, 70, self.name)
self.spine_datapackage_form = None
# self.ui.toolButton_datapackage.setMenu(self.datapackage_popup_menu) # TODO: OBSOLETE?
self._sigs = self.make_signal_handler_dict()
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 initUi(self):
self.layout = QGridLayout()
self.categoryList = QListView()
self.right_layout = QStackedLayout()
self.categoryList.setMaximumWidth(175)
self.categoryModel = QStandardItemModel(self.categoryList)
self.categoryList.setIconSize(QSize(32, 32))
for name, page in self.pages.items():
page_item = QStandardItem(name)
if name in CONST.ICONS:
page_item.setIcon(CONST.ICONS[name])
else:
page_item.setIcon(CONST.ICONS["Generator"])
page_item.setEditable(False)
page_item.setSelectable(True)
self.categoryModel.appendRow(page_item)
self.right_layout.addWidget(page)
self.initCheatLayout()
cheat = QStandardItem("Cheat Menu")
cheat.setIcon(CONST.ICONS["Cheat"])
cheat.setEditable(False)
cheat.setSelectable(True)
self.categoryModel.appendRow(cheat)
self.right_layout.addWidget(self.cheatPage)
self.pluginsPage = PluginsPage()
plugins = QStandardItem("LUA Plugins")
plugins.setIcon(CONST.ICONS["Plugins"])
plugins.setEditable(False)
plugins.setSelectable(True)
self.categoryModel.appendRow(plugins)
self.right_layout.addWidget(self.pluginsPage)
self.pluginsOptionsPage = PluginOptionsPage()
pluginsOptions = QStandardItem("LUA Plugins Options")
pluginsOptions.setIcon(CONST.ICONS["PluginsOptions"])
pluginsOptions.setEditable(False)
pluginsOptions.setSelectable(True)
self.categoryModel.appendRow(pluginsOptions)
self.right_layout.addWidget(self.pluginsOptionsPage)
self.categoryList.setSelectionBehavior(QAbstractItemView.SelectRows)
self.categoryList.setModel(self.categoryModel)
self.categoryList.selectionModel().setCurrentIndex(
self.categoryList.indexAt(QPoint(1, 1)), QItemSelectionModel.Select
)
self.categoryList.selectionModel().selectionChanged.connect(
self.onSelectionChanged
)
self.layout.addWidget(self.categoryList, 0, 0, 1, 1)
self.layout.addLayout(self.right_layout, 0, 1, 5, 1)
self.setLayout(self.layout)
class QCampaignList(QListView):
CampaignRole = Qt.UserRole
def __init__(self, campaigns: list[Campaign],
show_incompatible: bool) -> None:
super(QCampaignList, self).__init__()
self.campaign_model = QStandardItemModel(self)
self.setModel(self.campaign_model)
self.setMinimumWidth(250)
self.setMinimumHeight(350)
self.campaigns = campaigns
self.setSelectionBehavior(QAbstractItemView.SelectItems)
self.setup_content(show_incompatible)
@property
def selected_campaign(self) -> Campaign:
return self.currentIndex().data(QCampaignList.CampaignRole)
def setup_content(self, show_incompatible: bool) -> None:
self.selectionModel().blockSignals(True)
try:
self.campaign_model.clear()
for campaign in self.campaigns:
if show_incompatible or campaign.is_compatible:
item = QCampaignItem(campaign)
self.campaign_model.appendRow(item)
finally:
self.selectionModel().blockSignals(False)
self.selectionModel().setCurrentIndex(
self.campaign_model.index(0, 0, QModelIndex()),
QItemSelectionModel.Select)
def __init__(self, app, window, lib_tree):
QObject.__init__(self)
self.app = app
self.lib_tree = lib_tree
self.library = app.library
self.input = window.search_query_input
self.view = window.lib_items
self.tree_conditions = []
self.items = []
self.items_incomplete = False
self.model = ItemModel(self.app)
self.model.setColumnCount(1)
self.compl_model = QStandardItemModel()
self.compl_model.setColumnCount(1)
self.completer = QCompleter(self.compl_model)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setModelSorting(QCompleter.CaseSensitivelySortedModel)
self.input.setCompleter(self.completer)
self.view.setHeaderHidden(True)
self.view.setIndentation(0)
self.view.setModel(self.model)
self.view.sortByColumn(0, Qt.AscendingOrder)
self.view.setDragEnabled(True)
self.view.setAcceptDrops(True)
self.view.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
selection_model = self.view.selectionModel()
selection_model.selectionChanged.connect(self.selection_changed)
tree_selection_model = window.lib_tree.selectionModel()
tree_selection_model.selectionChanged.connect(
self.tree_selection_changed)
self.input.editingFinished.connect(self.query_entered)
self.input.textChanged.connect(self.query_changed)
self.view.doubleClicked.connect(self.double_clicked)
self.run_query()
def __init__(self):
super(CollectionsHistoryTabs, self).__init__()
self.setupUi(self)
self.historyList.setContextMenuPolicy(Qt.CustomContextMenu)
self.historyList.customContextMenuRequested.connect(self.historyMenu)
self.historyModel = QStandardItemModel()
self.historyList.setModel(self.historyModel)
self.historyList.header().hide()
self.historyList.expandToDepth(0)
self.historyList.doubleClicked.connect(self.emitItem)
self.collectionsModel = QStandardItemModel()
default = QStandardItem("Default")
default.setEditable(False)
default.setIcon(self.folder_icon)
self.collectionsModel.appendRow(default)
self.collectionsTree.setModel(self.collectionsModel)
self.collectionsTree.header().hide()
self.collectionsTree.expandToDepth(0)
self.collectionsTree.doubleClicked.connect(self.emitItem)
self.collectionsTree.setContextMenuPolicy(Qt.CustomContextMenu)
self.collectionsTree.customContextMenuRequested.connect(
self.collectionsMenu)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.model = QStandardItemModel()
self.setModel(self.model)
self.setHeaderHidden(True)
self.expanded.connect(self.expanded__handler)
self.profiles = []
def __init__(self, parent, task):
'''
Params:
-------
parent : FormMainWindow
task : MirrorTask
'''
super(DlgHistory, self).__init__(parent)
# initialize the UI
self.ui = Ui_DlgHistory()
self.ui.setupUi(self)
try:
# get the task from param
self._task = task
# initialize the logManager
self.logManager = LogManager()
# inits the selection model for TableView
self.taskViewModel = QStandardItemModel(self)
# sets the model to the TableView
self.ui.tableView.setModel(self.taskViewModel)
# connect double-clicked event to On_View
self.ui.tableView.doubleClicked.connect(self.On_View)
# set the cell delegate
self.tableLabelDelegate = LabelItemDelegate(
self.taskViewModel, self.ui.tableView)
for i in range(2):
self.ui.tableView.setItemDelegateForColumn(
i, self.tableLabelDelegate)
# reset the history list
self.log_data = []
# loads the table
self.LoadTable()
except Exception as e:
print(f'HistoryDlg Err:{e}')
def __init__(self, dialog_model, dialog_controller):
settings = Qt.Window | Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint
super(ListDialogView, self).__init__(None, settings)
self.setAttribute(Qt.WA_TranslucentBackground)
self._model = dialog_model
self._dialog_ctrl = dialog_controller
self._ui = Ui_ListDialog()
self._ui.setupUi(self)
delete_button_delegate = DeleteButtonDelegate(self)
self._commodity_model = QStandardItemModel(0, 2, self._ui.commodity_list)
for commodity in self._model:
self._commodity_model.appendRow([QStandardItem(str(commodity)), QStandardItem()])
"""connect widgets to controller"""
self._ui.button_add.clicked.connect(self.add_list_item)
self._ui.commodity_list.clicked.connect(self.remove_list_item)
self._ui.commodity_list.hover_index_changed.connect(delete_button_delegate.on_hover_index_changed)
self.accepted.connect(self.on_dialog_accepted)
self._ui.cancel_button.clicked.connect(self.reject)
self._ui.apply_button.clicked.connect(self.accept)
"""initialize view"""
self._ui.commodity_name.set_model(PropertyLineEdit(""))
self._ui.commodity_list.setModel(self._commodity_model)
self._ui.commodity_list.setItemDelegateForColumn(1, delete_button_delegate)
self._ui.commodity_list.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch)
self._ui.commodity_list.horizontalHeader().setSectionResizeMode(1, QHeaderView.Fixed)
self._ui.commodity_list.setColumnWidth(1, 22)
def __init__(self) -> None:
QWidget.__init__(self)
# self.index stores the index of the latest item which is clicked
self.index = None
self.model = QStandardItemModel()
file_view = QListView()
file_view.setModel(self.model)
file_view.setEditTriggers(QAbstractItemView.NoEditTriggers)
file_view.clicked.connect(self.onClicked)
file_view.doubleClicked.connect(self.onDoubleClicked)
open_file_button = QPushButton('Open')
open_file_button.clicked.connect(self.onOpenFile)
preview_file_button = QPushButton('Preview')
preview_file_button.clicked.connect(self.onPreviewFile)
layout = QGridLayout()
layout.addWidget(file_view, 0, 0, 1, 2)
layout.addWidget(open_file_button, 1, 0, 1, 1)
layout.addWidget(preview_file_button, 1, 1, 1, 1)
layout.setMargin(0)
self.setLayout(layout)
def __init__(self, calculator, parent=None):
super().__init__(parent)
calculator.projectDictChanged.connect(self.onProjectChanged)
self._project_dict = calculator.asDict()
self._headers_model = QStandardItemModel()
self._data_model = QStandardItemModel()
self._setModelsFromProjectDict()
def __init__(self, parent=None):
super().__init__(parent)
self._calculator = None
# Create the status items
chi_item = StatusItem('chiSq',
title='Current \u03c7\u00b2',
additionalData=1)
chi_item.setReturn(True)
chi_item.title = 'Previous \u03c7\u00b2'
chi_item.setReturn(False)
self._interestedList = StatusList([
chi_item,
StatusItem('numPars', title='Fit parameters', additionalData=1),
StatusItem('numData', title='Experiments', additionalData=0),
StatusItem('numPhases', title='Phases', additionalData=0)
])
# minor properties
self._first_role = Qt.UserRole + 1
self._statusBarModel = QStandardItemModel()
self._chartDisplayModel = QStandardItemModel()
# set role names
self._role_names_list = ['label', 'value']
self._roles_list = []
self._roles_dict = {'status': {}, 'plot': {}}
self._setRolesListAndDict()
self._statusBarModel.setItemRoleNames(self._roles_dict['status'])
self._chartDisplayModel.setItemRoleNames(self._roles_dict['plot'])
self._log = logger.getLogger(self.__class__.__module__)
def __init__(self):
super().__init__()
self.folderModel = QStandardItemModel()
self.setModel(self.folderModel)
self.setFrameStyle(QFrame.NoFrame)
self.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setItemDelegate(Folder())
self.setStyleSheet(
'FolderList { background-color: Transparent; color: rgb(190,190,190); }'
)
self.setAttribute(Qt.WA_TranslucentBackground)
for idx, folder in enumerate(self.getImageFolders()):
item = QStandardItem(folder)
item.setData(folder.replace('imgur',
'').replace('reddit_sub',
'').replace('_', ''),
role=Qt.DisplayRole)
item.setData(os.path.join(ThemeManager.IMAGE_FOLDERS_PATH, folder),
role=Qt.UserRole)
item.setData(folder, role=Qt.UserRole + 1)
self.folderModel.appendRow(item)
def __init__(self, title, message, items, parent=None):
"""
Constructor of ListerView which creates a new dialog with
scrolled items which the user can mark
Args:
title (str): The dialog title that should appear
message (str): The message that the user will see at the top of the dialog
items ([str]): A list of strings that will be showns as options
"""
super(ListerView, self).__init__(parent=parent)
form = QFormLayout(self)
form.addRow(QLabel(message))
self.listView = QListView(self)
self.listView.clicked.connect(self.mouse_click_event)
form.addRow(self.listView)
model = QStandardItemModel(self.listView)
self.setWindowTitle(title)
for item in items:
standardItem = QStandardItem(item)
standardItem.setCheckable(True)
standardItem.setEditable(False)
model.appendRow(standardItem)
self.listView.setModel(model)
def __init__(self, parent=None):
super().__init__(parent)
self._headers_model = QStandardItemModel()
self._model = QStandardItemModel()
self._calculator_interface = None
self._project_dict = None
self._log = None
def __init__(self):
super(Window, self).__init__()
self.table = QTableView()
self.sti = QStandardItemModel()
self.sti.setColumnCount(3)
self.table.setModel(self.sti)
self.sti.setRowCount(8)
#piersza możliwośc przez QStandardItem
# item1 = QStandardItem('Red')
# item1.setBackground(QBrush(Qt.red))
# self.sti.setHorizontalHeaderItem(1, item1)
#Druga możliwosć przez odwołanie modelu:
self.table.model().setHeaderData(0, Qt.Horizontal,
QBrush(QColor(121, 166, 210)),
Qt.BackgroundRole)
self.table.model().setHeaderData(0, Qt.Horizontal, "One",
Qt.DisplayRole)
self.mlayout = QHBoxLayout()
self.mlayout.addWidget(self.table)
self.setLayout(self.mlayout)
def __init__(self, parent=None):
super().__init__(parent)
self._project_dict = None
self._model = QStandardItemModel()
# set roles
self._label_role = Qt.UserRole + 1
self._type_role = Qt.UserRole + 2
self._chiiso_role = Qt.UserRole + 3
self._chi11_role = Qt.UserRole + 4
self._chi22_role = Qt.UserRole + 5
self._chi33_role = Qt.UserRole + 6
self._chi12_role = Qt.UserRole + 7
self._chi13_role = Qt.UserRole + 8
self._chi23_role = Qt.UserRole + 9
self._model.setItemRoleNames({
self._label_role: b'label',
self._type_role: b'type',
self._chiiso_role: b'chiiso',
self._chi11_role: b'chi11',
self._chi22_role: b'chi22',
self._chi33_role: b'chi33',
self._chi12_role: b'chi12',
self._chi13_role: b'chi13',
self._chi23_role: b'chi23'
})
self._log = logger.getLogger(self.__class__.__module__)
def _setup_scan_dir_list_model(self):
self._dirs_list_model = QStandardItemModel()
self._dirs_list_selection_model = QItemSelectionModel(
self._dirs_list_model)
self._thumbs_view_model = QStandardItemModel()
self._thumbs_selection_model = QItemSelectionModel(
self._thumbs_view_model)
self._dirs_list_model.setColumnCount(1)
# self._dirs_list_model.setRowCount(len(scan_dirs))
self._root_tree_item = self._dirs_list_model.invisibleRootItem()
# FOLDERS item
folder_item = QStandardItem("Folders")
folder_item_font = QFont()
folder_item_font.setBold(True)
folder_item.setFont(folder_item_font)
folder_item.setSizeHint(QSize(folder_item.sizeHint().width(), 24))
self._root_tree_item.appendRow(folder_item)
self._TV_FOLDERS_ITEM_MAP[0] = folder_item
self.treeView_scandirs.setModel(self._dirs_list_model)
self.treeView_scandirs.setSelectionModel(
self._dirs_list_selection_model)
# self.treeView_scandirs.setRootIsDecorated(False)
self.listView_thumbs.setModel(self._thumbs_view_model)
self.listView_thumbs.setSelectionModel(self._thumbs_selection_model)
scan_dirs = self._meta_files_mgr.get_scan_dirs()
self._populate_dirs_tree_view(0, scan_dirs)
def _createModelFromData(self, headers_blocks, data_blocks):
"""Create the model needed for GUI calculated data table and chart (based on data 2d list created previously)."""
if self._project.experimentsCount() > 1:
print("Currently, only 1 measured datablock is supported. Given: ",
self._project.experimentsCount())
experiment_id = self._project.experimentsIds()[
0] # only 1st measured datablock is currently taken into account
headers, data = headers_blocks[experiment_id], data_blocks[
experiment_id]
row_count = len(data)
column_count = len(data[0])
# set headers
headerModel = QStandardItemModel(1, column_count)
for column_index in range(column_count):
index = headerModel.index(0, column_index)
value = headers[column_index]
headerModel.setData(index, value,
Qt.DisplayRole) #Qt.WhatsThisRole
# set model data
dataModel = QStandardItemModel(row_count, column_count)
for row_index in range(row_count):
for column_index in range(column_count):
index = dataModel.index(row_index, column_index)
value = data[row_index][column_index]
dataModel.setData(index, value, Qt.DisplayRole)
return headerModel, dataModel
class MainWindow(QMainWindow, Ui_MainWindow):
"""Main application window for Qud Blueprint Explorer."""
def __init__(self, app: QApplication, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
self.app = app
self.setupUi(self)
icon = QIcon("spray_bottle.png")
self.setWindowIcon(icon)
self.qud_object_model = QStandardItemModel()
# We only need to add Object to the model, since all other Objects are loaded as children:
self.qud_object_model.appendRow(
self.init_qud_object(self.qud_object_model, qud_object_root))
self.treeView.setModel(self.qud_object_model)
self.treeView.clicked[QModelIndex].connect(self.tree_item_clicked)
def init_qud_object(self, model: QStandardItemModel,
qud_object: QudObject):
item = QStandardItem(qud_object.name)
if not qud_object.is_leaf:
for child in qud_object.children:
item.appendRow(self.init_qud_object(model, child))
if qud_object.is_specified('tag_BaseObject'):
item.setSelectable(False)
item.setData(qud_object)
return item
def tree_item_clicked(self, index):
item = self.qud_object_model.itemFromIndex(index)
qud_object = item.data()
text = pprint.pformat(qud_object.attributes)
self.plainTextEdit.setPlainText(text)
def __init__(self):
super(MainWindow, self).__init__()
#ui
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.comboBox_dict.addItems(dicts)
#signal
self.ui.pushButton_create.clicked.connect(self.createBoard)
self.ui.pushButton_save.clicked.connect(self.saveBoard)
self.ui.pushButton_open.clicked.connect(self.OpenImages)
self.ui.tableView.clicked.connect(self.showImg) #列表图片显示
self.ui.pushButton_calib.clicked.connect(self.calib)
self.ui.pushButton_saveParameter.clicked.connect(self.saveParameter)
self.ui.pushButton_output.clicked.connect(self.saveCameraGroup)
self.ui.pushButton_clear.clicked.connect(self.clearGroup)
self.ui.listView_Camera.clicked.connect(self.showCamera)
#property
self.model = QStandardItemModel() #tab 1
self.cameraListModel = QStringListModel() #tab 2
self.cameraLists = []
self.ui.listView_Camera.setModel(self.cameraListModel)
self.caliber = None
self.cameraGroup = CameraGroup.CameraGroup()
#other
self.calibBoard = CharucoBoard.ChessBoard()
self.board = None
self.boardType = 0
def __init__(self, model, tabWidget, parent=None):
super(ChartWidget, self).__init__(parent)
self.model = model
self.tabWidget = tabWidget
layout = QVBoxLayout(self)
chartGroupBox = QGroupBox("General Settings")
grid = QGridLayout(self)
grid.addWidget(QLabel("Name"), 0, 0)
self.nameLineEdit = QLineEdit()
self.nameLineEdit.setText(model.text())
self.nameLineEdit.textChanged.connect(self.updateText)
grid.addWidget(self.nameLineEdit, 0, 1)
self.typeComboBox = QComboBox()
self.typeComboBox.currentIndexChanged.connect(self.changeType)
grid.addWidget(self.typeComboBox, 1, 1)
chartGroupBox.setLayout(grid)
layout.addWidget(chartGroupBox)
self.chartWidget = QWidget()
layout.addWidget(self.chartWidget)
# using to dynamically add and remove chart settings/preview widgets
self.stackedWidget = QStackedWidget(self)
layout.addWidget(self.stackedWidget)
# layout.addStretch()
self.setLayout(layout)
# adding type values here is a violation of object-oriented design
# a more polymorphic implementation is desirable
chartTypesLst = [
('Bar Chart', "icons/chart-types/bar-chart.svg", BarChartModel),
('Box Plot', "icons/chart-types/box-plot.svg", None),
('Candlestick Chart', "icons/chart-types/candlestick-chart.svg",
None),
('Line Chart', "icons/chart-types/line-chart.svg", LineChartModel),
('Pie Chart', "icons/chart-types/pie-chart.svg", None),
('Scatter Chart', "icons/chart-types/scatter-chart.svg", None),
('Spline Chart', "icons/chart-types/spline-chart.svg", None)
]
s = QStandardItemModel()
for ct in chartTypesLst:
item = QStandardItem(ct[0])
item.setIcon(QIcon(ct[1]))
item.setData(ct[2])
s.appendRow(item)
self.typeComboBox.setModel(s)
def setTarget(self, target: SEADTargetInfo):
self.setTitle(target.name)
self.sead_target_infos = target
radar_list_model = QStandardItemModel()
self.radar_list.setSelectionMode(QAbstractItemView.NoSelection)
for r in self.sead_target_infos.radars:
radar_list_model.appendRow(QStandardItem(r.type))
self.radar_list.setModel(radar_list_model)
def testRefCount(self):
model = QStandardItemModel(5, 5)
items = []
for r in range(5):
row = []
for c in range(5):
row.append(QStandardItem("%d,%d" % (r,c)) )
self.assertEqual(sys.getrefcount(row[c]), 2)
model.insertRow(r, row)
for c in range(5):
ref_after = sys.getrefcount(row[c])
# check if the ref count was incremented after insertRow
self.assertEqual(ref_after, 3)
items.append(row)
row = None
for r in range(3):
my_row = model.takeRow(0)
my_row = None
for c in range(5):
# only rest 1 reference
self.assertEqual(sys.getrefcount(items[r][c]), 2)
my_i = model.item(0,0)
# ref(my_i) + parent_ref + items list ref
self.assertEqual(sys.getrefcount(my_i), 4)
model.clear()
# ref(my_i)
self.assertEqual(sys.getrefcount(my_i), 3)
def testLen(self):
model = QStandardItemModel(2, 2)
model.insertRow(0)
model.insertRow(1)
model.insertColumn(0)
model.insertColumn(1)
selection = QItemSelection(model.index(0,0), model.index(1,1))
self.assertEqual(len(selection), 1)
class QStandardItemModelTest(UsesQApplication):
def setUp(self):
super(QStandardItemModelTest, self).setUp()
self.window = QWidget()
self.model = QStandardItemModel(0, 3, self.window)
def tearDown(self):
del self.window
del self.model
super(QStandardItemModelTest, self).tearDown()
def testInsertRow(self):
# bug #227
self.model.insertRow(0)
def testClear(self):
model = QStandardItemModel()
root = model.invisibleRootItem()
model.clear()
self.assertFalse(shiboken.isValid(root))
def testOperators(self):
model = QStandardItemModel()
for i in range(100):
model.appendRow(QStandardItem("Item: %d"%i))
first = model.index(0, 0)
second = model.index(10, 0)
third = model.index(20, 0)
fourth = model.index(30, 0)
sel = QItemSelection(first, second)
sel2 = QItemSelection()
sel2.select(third, fourth)
sel3 = sel + sel2 #check operator +
self.assertEqual(len(sel3), 2)
sel4 = sel
sel4 += sel2 #check operator +=
self.assertEqual(len(sel4), 2)
self.assertEqual(sel4, sel3)
def testClear(self):
model = QStandardItemModel()
root = model.invisibleRootItem()
model.clear()
self.assertFalse(shiboken.isValid(root))
def setUp(self):
super(QStandardItemModelTest, self).setUp()
self.window = QWidget()
self.model = QStandardItemModel(0, 3, self.window)
