def create_table(self):
h_headers = [sec.__class__.__name__ for sec in self.sections]
v_headers = [self.check_header] + self.phys_proc_names
self.ui.tableWidget.setColumnCount(len(h_headers))
self.ui.tableWidget.setRowCount(len(v_headers))
self.ui.tableWidget.setHorizontalHeaderLabels(h_headers)
self.ui.tableWidget.setVerticalHeaderLabels(v_headers)
#self.ui.tableWidget.setItem(row, 0, QTableWidgetItem(r_name))
for col, sec in enumerate(self.sections):
for row, r_name in enumerate(v_headers):
checkBoxItem = QTableWidgetItem()
checkBoxItem.setCheckState(QtCore.Qt.Checked)
#flags = checkBoxItem.flags()
#QtGui.QTableWidgetItem(str(pv))
checkBoxItem.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled
| QtCore.Qt.ItemIsUserCheckable)
self.ui.tableWidget.setItem(row, col, checkBoxItem)
if row == 0:
#self.ui.tableWidget.item(row, col + 1).setBackground(QtCore.Qt.red)
checkBoxItem.setBackground(QtGui.QColor(100, 100, 150))
sec_ui = SectionUI()
sec_ui.col = col
sec_ui.v_headers = v_headers
sec_ui.tableWidget = self.ui.tableWidget
sec.ui = sec_ui
#self.ui.tableWidget.horizontalHeader().setStretchLastSection(True)
self.ui.tableWidget.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
def init_table(self, devs, dev_param="k1", device_iface=None, calc_obj=None, spin_params=[-5000, 5000, 5], check_box=False):
"""
Initialize the UI table object
:param devs:
:param device_iface:
:param calc_obj:
:param spin_params:
:param check_box:
:return:
"""
self.calc_obj = calc_obj
h_headers = ["ID", "ref.val.", "cur.val."]
if check_box:
h_headers += "status"
self.ui.tableWidget.setColumnCount(len(h_headers))
self.ui.tableWidget.setHorizontalHeaderLabels(h_headers)
self.spin_boxes = []
self.ui.tableWidget.setRowCount(0)
for row, dev in enumerate(devs):
#print(dev)
eng = QtCore.QLocale(QtCore.QLocale.English, QtCore.QLocale.UnitedStates)
self.ui.tableWidget.setRowCount(row + 1)
pv = dev.id
# put PV in the table
self.ui.tableWidget.setItem(row, 0, QTableWidgetItem(str(pv)))
# put start val in
if dev_param not in dev.__dict__.keys():
print("Parameter ", dev_param, " is not in the device!")
continue
val = np.round(dev.__dict__[dev_param], 4)
self.ui.tableWidget.setItem(row, 1, QTableWidgetItem(str(val)))
spin_box = self.create_spin_box(spin_params=spin_params)
spin_box.setValue(dev.__dict__[dev_param])
if calc_obj != None:
spin_box.valueChanged.connect(calc_obj)
self.ui.tableWidget.setCellWidget(row, 2, spin_box)
self.spin_boxes.append(spin_box)
if check_box:
checkBoxItem = QTableWidgetItem()
# checkBoxItem.setBackgroundColor(QtGui.QColor(100,100,150))
checkBoxItem.setCheckState(QtCore.Qt.Checked)
flags = checkBoxItem.flags()
# print("FLAG", flags)
# flags != flags
checkBoxItem.setFlags(flags)
self.ui.tableWidget.setItem(row, 3, checkBoxItem)
dev.row = row
if device_iface != None:
ui = device_iface()
ui.tableWidget = self.ui.tableWidget
ui.row = row
ui.col = 2
dev.ui = ui
def __init__(self, main_window):
QMainWindow.__init__(self)
self.main_window = main_window
# Настройка окна
self.setMinimumSize(QSize(480, 80))
self.setWindowTitle("Выбрать графики для фильтрации")
self.central_widget = QWidget(self) # Создаём центральный виджет
self.setCentralWidget(self.central_widget)
self.table = QTableWidget(self) # Пустая таблица
self.table.setColumnCount(2)
self.table.setRowCount(len(self.main_window.y))
self.table.setHorizontalHeaderLabels(['Название', ''])
for i in range(len(self.main_window.y)):
self.table.setItem(i, 0,
QTableWidgetItem(str(self.main_window.y[i])))
item = QTableWidgetItem()
item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
item.setCheckState(Qt.Unchecked)
self.table.setItem(i, 1, item)
# Кнопки
filter_btn = QPushButton("Фильтровать", self)
filter_btn.clicked.connect(self.filter_data)
vertical_layout = QVBoxLayout() # Вертикальная расстановка
vertical_layout.addWidget(self.table)
vertical_layout.addWidget(filter_btn)
self.central_widget.setLayout(vertical_layout)
def table_loader(qtable):
"""
Responsible for loading data into the QTableWidget
:param qtable: QTableWidget
:return: None
"""
try:
qtable.setColumnCount(3)
qtable.setRowCount(5)
for row in range(0, 5):
for col in range(0, 2):
stringitem = QTableWidgetItem()
stringitem.setText("Test r: " + str(row) + " c: " + str(col))
qtable.setItem(row, col, stringitem)
chkboxitem = QTableWidgetItem()
chkboxitem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
chkboxitem.setCheckState(Qt.Checked)
qtable.setItem(row, 2, chkboxitem)
except Exception as ex:
print_exception(ex)
def _set_module_auth_options_items(self,
row,
checked,
expire_date,
f_color,
b_color=None):
""" 设置模块管理的操作项目(选择开启或关闭,设置到期时间等) """
text = "开放" if checked else "关闭"
item2 = QTableWidgetItem(text)
item2.setCheckState(checked)
item2.setTextAlignment(Qt.AlignCenter)
item2.setBackground(
QBrush(b_color)) if b_color else item2.setForeground(
QBrush(f_color))
self.module_auth.module_auth_table.setItem(row, 2, item2)
item3 = QTableWidgetItem(expire_date)
item3.setBackground(
QBrush(b_color)) if b_color else item3.setForeground(
QBrush(f_color))
item3.setTextAlignment(Qt.AlignCenter)
self.module_auth.module_auth_table.setItem(row, 3, item3)
item4_widget = QPushButton("确定", self.module_auth.module_auth_table)
item4_widget.clicked.connect(self.edit_user_module_authority)
setattr(item4_widget, "row_index", row)
self.module_auth.module_auth_table.setCellWidget(row, 4, item4_widget)
def __init__(self, mainwindow):
super().__init__(mainwindow=mainwindow)
self.bd = BdController()
self.preparator = DataPreparator()
self.neurocreator = NeuroWebCreator()
if self.bd.data_exists():
market, trends = self.bd.read_data()
opts, num = self.preparator.forTrainWindow(market, trends)
self.bd.save_options(opts, num)
self.tableOptions.setColumnCount(1)
self.tableOptions.setRowCount(len(opts))
self.tableOptions.setHorizontalHeaderLabels(['Options'])
self.tableOptions.setColumnWidth(0, 500)
for i in range(len(opts)):
for j in range(1):
chkBoxItem = QTableWidgetItem()
chkBoxItem.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled)
chkBoxItem.setCheckState(QtCore.Qt.Unchecked)
chkBoxItem.setText(opts[i])
self.tableOptions.setItem(i, j, chkBoxItem)
self.tableOptions.itemClicked.connect(self.handleItemClicked)
self.listChecked = []
self.mistake.setMaximum(100)
self.mistake.setValue(2.5)
self.spinBox.setMaximum(300)
self.spinBox.setValue(300)
self.fastButton.clicked.connect(self.fast)
self.doubleButton.clicked.connect(self.double)
self.deepButton.clicked.connect(self.deep)
self.fullButton.clicked.connect(self.full)
def setData(self, widget, data, diagram, checkboxes = False):
widget.clearContents()
widget.setRowCount(len(data))
for row, item in enumerate(data):
columnMap = {0:'', #checkbox placeholder
1:'transitionTime',
2:'operation',
3:'stationId',
5:'trainDeparture'}
for key in list(columnMap.keys())[1:]:
columnMap[key] = item['conn'].attrib[columnMap[key]]
columnMap[4] = item['row'][1]
columnMap[6] = item['row'][3]
columnMap[7] = item['row'][4]
if diagram.hasExcelRows:
columnMap[8] = item['excelRow']['highlight_regions'][0]['cellRange']
for key in columnMap.keys():
newitem = QTableWidgetItem(columnMap[key])
if key == 0 and checkboxes:
newitem.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsEditable | QtCore.Qt.ItemIsSelectable)
newitem.setCheckState(QtCore.Qt.Checked)
if key not in [0,1,2]:
newitem.setFlags(newitem.flags() ^ QtCore.Qt.ItemIsEditable)
widget.setItem(row, key, newitem)
def show_table(self, data):
self.qualified_case = data
self.tableWidget.clear()
row = len(data)
col = int(self.lineEdit_18.text()) + 6
self.tableWidget.setRowCount(row) # 设置行数
self.tableWidget.setColumnCount(col + 1) # 设置列数
self.y_header_1 = [
'使用', '一阶扭转', '尾门框扭转', '一阶弯曲', '前舱横摆', '扭转刚度', '弯曲刚度'
]
self.y_header_2 = ['con_' + str(i + 1) for i in range(col - 6)]
self.y_header = self.y_header_1 + self.y_header_2
self.tableWidget.setHorizontalHeaderLabels(self.y_header) # 设置表头内容
self.tableWidget.verticalHeader().setVisible(True) # 显示垂直表头
self.tableWidget.horizontalHeader().setVisible(True) # 显示水平表头
self.tableWidget.setColumnWidth(0, 30) # 设置第0列宽度30
# 添加复选框
for k in range(row):
item_checked = QTableWidgetItem() # 复选框
item_checked.setCheckState(QtCore.Qt.Unchecked) # 如果使用这句就表示复选框是未选的
self.tableWidget.setItem(k, 0, item_checked)
# 添加数据
i = 0 # 第几行（从0开始）
j = 1 # 第几列（从0开始）
for case in data:
for item in case:
self.tableWidget.setItem(i, j, QTableWidgetItem(
str(item))) # 设置j行i列的内容为item
j += 1
i += 1
j = 1
def setup_tmc_preview_table(self):
if self.tmc_preview is not None:
self.tmc_table_init = True
num_rows = len(self.tmc_preview)
num_cols = len(self.tmc_preview.columns)
self.tmc_table.setRowCount(num_rows)
self.tmc_table.setColumnCount(num_cols)
# Creating column headers
self.tmc_table.setHorizontalHeaderItem(0,
QTableWidgetItem('Include'))
col_count = 1
for col_header in self.tmc_preview.columns:
self.tmc_table.setHorizontalHeaderItem(
col_count, QTableWidgetItem(col_header))
col_count += 1
# Adding data preview rows
for index, row in self.tmc_preview.iterrows():
check_item = QTableWidgetItem('')
check_item.setFlags(check_item.flags()
| Qt.ItemIsUserCheckable)
check_item.setCheckState(Qt.Checked)
check_item.setTextAlignment(Qt.AlignCenter)
self.tmc_table.setItem(index, 0, check_item)
for col_idx in range(num_cols):
item = QTableWidgetItem(str(row[col_idx]))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.tmc_table.setItem(index, col_idx + 1, item)
self.tmc_table_init = False
self.tmc_table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tmc_table.cellChanged.connect(self.handle_cell_changed)
self.tmc_table.resizeColumnsToContents()
def addrows(self, row):
#print('---------',row)'http://v9-tt.ixigua.com/53
row['rowid'] = self.rowid #此记录的唯一标识
self.rowsinfo.append(row)
colno = 1
rowsno = self.table_videos.rowCount()
self.table_videos.setRowCount(rowsno + 1)
try:
# check_widget = QtWidgets.QCheckBox()
# self.table_videos.setCellWidget(rowsno,0,check_widget)
checkItem = QTableWidgetItem()
checkItem.setCheckState(Qt.Unchecked)
#checkItem.setFlags(Qt.ItemIsEditable)
self.table_videos.setItem(rowsno, 0, checkItem)
except Exception as e:
print(e)
try:
source = row['source']
title = row['title']
url = row['video_url']
count = row['video_play_count']
rowid = row['rowid']
check = ' '
heads = [source, '未下载', title, count, url, rowid]
print(heads)
for head in heads:
item = QTableWidgetItem(str(head))
if colno != 3:
item.setFlags(Qt.ItemIsEditable)
self.table_videos.setItem(rowsno, colno, item)
colno += 1
self.rowid += 1
except Exception as e:
print(e)
def table_show_content(self, contents):
self.manger_table.cellChanged.disconnect()
self.manger_table.clear()
table_headers = ['品种', '代码', '是否交割']
self.manger_table.setColumnCount(len(table_headers))
self.manger_table.setRowCount(len(contents))
self.manger_table.setHorizontalHeaderLabels(table_headers)
self.manger_table.horizontalHeader().setSectionResizeMode(2, QHeaderView.ResizeToContents)
for row, row_item in enumerate(contents):
item0 = QTableWidgetItem(row_item['variety_name'])
item0.id = row_item['id']
item0.setTextAlignment(Qt.AlignCenter)
self.manger_table.setItem(row, 0, item0)
item1 = QTableWidgetItem(row_item['variety_en'])
if row_item['is_delivery']:
item2 = QTableWidgetItem('有交割')
item2.setCheckState(Qt.Checked)
else:
item2 = QTableWidgetItem('无交割')
item2.setCheckState(Qt.Unchecked)
item1.setTextAlignment(Qt.AlignCenter)
item2.setTextAlignment(Qt.AlignCenter)
self.manger_table.setItem(row, 1, item1)
self.manger_table.setItem(row, 2, item2)
self.manger_table.cellChanged.connect(self.manager_table_checked_changed)
def setValue(self, value):
self._updating = True
self.resizeColumnsToContents()
self.setMinimumSize(self.viewportSizeHint())
self.setRowCount(0)
if value is None:
value = set()
else:
# Don't mutate the original value.
value = set(value)
self._value = value
row = -1
for choice in sorted(self._reversed_choices):
row += 1
self.insertRow(row)
item = QTableWidgetItem(self._choices[choice])
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.setItem(row, 0, item)
item = QTableWidgetItem()
item.setFlags((item.flags() & ~Qt.ItemIsEditable)
| Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked if choice in value else Qt.Unchecked)
self.setItem(row, 1, item)
self.resizeColumnsToContents()
self.setMinimumSize(self.viewportSizeHint())
self._updating = False
def update_accounts(self):
_accounts = {a.order: (a, thread) for a, thread in self.accounts_thread.get_accounts().items()}
_mapping = {order_orig: order_new for order_new, order_orig in zip(range(len(_accounts)), _accounts.keys())}
self.accounts = {_mapping[order]: t for order, t in _accounts.items()}
self.accounts_table.setRowCount(len(self.accounts))
for index, (database_account, account_thread) in self.accounts.items():
self.accounts_table.setRowHeight(index, Constants.TABLE_ROW_HEIGHT)
account = account_thread.account
player_object = account.data.player_object
base = account.data.Base
select = QTableWidgetItem()
select.setFlags(
QtCore.Qt.ItemIsEditable | QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsUserCheckable)
select.setCheckState(QtCore.Qt.Unchecked)
select.account_thread = account_thread
self.accounts_table.setItem(index, 0, select)
self.accounts_table.setItem(index, 1, text_to_widget(account.email, center=True))
self.accounts_table.setItem(index, 2, text_to_widget(account.world_info['name'], center=True))
if account_thread.is_data_ready:
self.accounts_table.setItem(index, 3, text_to_widget(player_object.get('nick', ''), center=True))
self.accounts_table.setItem(index, 4,
text_to_widget(str(player_object.get('points', '')), center=True))
else:
for i in range(3, 5):
self.accounts_table.setItem(index, i, text_to_widget(''))
def init_brick(self):
""" 初始化砖块信息 """
self.brickTable.setHorizontalHeaderItem(0, QTableWidgetItem("砖块编号"))
self.brickTable.setHorizontalHeaderItem(1, QTableWidgetItem("X轴 / mm"))
self.brickTable.setHorizontalHeaderItem(2, QTableWidgetItem("y轴 / mm"))
self.brickTable.setHorizontalHeaderItem(3, QTableWidgetItem("已完成？"))
self.brickTable.setHorizontalHeaderItem(4, QTableWidgetItem("取消"))
row_count = self.brickTable.rowCount() # 砖列表行数
for i in range(row_count):
chkBoxItem = QTableWidgetItem()
chkBoxItem.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled)
chkBoxItem.setCheckState(QtCore.Qt.Unchecked)
self.brickTable.setItem(i, 4, chkBoxItem)
self.brickTable.itemClicked.connect(self.handleItemClicked)
self._list = []
for i in range(row_count):
self.brickTable.setItem(i , 0, QTableWidgetItem("brick_" + str(i)))
self.brickTable.setItem(i , 1, QTableWidgetItem("0.0"))
self.brickTable.setItem(i , 2, QTableWidgetItem("0.0"))
self.brickTable.setItem(i , 3, QTableWidgetItem("0"))
def show_configs(self, records):
self.config_table.cellChanged.disconnect()
self.config_table.clear()
table_headers = ['序号', '客户端名称', '客户端ID', '可登录', '截止日期']
self.config_table.setColumnCount(len(table_headers))
self.config_table.setHorizontalHeaderLabels(table_headers)
self.config_table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.config_table.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)
self.config_table.setRowCount(len(records))
for row, row_item in enumerate(records):
item0 = QTableWidgetItem(str(row + 1))
item0.setTextAlignment(Qt.AlignCenter)
item0.id = row_item['id']
self.config_table.setItem(row, 0, item0)
item1 = QTableWidgetItem(row_item['name'])
item1.setTextAlignment(Qt.AlignCenter)
self.config_table.setItem(row, 1, item1)
item2 = QTableWidgetItem(row_item['machine_code'])
item2.setTextAlignment(Qt.AlignCenter)
self.config_table.setItem(row, 2, item2)
if row_item['accessed']:
item3 = QTableWidgetItem('允许登录')
item3.setCheckState(Qt.Checked)
item3.setForeground(QBrush(QColor(100,200,180)))
item4 = QTableWidgetItem(row_item['expire_time'])
else:
item3 = QTableWidgetItem('不能登录')
item3.setCheckState(Qt.Unchecked)
item3.setForeground(QBrush(QColor(200, 100, 80)))
item4 = QTableWidgetItem('')
item3.setTextAlignment(Qt.AlignCenter)
item4.setTextAlignment(Qt.AlignCenter)
self.config_table.setItem(row, 3, item3)
self.config_table.setItem(row, 4, item4)
self.config_table.cellChanged.connect(self.config_table_checked_changed) # 恢复信号
def __init__(self, labels, parent=None):
super().__init__(len(labels), 3)
self.labels = labels
self.setEditTriggers(QTableWidget.NoEditTriggers)
self.setAlternatingRowColors(True)
self.setSelectionBehavior(QTableWidget.SelectRows)
self.setHorizontalHeaderLabels(["Name", "ID", " "])
self.setSelectionMode(QTableWidget.SingleSelection)
for i, label in enumerate(self.labels_info):
checkbox_item = QTableWidgetItem(label["state"])
label_name_item = QTableWidgetItem(label["name"])
label_id_item = QTableWidgetItem(str(label["id"]))
if label["state"]:
checkbox_item.setCheckState(Qt.Checked)
else:
checkbox_item.setCheckState(Qt.Unchecked)
self.setItem(i, 0, label_name_item)
self.setItem(i, 1, label_id_item)
self.setItem(i, 2, checkbox_item)
self.resizeColumnsToContents()
self.cellChanged.connect(self._on_checked)
def populateTable(self, filePath):
self.filePath = filePath[0]
ui = self
table = ui.tableWidget
table.setRowCount(0)
self.domdoc = QtXml.QDomDocument()
xml = QFile(self.filePath)
if (xml.open(QIODevice.ReadOnly | QIODevice.Text)):
self.domdoc.setContent(xml)
layers = self.domdoc.elementsByTagName("legendlayer")
self.layers = layers
for i in range(layers.length()):
table.setRowCount(table.rowCount() + 1)
info = self.getLayerInfo(layers.item(i))
if info:
nameItem = QTableWidgetItem(info['name'])
nameItem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsSelectable
| Qt.ItemIsEnabled)
nameItem.setCheckState(Qt.Unchecked)
nameItem.setData(Qt.UserRole, info['id'])
nameItem.setData(Qt.ToolTipRole, info['doc'])
table.setItem(i, 0, nameItem)
table.setItem(i, 1, FixedWidgetItem(info['mtype']))
table.setItem(i, 2, FixedWidgetItem(info['geom']))
table.setItem(i, 3, FixedWidgetItem(info['provider']))
ds = FixedWidgetItem(info['ds'])
ds.setData(Qt.ToolTipRole, info['ds'])
table.setItem(i, 4, ds)
def set_table_info(self):
self.table_items = my_sql.sql_select(self.query_table_select)
if "mysql.connector.errors" in str(type(self.table_items)):
QMessageBox.critical(self, "Ошибка sql получение таблицы", self.table_items.msg, QMessageBox.Ok)
return False
self.table_widget.clearContents()
self.table_widget.setRowCount(0)
if not self.table_items:
return False
for table_typle in self.table_items:
self.table_widget.insertRow(self.table_widget.rowCount())
for column in range(1, len(table_typle)):
if isinstance(table_typle[column], Decimal):
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(table_typle[column]))
elif isinstance(table_typle[column], datetime.date):
text = table_typle[column].strftime("%d.%m.%Y")
else:
text = str(table_typle[column])
item = QTableWidgetItem(text)
if column == 8:
if table_typle[0] in self.other_value:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
item.setData(5, table_typle[0])
self.table_widget.setItem(self.table_widget.rowCount() - 1, column - 1, item)
def btnAdd_Clicked(self):
numRows = self.tableWidget.rowCount()
self.tableWidget.insertRow(numRows)
chkBoxItem = QTableWidgetItem()
chkBoxItem.setFlags(QtCore.Qt.ItemIsUserCheckable
| QtCore.Qt.ItemIsEnabled)
chkBoxItem.setCheckState(QtCore.Qt.Checked)
self.tableWidget.setItem(numRows, 0, chkBoxItem)
txtItem1 = QTableWidgetItem(
self.dedStart.date().toString("MM/dd/yyyy"))
txtItem1.setFlags(QtCore.Qt.ItemIsEnabled)
self.tableWidget.setItem(numRows, 1, txtItem1)
txtItem2 = QTableWidgetItem(self.tmeStart.time().toString("hh:mm"))
txtItem2.setFlags(QtCore.Qt.ItemIsEnabled)
self.tableWidget.setItem(numRows, 2, txtItem2)
txtItem3 = QTableWidgetItem(self.dedEnd.date().toString("MM/dd/yyyy"))
txtItem3.setFlags(QtCore.Qt.ItemIsEnabled)
self.tableWidget.setItem(numRows, 3, txtItem3)
txtItem4 = QTableWidgetItem(self.tmeEnd.time().toString("hh:mm"))
txtItem4.setFlags(QtCore.Qt.ItemIsEnabled)
self.tableWidget.setItem(numRows, 4, txtItem4)
self.tableWidget.setRowHeight(numRows, 20)
def refresh_filter(self):
'''
刷新筛选信息
:return:
'''
# 模块筛选
module_type = getter.get_filter_module_type_all()
for i in range(len(module_type)):
item = QTableWidgetItem(module_type[i]['name'])
item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
item.setCheckState(Qt.Unchecked)
item.setTextAlignment(Qt.AlignTop)
print(i)
self.filter_type_table.setItem(0, i + 1, item)
# 用例类型筛选
scen_type = getter.get_filter_scen_type_all()
for i in range(len(scen_type)):
item = QTableWidgetItem(scen_type[i]['name'])
item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
item.setCheckState(Qt.Unchecked)
item.setTextAlignment(Qt.AlignTop)
if i > 10:
self.filter_type_table.setItem(2, i - 10, item)
else:
self.filter_type_table.setItem(1, i + 1, item)
# 人员分类
self.filter_type_table.resizeColumnsToContents()
def __make_checkbox(self):
checkbox = QTableWidgetItem()
checkbox.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
checkbox.setCheckState(Qt.Unchecked)
return checkbox
def updateTableUi(self):
self.fileView.setRowCount(0)
end = self.nStart+self.nPageSize if self.nStart+self.nPageSize < self.nTotal else self.nTotal
if end == self.nTotal:
self.nextBtn.setEnabled(False)
for i in range(self.nStart, end):
subDict = self.fileDicts['seq_'+str(i).zfill(4)]
row = self.fileView.rowCount()
self.fileView.setRowCount(row + 1)
item0 = QTableWidgetItem(subDict['filename'])
if (row+1) % 10 == 0:
textFont = QFont("Arial", 9, QFont.Bold)
item0.setFont(textFont)
item0.setForeground(QColor(255,0,0))
item1 = QTableWidgetItem(str(subDict['count']))
#√
item2 = QTableWidgetItem('×')
item2.setForeground(QColor(0,0,0))
item2.setTextAlignment(Qt.AlignCenter)
item3 = QTableWidgetItem(str(row + 1))
item4 = QTableWidgetItem(subDict['content'])
item5 = QTableWidgetItem(subDict['seq'])
self.fileView.setItem(row, 0, item0)
self.fileView.setItem(row, 1, item1)
self.fileView.setItem(row, 2, item2)
self.fileView.setItem(row, 3, item3)
self.fileView.setItem(row, 4, item4)
self.fileView.setItem(row, 5, item5)
item3.setCheckState(Qt.Unchecked)
def addImage(self):
fileNames, _ = QFileDialog.getOpenFileNames(self, "Open Images", '',
"Images (*.png *.xpm *.jpg);;All Files (*)")
for fileName in fileNames:
row = self.imagesTable.rowCount()
self.imagesTable.setRowCount(row + 1)
imageName = QFileInfo(fileName).baseName()
item0 = QTableWidgetItem(imageName)
item0.setData(Qt.UserRole, fileName)
item0.setFlags(item0.flags() & ~Qt.ItemIsEditable)
item1 = QTableWidgetItem("Normal")
item2 = QTableWidgetItem("Off")
if self.guessModeStateAct.isChecked():
if '_act' in fileName:
item1.setText("Active")
elif '_dis' in fileName:
item1.setText("Disabled")
elif '_sel' in fileName:
item1.setText("Selected")
if '_on' in fileName:
item2.setText("On")
self.imagesTable.setItem(row, 0, item0)
self.imagesTable.setItem(row, 1, item1)
self.imagesTable.setItem(row, 2, item2)
self.imagesTable.openPersistentEditor(item1)
self.imagesTable.openPersistentEditor(item2)
item0.setCheckState(Qt.Checked)
def update_feature_table(self):
self.feature_table.setRowCount(0)
# disconnect signal, else it would be called when adding a row
try:
self.feature_table.cellChanged.disconnect()
except:
pass
# available features
for row, feature_type in enumerate(FEATURES):
self.feature_table.insertRow(row)
feat_item = QTableWidgetItem(feature_type.label)
feat_item.setCheckState(False)
b_color = Qt.QColor(255, 255, 255)
if issubclass(feature_type, UnorderedFeature):
codebooks = self.store.list_codebooks(feature_type)
if len(codebooks) == 0:
dict_label = 'dictionary required, but none found'
b_color = Qt.QColor(255, 230, 230)
else:
dict_label = ' | '.join(codebooks)
b_color = Qt.QColor(230, 255, 230)
else:
dict_label = 'no dictionary needed'
dict_item = QTableWidgetItem(dict_label)
dict_item.setBackground(b_color)
self.feature_table.setItem(row, 0, feat_item)
self.feature_table.setItem(row, 1, dict_item)
self.feature_table.resizeColumnsToContents()
self.feature_table.cellChanged.connect(self.color_species_table)
def AddLine(self, table):
row = table.rowCount()
table.setRowCount(row + 1)
checkBox = QTableWidgetItem()
checkBox.setCheckState(Qt.Unchecked)
table.setItem(row, 0, checkBox)
def update_species_table(self):
self._species_features = []
table = self.species_table
# remove all rows
table.setRowCount(0)
stored_species = self.store.list_categories()
for row, species in enumerate(stored_species):
table.insertRow(row)
species_check = QTableWidgetItem(species)
species_check.setCheckState(False)
feat_txts = []
feats = []
feat_missing = False
for feature_type in FEATURES:
feat_count = self.store.get_feature_count(
species, feature_type)
label = feature_type.label
feat_txt = '{}: {}'.format(label, feat_count)
feat_txts.append(feat_txt)
if feat_count > 0:
feats.append(feature_type)
feat_item = QTableWidgetItem(' | '.join(feat_txts))
# there is no function to add extra data, so just appended
# available features to object (not a good style but needed to do
# coloring without updating table again)
feat_item.features = feats
table.setItem(row, 0, species_check)
table.setItem(row, 1, feat_item)
self.color_species_table()
self.species_table.resizeColumnsToContents()
def popup(self, pos):
menu = QMenu()
checkAction = menu.addAction("Check selected rows")
unCheckAction = menu.addAction("Uncheck selected rows")
action = menu.exec_(self.deleteTable.mapToGlobal(pos))
check = None
if action == checkAction:
check = Qt.Checked
elif action == unCheckAction:
check = Qt.Unchecked
if check is not None:
self.freeze()
rows = set([
i.row() for i in
self.deleteTable.selectionModel().selection().indexes()
])
nSamples = self.deleteTable.rowCount() - 1
for r in rows:
item = self.deleteTable.item(r, 0)
if item is None:
item = QTableWidgetItem()
flags = item.flags()
mask = ~(Qt.ItemIsSelectable | Qt.ItemIsEditable)
item.setFlags(flags & mask)
item.setCheckState(check)
self.deleteTable.setItem(r, 0, item)
if (item is not None):
item.setCheckState(check)
self.activateDeleteButton(rows.pop(), 0)
self.unfreeze()
def set_model(self, file_items):
self._reset()
self.setRowCount(len(file_items))
self.setSortingEnabled(False)
for i in range(0, len(file_items)):
source = file_items[i][DisplayKeys.source]
target = file_items[i][DisplayKeys.target]
source_item = QTableWidgetItem(source)
target_item = QTableWidgetItem(target)
mime = MainTable._mime_database.mimeTypesForFileName(source)
if len(mime):
source_item.setIcon(QIcon.fromTheme(mime[0].iconName()))
else:
logger.error("Unable to determine mime type for " + source)
source_item.setIcon(QIcon.fromTheme("text-x-generic"))
source_item.setCheckState(Qt.Checked)
_, file_name = os.path.split(target)
if file_name.startswith(_UNKNOWN_KEY):
target_item.setBackground(MainTable._error_brush)
source_item.setBackground(MainTable._error_brush)
source_item.setCheckState(Qt.Unchecked)
self.setItem(i, 0, source_item)
self.setItem(i, 1, target_item)
self.setSortingEnabled(True)
self.model = file_items
def refresh_tablewidget_vectors():
tablewidget_vectors: QTableWidget = VectorConfigInputInterface.vectorconfig_dialog.tablewidget_vectors_vc
tablewidget_vectors.setSortingEnabled(False)
vectors: list = DatabaseInterface.find_vectors_all()
tablewidget_vectors.clearContents()
counter: int = 0
for vector in vectors:
vector: dict
tablewidget_vectors.insertRow(counter)
checkbox_item = QTableWidgetItem()
checkbox_item.setCheckState(False)
vectorname_item = QTableWidgetItem(vector['name'])
vectorname_item.setFlags(Qt.ItemIsEnabled)
vectordescription_item = QTableWidgetItem(vector['description'])
vectordescription_item.setFlags(Qt.ItemIsEnabled)
vectorid_item = QTableWidgetItem(str(vector['_id']))
vectorid_item.setFlags(Qt.ItemIsEnabled)
tablewidget_vectors.setItem(counter, 0, checkbox_item)
tablewidget_vectors.setItem(counter, 1, vectorname_item)
tablewidget_vectors.setItem(
counter, 2,
vectordescription_item) # log entry timestamp column
tablewidget_vectors.setItem(
counter, 3, vectorid_item) # log entry event column
counter += 1
tablewidget_vectors.setRowCount(len(vectors))
tablewidget_vectors.setSortingEnabled(True)
def addImage(self):
fileNames, _ = QFileDialog.getOpenFileNames(
self, "Open Images", "", "Images (*.png *.xpm *.jpg);;All Files (*)"
)
for fileName in fileNames:
row = self.imagesTable.rowCount()
self.imagesTable.setRowCount(row + 1)
imageName = QFileInfo(fileName).baseName()
item0 = QTableWidgetItem(imageName)
item0.setData(Qt.UserRole, fileName)
item0.setFlags(item0.flags() & ~Qt.ItemIsEditable)
item1 = QTableWidgetItem("Normal")
item2 = QTableWidgetItem("Off")
if self.guessModeStateAct.isChecked():
if "_act" in fileName:
item1.setText("Active")
elif "_dis" in fileName:
item1.setText("Disabled")
elif "_sel" in fileName:
item1.setText("Selected")
if "_on" in fileName:
item2.setText("On")
self.imagesTable.setItem(row, 0, item0)
self.imagesTable.setItem(row, 1, item1)
self.imagesTable.setItem(row, 2, item2)
self.imagesTable.openPersistentEditor(item1)
self.imagesTable.openPersistentEditor(item2)
item0.setCheckState(Qt.Checked)
def set_from(self, project):
section = project.events
for event in section.value:
numRows = self.tableWidget.rowCount()
self.tableWidget.insertRow(numRows)
# Add text to the row
chkBoxItem = QTableWidgetItem()
chkBoxItem.setFlags(QtCore.Qt.ItemIsUserCheckable
| QtCore.Qt.ItemIsEnabled)
chkBoxItem.setCheckState(QtCore.Qt.Checked)
self.tableWidget.setItem(numRows, 0, chkBoxItem)
txtItem1 = QTableWidgetItem(event.start_date)
txtItem1.setFlags(QtCore.Qt.ItemIsEnabled)
self.tableWidget.setItem(numRows, 1, txtItem1)
txtItem2 = QTableWidgetItem(event.start_time)
txtItem2.setFlags(QtCore.Qt.ItemIsEnabled)
self.tableWidget.setItem(numRows, 2, txtItem2)
txtItem3 = QTableWidgetItem(event.end_date)
txtItem3.setFlags(QtCore.Qt.ItemIsEnabled)
self.tableWidget.setItem(numRows, 3, txtItem3)
txtItem4 = QTableWidgetItem(event.end_time)
txtItem4.setFlags(QtCore.Qt.ItemIsEnabled)
self.tableWidget.setItem(numRows, 4, txtItem4)
self.tableWidget.setRowHeight(numRows, 20)
self.tableWidget.setCurrentCell(0, 0)
self.tableWidget.resizeColumnsToContents()
pass
def fill_test_tab(self):
self.w_main.tests_tab.setSelectionMode(QAbstractItemView.SingleSelection)
self.w_main.tests_tab.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.w_main.tests_tab.setRowCount(0)
self.w_main.tests_tab.setColumnCount(3)
self.w_main.tests_tab.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeToContents)
self.w_main.tests_tab.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)
self.w_main.tests_tab.horizontalHeader().setSectionResizeMode(2, QHeaderView.ResizeToContents)
self.w_main.tests_tab.setHorizontalHeaderLabels(["", "Test name", ""])
# self.w_main.tests_tab.horizontalHeaderItem(0).setToolTip("Column 1 ")
# self.w_main.tests_tab.horizontalHeaderItem(1).setToolTip("Column 2 ")
test_dict = self.get_tests_queue(getattr(sys.modules[__name__], self.test_type))
keys = sorted(list(test_dict.keys()))
for key in keys:
rowPosition = self.w_main.tests_tab.rowCount()
chkBoxItem = QTableWidgetItem()
chkBoxItem.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled)
chkBoxItem.setCheckState(QtCore.Qt.Checked)
self.w_main.tests_tab.insertRow(rowPosition)
self.w_main.tests_tab.setItem(rowPosition, 0, chkBoxItem)
self.w_main.tests_tab.setItem(rowPosition, 1, QTableWidgetItem(test_dict.get(key)[0]))
self.w_main.tests_tab.setItem(rowPosition, 2, None)
self.w_main.tests_tab.resizeRowsToContents()
def setConfig(self, config):
self.remoteConfig = config
self.localConfig = copy.copy(
config) # Local configuration is initially a copy of the remote
self.configtable.clearContents()
self.unit_label.setText("Currently configuring: {}".format(
self.remoteConfig["s_id"]))
self.configtable.setRowCount(len(self.remoteConfig))
self.configtable.setColumnCount(2)
i = 0
for key in self.remoteConfig:
self.configtable.setItem(i, 0, QTableWidgetItem(key))
type_tag = key[:2]
if type_tag == "s_":
if key == "s_device":
comboBox = QtWidgets.QComboBox()
comboBox.addItem("rf1")
comboBox.addItem("rf2")
comboBox.addItem("alsa")
index = comboBox.findText(self.remoteConfig[key])
comboBox.setCurrentIndex(index)
self.configtable.setCellWidget(i, 1, comboBox)
else:
tableItem = QTableWidgetItem(str(self.remoteConfig[key]))
self.configtable.setItem(i, 1, tableItem)
elif type_tag == "f_":
floatEdit = QtWidgets.QDoubleSpinBox()
floatEdit.setMaximum(50000.0)
floatEdit.setMinimum(0.0)
floatEdit.setSingleStep(0.01)
floatEdit.setValue(self.remoteConfig[key])
self.configtable.setCellWidget(i, 1, floatEdit)
elif type_tag == "b_":
tableItem = QTableWidgetItem()
tableItem.setFlags(QtCore.Qt.ItemIsUserCheckable
| QtCore.Qt.ItemIsEnabled)
if self.remoteConfig[key]:
tableItem.setCheckState(QtCore.Qt.Checked)
else:
tableItem.setCheckState(QtCore.Qt.Unchecked)
self.configtable.setItem(i, 1, tableItem)
elif type_tag == "i_":
intEdit = QtWidgets.QSpinBox()
intEdit.setMaximum(2147483647)
intEdit.setValue(self.remoteConfig[key])
self.configtable.setCellWidget(i, 1, intEdit)
elif type_tag == "l_":
tableItem = QTableWidgetItem(str(self.remoteConfig[key]))
i = i + 1
self.popup()
def _add_task_to_table(self, row, task):
self._ignore_cell_changed = True
self.setItem(row, self._dict_header['id'],
QTableWidgetItem(str(task.identifier)))
self.item(row, self._dict_header['id']) \
.setTextAlignment(Qt.AlignCenter)
self.setItem(row, self._dict_header['name'],
QTableWidgetItem(str(task.name)))
combo = QComboBox()
items = [task_type for task_type in Task.task_types_names]
combo.addItems(items)
combo.setCurrentIndex(combo.findText(task.task_type))
combo.currentIndexChanged.connect(
lambda x: self._cell_changed(row, self._dict_header['task_type']))
self.setCellWidget(row, self._dict_header['task_type'], combo)
item = QTableWidgetItem(task.abort_on_miss and 'Yes' or 'No')
item.setFlags(
Qt.ItemIsUserCheckable | Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item.setCheckState(task.abort_on_miss and Qt.Checked or Qt.Unchecked)
self.setItem(row, self._dict_header['abort'], item)
self.setItem(row, self._dict_header['list_activation_dates'],
QTableWidgetItem(
', '.join(map(str, task.list_activation_dates))))
self.item(row, self._dict_header['list_activation_dates']) \
.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
for i in ['activation_date', 'period',
'deadline', 'wcet', 'base_cpi', 'n_instr', 'mix', 'acet',
'et_stddev', 'preemption_cost']:
self.setItem(row, self._dict_header[i],
QTableWidgetItem(str(task.__dict__[i])))
self.item(row, self._dict_header[i]) \
.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
stack_item = QTableWidgetItem(str(task.stack_file))
stack_item.setFlags(stack_item.flags() ^ (Qt.ItemIsEditable))
self.setItem(row, self._dict_header['sdp'], stack_item)
combo = QComboBox()
combo.currentIndexChanged.connect(
lambda x: self._cell_changed(row, self._dict_header['followed']))
self.setCellWidget(row, self._dict_header['followed'], combo)
for col in range(len(self._custom_fields)):
key = self._custom_fields[col]
if key in task.data and task.data[key] is not None:
item = QTableWidgetItem(str(task.data[key]))
else:
item = QTableWidgetItem('')
item.setBackgroundColor(QColor.fromRgb(200, 255, 200))
self.setItem(row, col + len(self._header), item)
self._ignore_cell_changed = False
self._show_period(task, row)
def tableWidgetMakeItem(self, text="", icon="", checkable=False, checked=False):
"""Creates a QTableWidgetItem with the given attributes."""
item = QTableWidgetItem(QIcon.fromTheme(icon), text)
if checkable:
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked if checked else Qt.Unchecked)
else:
item.setFlags(item.flags() & ~Qt.ItemIsUserCheckable)
return item
def update_scripts_list(self):
items = self.database_manager.get_scripts()
self.scriptListTableWidget.setRowCount(len(items))
for i, row in enumerate(items):
for j, column_text in enumerate(row):
item = QTableWidgetItem(column_text)
self.scriptListTableWidget.setItem(i, j, item)
check_box_item = QTableWidgetItem()
check_box_item.setCheckState(Qt.Checked)
self.scriptListTableWidget.setItem(i, len(row), check_box_item)
def update_host_list_table_widget(self, host_description_list):
self.hostListTableWidget.setRowCount(len(host_description_list))
for i, host_desc in enumerate(host_description_list):
for j, desc in enumerate(host_desc):
table_item = QTableWidgetItem(desc)
self.hostListTableWidget.setItem(i, j, table_item)
check_box_item = QTableWidgetItem()
row_check_state = Qt.Checked if host_desc[-1] == 'up' else Qt.Unchecked
check_box_item.setCheckState(row_check_state)
self.hostListTableWidget.setItem(i, len(host_desc), check_box_item)
self.set_disable_host_manager(False)
def createCheckBoxes(self):
#Create checkbox
data_unique = []
self.table=QTableWidget()
self.table.setColumnCount(1)
self.table.verticalHeader().hide()
self.table.horizontalHeader().hide()
self.table.horizontalHeader().setStretchLastSection(True)
self.table.setRowCount(self.rowCount())
#Assign the action a create the list of checkbox
self.checkBoxs = []
checkBox = QCheckBox("Seleccionar todo", self.menu)
checkableAction = QWidgetAction(self.menu)
checkableAction.setDefaultWidget(checkBox)
self.menu.addAction(checkableAction)
checkBox.setChecked(Qt.Checked)
checkBox.stateChanged.connect(self.slotSelect)
j=0
for i in range(self.rowCount()):
if not self.isRowHidden(i):
item = self.item(i, self.col )
if item.text() not in data_unique:
data_unique.append(item.text())
it = QTableWidgetItem(item.text())
it.setFlags(Qt.ItemIsUserCheckable |Qt.ItemIsEnabled)
it.setCheckState(Qt.Checked)
self.checkBoxs.append(it)
j=j+1
#Sort the element of the list
self.checkBoxs=sorted(self.checkBoxs, key=lambda it: it.text())
# self.sort(self.checkBoxs[i])
j=0
for i in range(len(self.checkBoxs)):
#print(self.checkBoxs[i].text())
self.table.setItem(j,0, self.checkBoxs[i])
j=j+1
self.table.update()
self.table.setRowCount(len(self.checkBoxs))
checkableAction = QWidgetAction(self.menu)
checkableAction.setDefaultWidget(self.table)
self.menu.addAction(checkableAction)
def on_coords_recieved(self, df):
"""
Modify the TableWidget when the data is recieved in the `coords` terminal
"""
if df is None:
# if DataFrame withh coords is emty
self.clear()
else:
#if everything is Ok, create rows and populate them
for i, wellName in enumerate(df.index.values):
# first check if a row with this name already exists
if wellName in self._tableWidget_wellNames():
continue
# no dupticated entry > continue adding the row
self.tableWidget_menu.insertRow(i) #create row
# now create 4 items for this row
# - well Name [Checkbox]
# - X coord [label]
# - Y coord [label]
# - Head [combobox]
wellNameItem = QTableWidgetItem(wellName)
wellNameItem.setFlags(wellNameItem.flags() ^ Qt.ItemIsEditable)
wellNameItem.setCheckState(Qt.Checked)
#wellNameItem.currentIndexChanged.connect(self._parent.on_calcSingle_requested)
xCoordItem = QTableWidgetItem('{0:.2f}'.format( float(df.iloc[[i]]['x']) ) )
xCoordItem.setFlags(xCoordItem.flags() ^ Qt.ItemIsEditable)
yCoordItem = QTableWidgetItem('{0:.2f}'.format( float(df.iloc[[i]]['y']) ) )
yCoordItem.setFlags(yCoordItem.flags() ^ Qt.ItemIsEditable)
headItem = QtWidgets.QComboBox()
headItem.currentIndexChanged.connect(self._parent.on_calcSingle_requested)
# finally add items to the table (populate the row)
self.tableWidget_menu.setItem(i, 0, wellNameItem)
self.tableWidget_menu.setItem(i, 1, xCoordItem)
self.tableWidget_menu.setItem(i, 2, yCoordItem)
self.tableWidget_menu.setCellWidget(i, 3, headItem)
self.updateUI()
def sat_insert(self, sat):
row = self.sattable.rowCount()
self.sattable.insertRow(row)
cb = QTableWidgetItem("")
cb.setCheckState(Qt.Unchecked)
self.sattable.setItem(row, 0, cb)
self.sattable.setItem(
row, 1,
QTableWidgetItem(str(sat.norad))
)
self.sattable.setItem(
row, 2,
QTableWidgetItem(str(sat.intl))
)
self.sattable.setItem(
row, 3,
QTableWidgetItem(str(sat.name))
)
def load_table(table, headers, data, checkFirstColumn=True):
table.setHorizontalHeaderLabels(headers)
table.horizontalHeader().setStretchLastSection(True)
table.setSelectionBehavior(QAbstractItemView.SelectRows)
for i in range(table.rowCount()):
table.removeRow(0)
for r, row in enumerate(data):
table.insertRow(r)
for index, colItem in enumerate(row):
item = QTableWidgetItem(colItem)
table.setItem(r, index, item)
if index == 0 and checkFirstColumn:
item.setData(Qt.UserRole, row)
item.setCheckState(Qt.Unchecked)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled |
Qt.ItemIsUserCheckable)
else:
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
def setValue(self, value):
self._updating = True
self.resizeColumnsToContents()
self.setMinimumSize(self.viewportSizeHint())
self.setRowCount(0)
if value is None:
value = set()
self._value = value
row = -1
for choice in sorted(self._reversed_choices):
row += 1
self.insertRow(row)
item = QTableWidgetItem(self._choices[choice])
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.setItem(row, 0, item)
item = QTableWidgetItem()
item.setFlags((item.flags() & ~Qt.ItemIsEditable) | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked if choice in value else Qt.Unchecked)
self.setItem(row, 1, item)
self.resizeColumnsToContents()
self.setMinimumSize(self.viewportSizeHint())
self._updating = False
def __init__(self, parent, file_path, callback, persepolis_setting):
super().__init__(persepolis_setting)
self.persepolis_setting = persepolis_setting
self.callback = callback
self.file_path = file_path
self.parent = parent
global icons
icons = ':/' + \
str(self.persepolis_setting.value('settings/icons')) + '/'
# read text file lines and put links in list format.
f = open(self.file_path)
f_links_list = f.readlines()
f.close()
f_links_list.reverse()
# check links! links must be started with http or https or ftp
link_list = []
for link in f_links_list:
text = link.strip()
if ("tp:/" in text[2:6]) or ("tps:/" in text[2:7]):
link_list.append(text)
k = 1
for link in link_list:
self.links_table.insertRow(0)
# file_name
file_name = '***'
dict = {'link': link}
# spider finds file name
new_spider = QueueSpiderThread(dict)
self.parent.threadPool.append(new_spider)
self.parent.threadPool[len(self.parent.threadPool) - 1].start()
self.parent.threadPool[len(self.parent.threadPool) - 1].QUEUESPIDERRETURNEDFILENAME.connect(
partial(self.parent.queueSpiderCallBack, child=self, row_number=len(link_list) - k))
k = k + 1
item = QTableWidgetItem(file_name)
# add checkbox to the item
item.setFlags(QtCore.Qt.ItemIsUserCheckable |
QtCore.Qt.ItemIsEnabled)
item.setCheckState(QtCore.Qt.Checked)
# insert file_name
self.links_table.setItem(0, 0, item)
# insert link
item = QTableWidgetItem(str(link))
self.links_table.setItem(0, 1, item)
# get categories name and add them to add_queue_comboBox
categories_list = self.parent.persepolis_db.categoriesList()
for queue in categories_list:
if queue != 'All Downloads':
self.add_queue_comboBox.addItem(queue)
self.add_queue_comboBox.addItem(
QIcon(icons + 'add_queue'), 'Create new queue')
# entry initialization
# get values from persepolis_setting
global connections
connections = int(
self.persepolis_setting.value('settings/connections'))
global download_path
download_path = str(
self.persepolis_setting.value('settings/download_path'))
self.connections_spinBox.setValue(connections)
self.download_folder_lineEdit.setText(download_path)
self.download_folder_lineEdit.setEnabled(False)
# ip_lineEdit initialization
settings_ip = self.persepolis_setting.value(
'add_link_initialization/ip', None)
if settings_ip:
self.ip_lineEdit.setText(str(settings_ip))
# proxy user lineEdit initialization
settings_proxy_user = self.persepolis_setting.value(
'add_link_initialization/proxy_user', None)
if settings_proxy_user:
self.proxy_user_lineEdit.setText(str(settings_proxy_user))
# port_spinBox initialization
settings_port = self.persepolis_setting.value(
'add_link_initialization/port', 0)
self.port_spinBox.setValue(int(int(settings_port)))
# download UserName initialization
settings_download_user = self.persepolis_setting.value(
'add_link_initialization/download_user', None)
if settings_download_user:
self.download_user_lineEdit.setText(str(settings_download_user))
# connect folder_pushButton
self.folder_pushButton.clicked.connect(self.changeFolder)
# connect OK and canel button
self.cancel_pushButton.clicked.connect(self.close)
self.ok_pushButton.clicked.connect(self.okButtonPressed)
# connect select_all_pushButton deselect_all_pushButton
self.select_all_pushButton.clicked.connect(self.selectAll)
self.deselect_all_pushButton.clicked.connect(self.deselectAll)
#frames and checkBoxes
self.proxy_frame.setEnabled(False)
self.proxy_checkBox.toggled.connect(self.proxyFrame)
self.download_frame.setEnabled(False)
self.download_checkBox.toggled.connect(self.downloadFrame)
self.limit_frame.setEnabled(False)
self.limit_checkBox.toggled.connect(self.limitFrame)
# set focus to ok button
self.ok_pushButton.setFocus()
# add_queue_comboBox event
self.add_queue_comboBox.currentIndexChanged.connect(self.queueChanged)
# setting window size and position
size = self.persepolis_setting.value('TextQueue/size', QSize(700, 500))
position = self.persepolis_setting.value(
'TextQueue/position', QPoint(300, 300))
self.resize(size)
self.move(position)
def _update_dictionaries(self, config_dictionaries=None, loaded_dictionaries=None,
reverse_order=None, record=True, save=True,
reset_undo=False, keep_selection=True):
if reverse_order is None:
reverse_order = self._reverse_order
if config_dictionaries is None:
config_dictionaries = self._config_dictionaries
if config_dictionaries == self._config_dictionaries and \
reverse_order == self._reverse_order and \
loaded_dictionaries is None:
return
if save:
self._engine.config = { 'dictionaries': config_dictionaries }
if record:
self._states.append(self._config_dictionaries)
self.action_Undo.setEnabled(True)
if keep_selection:
selected = [
self._config_dictionaries[row].path
for row in self._get_selection()
]
self._config_dictionaries = config_dictionaries
if loaded_dictionaries is None:
loaded_dictionaries = self._loaded_dictionaries
else:
self._loaded_dictionaries = loaded_dictionaries
self._reverse_order = reverse_order
self._updating = True
self.table.setRowCount(len(config_dictionaries))
favorite_set = False
for n, dictionary in enumerate(config_dictionaries):
row = n
if self._reverse_order:
row = len(config_dictionaries) - row - 1
item = QTableWidgetItem(dictionary.short_path)
item.setFlags((item.flags() | Qt.ItemIsUserCheckable) & ~Qt.ItemIsEditable)
item.setCheckState(Qt.Checked if dictionary.enabled else Qt.Unchecked)
item.setToolTip(dictionary.path)
self.table.setItem(row, 0, item)
item = QTableWidgetItem(str(n + 1))
if dictionary.path not in loaded_dictionaries:
icon = 'loading'
else:
d = loaded_dictionaries.get(dictionary.path)
if isinstance(d, ErroredDictionary):
icon = 'error'
item.setToolTip(str(d.exception))
elif d.readonly:
icon = 'readonly'
elif not favorite_set and dictionary.enabled:
icon = 'favorite'
favorite_set = True
else:
icon = 'normal'
item.setIcon(QIcon(':/dictionary_%s.svg' % icon))
self.table.setVerticalHeaderItem(row, item)
if keep_selection:
row_list = []
for path in selected:
for n, d in enumerate(config_dictionaries):
if d.path == path:
row_list.append(n)
break
self._set_selection(row_list)
if reset_undo:
self.action_Undo.setEnabled(False)
self._states = []
self._updating = False
self.on_selection_changed()
