def __init__(self, *args, **kwargs):
QWidget.__init__(self, *args, **kwargs)
self.setLayout(QVBoxLayout())
tv1 = QTableView(self)
tv2 = QTableView(self)
model = QStandardItemModel(8, 4, self)
proxy = SortFilterProxyModel(self)
proxy.setSourceModel(model)
tv1.setModel(model)
tv2.setModel(proxy)
self.layout().addWidget(tv1)
self.layout().addWidget(tv2)
for i in range(model.rowCount()):
for j in range(model.columnCount()):
item = QStandardItem()
item.setData(random_word(), Qt.DisplayRole)
model.setItem(i, j, item)
flayout = QFormLayout()
self.layout().addLayout(flayout)
for i in range(model.columnCount()):
le = QLineEdit(self)
flayout.addRow("column: {}".format(i), le)
le.textChanged.connect(lambda text, col=i: proxy.setFilterByColumn(
QRegExp(text, Qt.CaseSensitive, QRegExp.FixedString), col))
def update_task_list_view(self):
self.model.clear()
current_date_tasks = list(
filter(
lambda task: task.start_at.date() <= self.date_now and task.
end_at.date() >= self.date_now, self.active_task_list))
self.busy = len(current_date_tasks)
for task in current_date_tasks:
topic = task.topic
item = QStandardItem(topic)
item.setData(task)
item.setCheckable(True)
item.setData(task)
item.setEditable(False)
self.model.appendRow(item)
if len(current_date_tasks) == 0:
self.graphic.setText("")
self.graphic.setPixmap(QtGui.QPixmap("../Assets/no_task.png"))
self.graphic.setScaledContents(True)
self.graphic.setGeometry(QtCore.QRect(260, 195, 252, 211))
self.label_notask.setGeometry(QtCore.QRect(280, 395, 221, 51))
font = QtGui.QFont()
font.setFamily("Roboto Light")
font.setPointSize(20)
self.label_notask.setFont(font)
self.label_notask.setText("You are free on this day !")
else:
self.graphic.clear()
self.label_notask.clear()
def load(self, filename: str):
model = self.model()
model.removeRows(0, model.rowCount())
for name, file_count in get_file_tags(filename):
model.appendRow(
[QStandardItem(name),
QStandardItem(str(file_count))])
def make_words_list(filter_id, rows):
"""
make words list for filters,
if find word in list assigned name of category
:param filter_id:
:param rows:
:return:
"""
session = Session()
filter_ = session.query(FilterF).get(filter_id)
ready_valus = []
for row in rows:
flag = False
row = [i.lower() for i in row]
row = ' '.join(row)
for category in filter_.categorys:
words = [b.lower() for b in category.words]
for word in words:
if word in row:
item = QStandardItem(str(category.name))
ready_valus.append(item)
flag = True
break
if flag is False:
item = QStandardItem('')
ready_valus.append(item)
session.close()
return ready_valus
def run(self):
rows = connect_to_base_and_execute(
self.table_query.format(self.ru_entry.text().strip(),
self.cur_entry.text().strip(),
int(self.balance_entry.text().strip())),
self.error_label, self.user_entry.text(),
keyring.get_password(getpass.getuser(),
self.user_entry.text()), self.ok_button, "''")
self.standart_item_model.clear()
self.table.clearSpans()
item_list = []
if rows:
#print("rows", rows)
for values in rows:
item_list = []
for value in values:
if type(value) == int:
item = QStandardItem(str(value))
else:
item = QStandardItem(value)
item_list.append(item)
self.standart_item_model.appendRow(item_list)
self.standart_item_model.setHorizontalHeaderLabels(
["Счет", "РУ", "Валюта", "Остаток"])
self.table.setModel(self.standart_item_model)
self.table.setColumnWidth(0, 150)
self.table.setColumnWidth(1, 60)
self.table.setColumnWidth(2, 80)
self.table.setColumnWidth(3, 150)
if self.standart_item_model.rowCount() > 0:
frequency = 2500
duration = 2000
winsound.Beep(frequency, duration)
def __get_next(self, element_info, parent):
for child in element_info.children():
self.__generate_props_dict(child)
child_item = QStandardItem(self.__node_name(child))
child_item.setEditable(False)
parent.appendRow(child_item)
self.__get_next(child, child_item)
def LoadTable(self):
'''
Loads the history as the list
'''
try:
# Clear the table rows
self.taskViewModel.clear()
# loads the log data
self.log_data = self.logManager.LoadLogs(self._task.Guid)
# prepare timestamp & msg
for task in self.log_data:
self.taskViewModel.appendRow([
QStandardItem(task['timeStamp']),
QStandardItem(task['message'])])
# set the column header
self.taskViewModel.setHorizontalHeaderLabels(
Settings.HIST_TABLE_COLUMNS)
# set the width of columns
self.ui.tableView.setColumnWidth(0, 200)
# set last column as stretchable
self.ui.tableView.horizontalHeader().setSectionResizeMode(
1, QHeaderView.Stretch)
# set text align as left
self.ui.tableView.horizontalHeader().setDefaultAlignment(
Qt.AlignLeft)
except Exception as e:
print(f'HistryDlg/LoadTable Err:{e}')
def UpdateListItem(self, task):
'''
Updates the current selected item on TableView
Parameters:
-----------
task: MirrorTask
currently selected task
'''
try:
# if selected task is None, return
if task is None:
return
# Checks if the selected task exist on task list
index = -1
for i in range(len(self.TaskList)):
# compare GUIDs
if self.TaskList[i].Guid == task.Guid:
index = i
break
# if not EXIST, return
if index < 0:
return
# updates the Task Manager
self.TaskList[i] = self.SelectedTask
# Rewrites the TableView item
self.taskViewModel.setItem(index, 0, QStandardItem(task.Source))
self.taskViewModel.setItem(index, 1, QStandardItem(task.Target))
_str = Settings.Schedule_String if task.Scheduled else Settings.UnScheduled_String # noqa
self.taskViewModel.setItem(index, 2, QStandardItem(_str))
self.taskViewModel.setItem(index, 3,
QStandardItem(task.LastOperation))
except Exception as e:
print(f"UpdateListItem Error:{e}")
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, name, rowid, idx):
QStandardItem.__init__(self)
self.itemType = 'BOARD'
self.name = decodeFromDB(name)
self.rowid = int(rowid)
self.setText(f'#{rowid} {name}')
self.idx = int(idx)
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 make_filter_list(filter_id, rows):
"""
make list with assigned value
:param filter_id:
:param rows:
:return:
"""
session = Session()
filter_ = session.query(FilterF).get(filter_id)
ready_valus = []
for row in rows:
flag = False
row = [i.strip().lower() for i in row]
for category in filter_.categorys:
items = [[b.strip().lower() for b in a]
for a in category.items]
if row in items:
#make QStandardItem to make column in sti model
item = QStandardItem(str(category.name))
ready_valus.append(item)
flag = True
if flag is False:
item = QStandardItem('')
ready_valus.append(item)
session.close()
return ready_valus
def add_init_data(self, data, data_length=3):
'''添加数据到 table_view
@参数说明:
data ：要显示的数据
data_length : 设置单元格的宽度
@返回值:
无
@注意:
无
'''
self._data = data
# 设计单元格宽度
if (data_length == 2):
self.table_view.horizontalHeader().setDefaultSectionSize(50)
else:
self.table_view.horizontalHeader().setDefaultSectionSize(120)
for i in range(self.table_col):
for j in range(self.table_row):
temp_date = QStandardItem(str(self._data[i, j]))
# 设置单元格居中
temp_date.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self.item_model.setItem(i, j, temp_date) # 在单元格中添加数据
def __init__(self, name, rowid, idx):
QStandardItem.__init__(self)
self.itemType = 'LIST'
self.name = name
self.rowid = int(rowid)
self.setText(f'#{rowid} {name}')
self.idx = int(idx)
def add_preview_item(self, path, metadata):
root = self.window.root_input.text()
metadata = metadata.rewrite(self.rewrite_rules, root=root)
metadata.add_tags(self.extra_tags)
item1 = QStandardItem(metadata.name)
item2 = QStandardItem(", ".join(metadata.get_tags()))
item3 = QStandardItem(str(path))
self.preview_model.appendRow([item1, item2, item3])
def add_resources(self, resource_db_maps):
for resource, db_map in resource_db_maps.items():
if db_map in self._root_items:
continue
self._root_items[db_map] = root_item = QStandardItem(resource.label)
filter_items = [QStandardItem("Scenario filter"), QStandardItem("Tool filter")]
root_item.appendRows(filter_items)
self.appendRow(root_item)
def _update_check_state(self, item: QStandardItem):
capabilities: ExportCapabilities = item.data(_CAPABILITIES_ROLE)
if capabilities.is_selectable():
new_state = item.checkState()
self.blockSignals(True)
for i in range(0, item.rowCount()):
self._recursive_update_check_state(item.child(i), new_state)
self.blockSignals(False)
def load_translations(self):
self._languages_model.clear()
item = QStandardItem("Default")
self._languages_model.appendRow(item)
trans_dir = QDir(os.fspath(TRANSLATIONS_DIR))
for filename in trans_dir.entryList(["*.qm"], QDir.Files, QDir.Name):
language = re.search(r"i18n_(.*?)\.qm", filename).group(1)
item = QStandardItem(language)
self._languages_model.appendRow(item)
def populate(self):
for idx, folder in enumerate(self.getImageFolders()):
item = QStandardItem(folder)
item.setData(folder.replace('imgur', '').replace('reddit_sub', '').replace('_', ''), role=Qt.DisplayRole)
item.setData(folder, 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 update_pipeline_view(self):
logging.debug(self.pipeline)
model = self.pipelineView.model()
model.clear()
for t in range(self.pipeline.rowCount()):
item = QStandardItem()
item.setText(repr(self.pipeline.data(t)))
model.appendRow(item)
def __updateNodeView(self):
nodes = self.singleItems(BezierNode)
if len(nodes):
self.ui.nodeDetails.setEnabled(True)
else:
return
nodeColCount = 4
self.nodeModel.clear()
nodeHeaderList = [
self._tr("MainWindow", 'ID'),
self._tr("MainWindow", '边数'),
self._tr("MainWindow", '坐标'),
self._tr("MainWindow", '权重')
]
if self.ui.actionDigraph_Mode.isChecked():
nodeHeaderList.append(self._tr("MainWindow", '出度'))
nodeHeaderList.append(self._tr("MainWindow", '入度'))
nodeColCount += 2
else:
nodeHeaderList.append(self._tr("MainWindow", "度"))
nodeColCount += 1
self.nodeModel.setHorizontalHeaderLabels(nodeHeaderList)
self.nodeModel.setRowCount(len(nodes))
self.nodeSelectionModel.currentChanged.connect(self.do_curNodeChanged)
self.ui.nodeDetails.setModel(self.nodeModel)
self.ui.nodeDetails.setSelectionModel(self.nodeSelectionModel)
self.ui.nodeDetails.verticalHeader().setSectionResizeMode(
QHeaderView.Fixed)
self.ui.nodeDetails.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.ui.nodeDetails.setAlternatingRowColors(True)
self.ui.nodeDetails.setItemDelegateForColumn(3, self.spinWeight)
nodes.reverse()
for i in range(len(nodes)):
node: BezierNode = nodes[i]
strList = [
f"V{node.data(self.__ItemId)}",
str(len(node.bezierEdges)),
f"x:{node.pos().x()},y:{node.pos().y()}",
str(node.weight())
]
if self.ui.actionDigraph_Mode.isChecked():
strList.append(
f'{node.degrees(self.ui.actionDigraph_Mode.isChecked())[1]}'
)
strList.append(
f'{node.degrees(self.ui.actionDigraph_Mode.isChecked())[0]}'
)
else:
strList.append(
f'{node.degrees(self.ui.actionDigraph_Mode.isChecked())}')
for j in range(nodeColCount):
item = QStandardItem(strList[j])
if j != 3:
item.setFlags(self.__lastColumnFlag)
self.nodeModel.setItem(i, j, item)
def __init__(self, widgetModel, parent=None):
super(FilesViewModel, self).__init__(parent)
self.setHorizontalHeaderItem(0, QStandardItem(self.NAME))
self.setHorizontalHeaderItem(1, QStandardItem(self.DATE_MODIFIED))
self.setHorizontalHeaderItem(2, QStandardItem(self.SIZE))
self.setHorizontalHeaderItem(3, QStandardItem(self.TYPE))
self._widgetModel = widgetModel
self.populateList()
def set_metadata(self, metadata):
self.metadata = metadata
if metadata:
self.model.setRowCount(len(self.metadata))
for i, key in enumerate(sorted(metadata)):
fmt_key, fmt_value = metadata.get_formatted(key)
self.model.setItem(i, 0, QStandardItem(fmt_key))
self.model.setItem(i, 1, QStandardItem(fmt_value))
else:
self.model.setRowCount(0)
def OpenImages(self):
self.cacheDir = ''
fileList = QFileDialog.getOpenFileNames(self, "Load Files", '../')
self.model = QStandardItemModel()
for name in fileList[0]:
item = QStandardItem(os.path.basename(name)) #QIcon(name),
item.setData(name)
item2 = QStandardItem('NULL')
self.model.appendRow([item, item2])
self.ui.tableView.setModel(self.model)
def _on_uncheck(self, item: QStandardItem):
"""
Handles unchecking an item.
Args:
item: Item unchecked
"""
item.setCheckState(Qt.Unchecked)
assert item.text() in self.checked_items
self.checked_items.remove(item.text())
def _on_check(self, item: QStandardItem):
"""
Handles checking an item.
Args:
item: Item checked
"""
item.setCheckState(Qt.Checked)
assert item.text() not in self.checked_items
self.checked_items.append(item.text())
def __init__(self, metadata_view):
QObject.__init__(self)
self.view = metadata_view
self.metadata = None
self.model = QStandardItemModel(1, 2)
self.model.setHorizontalHeaderItem(0, QStandardItem("Key"))
self.model.setHorizontalHeaderItem(1, QStandardItem("Value"))
self.view.setModel(self.model)
self.view.sortByColumn(0, Qt.AscendingOrder)
self.view.setSortingEnabled(False)
def _add_morpheme(self, tree: QtGui.QStandardItem, morpheme: Morpheme):
text_item = MorphemeTextItem(morpheme)
gloss_item = MorphemeGlossItem(morpheme)
self.morpheme_text_items.update({morpheme.dict_id: text_item})
self.morpheme_gloss_items.update({morpheme.dict_id: gloss_item})
tree.appendRow([
text_item,
gloss_item,
RemoveButton(morpheme),
])
def populate_outputfiles_list(self, items):
"""List output files in QTreeView.
If items is None or empty list, model is cleared.
"""
self.outputfiles_model.clear()
self.outputfiles_model.setHorizontalHeaderItem(0, QStandardItem("Output files")) # Add header
if items is not None:
for item in items:
qitem = QStandardItem(item)
qitem.setData(QFileIconProvider().icon(QFileInfo(item)), Qt.DecorationRole)
self.outputfiles_model.appendRow(qitem)
def _update_file_picker_list(self, file_names):
model = self.file_list.model()
# Update File Picker list from files[]
model.clear()
for f in range(self.file_sequence.rowCount()):
item = QStandardItem()
item.setText(file_names[f])
model.appendRow(item)
self.log_file_sequence_status()
