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=None):
super().__init__(parent)
self._headers_model = QStandardItemModel()
self._model = QStandardItemModel()
self._calculator_interface = None
self._project_dict = None
self._log = None
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
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 _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 __init__(self):
super(HistorianWidget, self).__init__()
self.existing_responses = set()
self.existing_requests = set()
self.loaded = False
layout = QHBoxLayout()
request_box = QGroupBox('REQUEST HISTORY')
request_box.setAlignment(QtCore.Qt.AlignCenter)
self.export_request_history = QPushButton('Export to CSV')
self.request_history = QTableView()
self.request_rows = QStandardItemModel()
self.request_history.setSortingEnabled(True)
# self.request_history.verticalHeader().hide()
self.request_history.setItemDelegate(CenterDelegate())
# self.request_history.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.request_history.horizontalHeader().setStretchLastSection(True)
self.request_history.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.request_header_labels = [
'Timestamp', 'Transaction ID', 'Unit Address', 'Function Code',
'Data'
]
self.request_rows.setHorizontalHeaderLabels(self.request_header_labels)
req_layout = QVBoxLayout()
req_layout.addWidget(self.request_history)
req_layout.addWidget(self.export_request_history)
request_box.setLayout(req_layout)
response_box = QGroupBox('RESPONSE HISTORY')
response_box.setAlignment(QtCore.Qt.AlignCenter)
self.export_response_history = QPushButton('Export to CSV')
self.response_history = QTableView()
self.response_rows = QStandardItemModel()
self.response_history.setSortingEnabled(True)
# self.response_history.verticalHeader().hide()
self.response_history.setItemDelegate(CenterDelegate())
# self.response_history.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.response_history.horizontalHeader().setStretchLastSection(True)
self.response_history.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.response_header_labels = [
'Timestamp', 'Transaction ID', 'Unit Address', 'Function Code',
'Data'
]
self.response_rows.setHorizontalHeaderLabels(
self.response_header_labels)
res_layout = QVBoxLayout()
res_layout.addWidget(self.response_history)
res_layout.addWidget(self.export_response_history)
response_box.setLayout(res_layout)
layout.addWidget(request_box)
layout.addWidget(response_box)
self.setLayout(layout)
def setupUi(self):
super().setupUi(self)
self.status_consumer = None
self.status_broker_led = Led(self)
self.status_topic_layout.addWidget(self.status_broker_led)
self.status_broker_change_timer = QTimer()
self._set_up_broker_fields(
self.status_broker_led,
self.status_broker_edit,
self.status_broker_change_timer,
self.status_broker_timer_changed,
StatusConsumer,
)
self.command_producer = None
self.command_broker_led = Led(self)
self.command_broker_layout.addWidget(self.command_broker_led)
self.command_broker_change_timer = QTimer()
self._set_up_broker_fields(
self.command_broker_led,
self.command_broker_edit,
self.command_broker_change_timer,
self.command_broker_timer_changed,
CommandProducer,
)
self.command_widget.ok_button.clicked.connect(self.send_command)
self.update_status_timer = QTimer()
self.update_status_timer.timeout.connect(self._check_connection_status)
self.update_status_timer.start(500)
self.files_list.clicked.connect(self.file_list_clicked)
self.stop_file_writing_button.clicked.connect(
self.stop_file_writing_clicked)
self.model = QStandardItemModel(0, 2, self)
self.model.setHeaderData(0, QtCore.Qt.Horizontal, "File writer")
self.model.setHeaderData(1, QtCore.Qt.Horizontal, "Last seen")
self.file_writers_list.setModel(self.model)
self.file_writers_list.setColumnWidth(0, 320)
self.file_list_model = QStandardItemModel(0, 3, self)
self.file_list_model.setHeaderData(0, QtCore.Qt.Horizontal,
"File name")
self.file_list_model.setHeaderData(1, QtCore.Qt.Horizontal,
"Last seen")
self.file_list_model.setHeaderData(2, QtCore.Qt.Horizontal,
"File writer")
self.files_list.setModel(self.file_list_model)
self._restore_settings()
QApplication.instance().aboutToQuit.connect(self._store_settings)
def __init__(self, parent=None):
super().__init__(parent) # 调用父类构造函数，创建窗体
self.__scene = None # 创建QGraphicsScene
self.__view = None # 创建图形视图组件
self.ui = Ui_MainWindow() # 创建UI对象
self.ui.setupUi(self) # 构造UI界面
self.operatorFile = OperatorFile(self)
self.__translator = None
title = self.tr("基于Python的图的绘制及相关概念的可视化展示")
self.setWindowTitle(title)
self.ui.nodeDetails.setEnabled(False)
self.ui.edgeDetails.setEnabled(False)
self.ui.actionSave.setEnabled(False)
self.edgeModel = QStandardItemModel(5, 5, self)
self.edgeSelectionModel = QItemSelectionModel(self.edgeModel)
self.edgeModel.dataChanged.connect(self.do_updateEdgeWeight)
self.nodeModel = QStandardItemModel(5, 4, self)
self.nodeSelectionModel = QItemSelectionModel(self.nodeModel)
self.nodeModel.dataChanged.connect(self.do_updateNodeWeight)
self.spinWeight = WeightSpinDelegate(0, 200, 1, self)
self.ui.tabWidget.setVisible(False)
self.ui.tabWidget.clear()
self.ui.tabWidget.setTabsClosable(True)
self.ui.tabWidget.setDocumentMode(True)
self.setCentralWidget(self.ui.tabWidget)
self.setAutoFillBackground(True)
self.__buildStatusBar() # 构造状态栏
self.__buildUndoCommand() # 初始化撤销重做系统
self.__initModeMenu()
self.__lastColumnFlag = Qt.NoItemFlags
self.iniGraphicsSystem()
self.__ItemId = 0 # 绘图项自定义数据的key
self.__ItemDesc = 1 # 绘图项自定义数据的key
self.__nodeNum = 0 # 结点的序号
self.__edgeNum = 0 # 边的序号
self.__textNum = 0
self.lastColumnFlags = (Qt.ItemIsSelectable | Qt.ItemIsUserCheckable
| Qt.ItemIsEnabled)
self.__graph = Graph()
def __create_vertical_section(self, group_name):
# Setup layout
groupbox = QGroupBox(group_name)
groupbox.setObjectName(group_name)
vertical_layout = QVBoxLayout()
groupbox.setLayout(vertical_layout)
'''
Add widgets
'''
# Add file selection/loading widgets
file_select_organizer = QHBoxLayout()
text_input = QLineEdit() # Does this need a name yet?
file_select_button = QPushButton("...")
file_select_organizer.addWidget(text_input)
file_select_organizer.addWidget(file_select_button)
# Add the section we just made to layout
vertical_layout.addLayout(file_select_organizer)
# add listview for excel pages
excel_label = QLabel("Excel Workbook Pages")
excel_sheets = QListView()
excel_sheets.setEditTriggers(QAbstractItemView.NoEditTriggers)
excel_label_model = QStandardItemModel()
excel_sheets.setModel(excel_label_model)
vertical_layout.addWidget(excel_label)
vertical_layout.addWidget(excel_sheets)
# add listview for column headers
variable_label = QLabel("Merge on column:")
variables = QListView()
variables.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.columns[group_name] = variables
variables_model = QStandardItemModel()
variables.setModel(variables_model)
vertical_layout.addWidget(variable_label)
vertical_layout.addWidget(variables)
'''
Connect Functions
'''
# Connect File dialog to file selection
file_select_button.clicked.connect(lambda: self.openFileNameDialog(text_input, excel_label_model, group_name))
# Connect listview to populate listview for column headers
excel_sheets.clicked.connect(lambda x: self.populateColumns(x, excel_label_model, variables_model, group_name))
return groupbox
def setupUi(self, variableSelection):
variableSelection.setObjectName("variableSelection")
variableSelection.resize(409, 300)
self.buttonBox = QtWidgets.QDialogButtonBox(variableSelection)
self.buttonBox.setGeometry(QtCore.QRect(230, 260, 171, 32))
self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
self.buttonBox.setStandardButtons(QtWidgets.QDialogButtonBox.Cancel
| QtWidgets.QDialogButtonBox.Ok)
self.buttonBox.setObjectName("buttonBox")
self.list_left = QtWidgets.QListView(variableSelection)
self.list_left.setGeometry(QtCore.QRect(30, 60, 141, 191))
self.list_left.setObjectName("listView")
self.verticalScrollBar = QtWidgets.QScrollBar(variableSelection)
self.verticalScrollBar.setGeometry(QtCore.QRect(150, 70, 20, 171))
self.verticalScrollBar.setOrientation(QtCore.Qt.Vertical)
self.verticalScrollBar.setObjectName("verticalScrollBar")
self.verticalScrollBar_2 = QtWidgets.QScrollBar(variableSelection)
self.verticalScrollBar_2.setGeometry(QtCore.QRect(350, 70, 21, 171))
self.verticalScrollBar_2.setOrientation(QtCore.Qt.Vertical)
self.verticalScrollBar_2.setObjectName("verticalScrollBar_2")
self.toolButton = QtWidgets.QToolButton(variableSelection)
self.toolButton.setGeometry(QtCore.QRect(190, 100, 41, 31))
self.toolButton.setAutoRaise(False)
self.toolButton.setArrowType(QtCore.Qt.RightArrow)
self.toolButton.setObjectName("addButton")
self.toolButton_2 = QtWidgets.QToolButton(variableSelection)
self.toolButton_2.setGeometry(QtCore.QRect(190, 180, 41, 31))
self.toolButton_2.setArrowType(QtCore.Qt.LeftArrow)
self.toolButton_2.setObjectName("removeButton")
self.list_right = QtWidgets.QListView(variableSelection)
self.list_right.setGeometry(QtCore.QRect(240, 60, 141, 191))
self.list_right.setObjectName("listView_2")
self.label = QtWidgets.QLabel(variableSelection)
self.label.setGeometry(QtCore.QRect(40, 20, 361, 20))
self.label.setStyleSheet("font: 8pt \"MS Shell Dlg 2\";")
self.label.setObjectName("label")
self.retranslateUi(variableSelection)
QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL("accepted()"),
variableSelection.accept)
QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL("rejected()"),
variableSelection.reject)
QtCore.QMetaObject.connectSlotsByName(variableSelection)
self.model_left = QStandardItemModel(self)
self.list_left.setModel(self.model_left)
self.model_right = QStandardItemModel(self)
self.list_right.setModel(self.model_right)
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):
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 create_results_model(self, results):
def add_result_row(row_model, value, obj_class, uuid):
row_model.insertRow(0)
row_model.setData(model.index(0, 0), value)
row_model.setData(model.index(0, 1), obj_class)
row_model.setData(model.index(0, 2), uuid)
item_0 = model.itemFromIndex(model.index(0, 0))
item_0.setCheckState(Qt.Unchecked)
item_0.setFlags(item_0.flags() | Qt.ItemIsUserCheckable)
item_0.setEditable(False)
item_1 = model.itemFromIndex(model.index(0, 1))
item_1.setEditable(False)
model = QStandardItemModel(0, 3, self)
model.setHeaderData(0, Qt.Horizontal, "Value")
model.setHeaderData(1, Qt.Horizontal, "Class")
model.setHeaderData(2, Qt.Horizontal, "UUID")
for hit in results:
add_result_row(model, hit['value'], hit['obj_class_display'],
hit['uuid'])
return model
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 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)
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, *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 set_data(self, object_icons, object_class_names, object_names,
object_names_dict):
for i, object_class_name in enumerate(object_class_names):
combo = QComboBox(self)
model = QStandardItemModel()
icon = object_icons[i]
qitem = QStandardItem(icon, object_class_name)
qitem.setFlags(~Qt.ItemIsSelectable)
model.appendRow(qitem)
all_object_names = object_names_dict[object_class_name]
for object_name in all_object_names:
qitem = QStandardItem(object_name)
model.appendRow(qitem)
combo.setModel(model)
combo.insertSeparator(1)
combo.activated.connect(
lambda index, i=i: self.remove_missing_dimension(i))
self.layout().addWidget(combo)
self.combos.append(combo)
try:
object_name = object_names[i]
except IndexError:
self.missing_dimensions.add(i)
continue
if object_name:
combo.setCurrentText(object_name)
else:
self.missing_dimensions.add(i)
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, 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):
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 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
def setTarget(self, target):
self.setTitle(target.name)
self.strike_target_infos = target
model = QStandardItemModel()
self.listView.setSelectionMode(QAbstractItemView.NoSelection)
if len(self.strike_target_infos.units) > 0:
dic = {}
for u in self.strike_target_infos.units:
if u.type in dic.keys():
dic[u.type] = dic[u.type] + 1
else:
dic[u.type] = 1
for k, v in dic.items():
model.appendRow(QStandardItem(k + " x " + str(v)))
print(k + " x " + str(v))
else:
dic = {}
for b in self.strike_target_infos.buildings:
id = b.dcs_identifier
if b.is_dead:
id = id + "[Destroyed]"
if id in dic.keys():
dic[id] = dic[id] + 1
else:
dic[id] = 1
for k, v in dic.items():
model.appendRow(QStandardItem(k + " x " + str(v)))
print(k + " x " + str(v))
self.listView.setModel(model)
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 createMailModel(parent):
model = QStandardItemModel(0, 3, parent)
model.setHeaderData(SUBJECT, Qt.Horizontal, "Subject")
model.setHeaderData(SENDER, Qt.Horizontal, "Sender")
model.setHeaderData(DATE, Qt.Horizontal, "Date")
addMail(model, "Happy New Year!", "Grace K. <*****@*****.**>",
QDateTime(QDate(2006, 12, 31), QTime(17, 3)))
addMail(model, "Radically new concept",
"Grace K. <*****@*****.**>",
QDateTime(QDate(2006, 12, 22), QTime(9, 44)))
addMail(model, "Accounts", "*****@*****.**",
QDateTime(QDate(2006, 12, 31), QTime(12, 50)))
addMail(model, "Expenses", "Joe Bloggs <*****@*****.**>",
QDateTime(QDate(2006, 12, 25), QTime(11, 39)))
addMail(model, "Re: Expenses", "Andy <*****@*****.**>",
QDateTime(QDate(2007, 1, 2), QTime(16, 5)))
addMail(model, "Re: Accounts", "Joe Bloggs <*****@*****.**>",
QDateTime(QDate(2007, 1, 3), QTime(14, 18)))
addMail(model, "Re: Accounts", "Andy <*****@*****.**>",
QDateTime(QDate(2007, 1, 3), QTime(14, 26)))
addMail(model, "Sports", "Linda Smith <*****@*****.**>",
QDateTime(QDate(2007, 1, 5), QTime(11, 33)))
addMail(model, "AW: Sports", "Rolf Newschweinstein <*****@*****.**>",
QDateTime(QDate(2007, 1, 5), QTime(12, 0)))
addMail(model, "RE: Sports", "Petra Schmidt <*****@*****.**>",
QDateTime(QDate(2007, 1, 5), QTime(12, 1)))
return 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 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, 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 __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 __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()
