def add_download_item(self, downloader):
for historyDownloader in self.downloaderList:
if historyDownloader.name == downloader.name and \
(historyDownloader.status == STATUS_PENDING or
historyDownloader.status == STATUS_DOWNLOADING or
historyDownloader.status == STATUS_DOWNLOADED):
return
self.downloaderList.append(downloader)
comic_name = downloader.name
table = self.ui.tableWidgetDownload
row_count = table.rowCount()
table.setRowCount(row_count + 1)
comic_name_cell = QTableWidgetItem(comic_name)
comic_name_cell.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
progress_bar_cell = QProgressBar()
progress_bar_cell.setRange(0, 100)
progress_bar_cell.setAlignment(Qt.AlignCenter)
status_cell = QLabel(STATUS_PENDING)
status_cell.setAlignment(Qt.AlignCenter)
table.setItem(row_count, 0, comic_name_cell)
table.setCellWidget(row_count, 1, status_cell)
table.setCellWidget(row_count, 2, progress_bar_cell)
downloader.signal.status.connect(status_cell.setText)
downloader.signal.progress.connect(progress_bar_cell.setValue)
downloader.start_download()
def rows_text_insert(self,
where_to=None,
editable=None,
clickable=None,
alignment=None): # text -> table item
if where_to is None:
where_to = self.rowCount()
if editable is None:
editable = self.col_editable
if clickable is None:
clickable = self.col_clickable
if alignment is None:
alignment = self.col_alignment
n = 0
while True:
to_insert = (yield)
if to_insert is None: # 꼼수
where_to = self.rowCount()
n = 0
continue
self.insertRow(where_to + n)
for col in range(self.columnCount()):
item = QTableWidgetItem(to_insert[col])
if not editable[col]: # false 일때 플래그 제거
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
if not clickable[col]:
item.setFlags(item.flags() ^ Qt.ItemIsEnabled)
if alignment[col]:
item.setTextAlignment(alignment[col]) # ex) Qt.AlignCenter
self.setItem(where_to + n, col, item)
n += 1
def show_shortcut(self):
"""Show the list of valid keyboard shortcut.
"""
self.parent.dialog = QDialog(self.parent)
table = QTableWidget()
vbox = QVBoxLayout()
self.parent.dialog.setLayout(vbox)
self.parent.dialog.setWindowTitle("Keyboard shortcut")
header = ["key", "description"]
keys = MessageText.keylist
table.setColumnCount(len(header))
table.setRowCount(len(keys))
table.setHorizontalHeaderLabels(header)
table.verticalHeader().setVisible(False)
table.setAlternatingRowColors(True)
table.horizontalHeader().setStretchLastSection(True)
table.setEditTriggers(QAbstractItemView.NoEditTriggers)
table.setFocusPolicy(Qt.NoFocus)
for row, content in enumerate(keys):
for col, elem in enumerate(content):
item = QTableWidgetItem(elem)
item.setFlags(Qt.ItemIsDragEnabled | Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
table.setItem(row, col, item)
button = QPushButton("&Ok")
button.clicked.connect(self.close)
button.setAutoDefault(True)
vbox.addWidget(table)
vbox.addWidget(button)
self.parent.dialog.resize(640, 480)
self.parent.dialog.exec_()
def populate_suggestions(self, text):
# For Design purpose we want to input always lowercase
self.ui.inputText.setText(text.lower())
# Clean the table everytime something is typed in the inputField
self.ui.tableWidget.setRowCount(0)
try:
full_path = self.asset_to_path.get_asset_path(text.lower())
if full_path is not None:
path, asset_file_name = os.path.split(full_path[0])
self.ui.labelAsset.setText(str(asset_file_name))
if self.asset_to_path.setTheAsset(text) is not None:
asset_files = self.asset_to_path.get_files_in_asset_dir()
self.ui.tableWidget.setRowCount(len(asset_files))
for i in range(0, len(asset_files)):
full_path[0] = asset_files[i]
path, asset_file_name = os.path.split(full_path[0])
file_name_item = QTableWidgetItem(asset_file_name)
file_name_item.setFlags(QtCore.Qt.ItemIsEnabled)
self.ui.tableWidget.setItem(i, 0, file_name_item)
mod_time = datetime.fromtimestamp(
os.path.getmtime(asset_files[i]))
mod_time_item = QTableWidgetItem(str(mod_time))
mod_time_item.setFlags(QtCore.Qt.ItemIsEnabled)
self.ui.tableWidget.setItem(i, 1, mod_time_item)
self.ui.tableWidget.resizeColumnsToContents()
except AttributeError as e:
# If there is not a matching auto-completion do not throw an exception
return
def fetch_markers(data, ddf): # Fetch data into table view markersTable
if MarkersTabController.ui is None:
QMessageBox.information(MarkersTabController.ui, "Warning", "Something went wrong with the .txt file.")
else:
linkageGroupsDict = defaultdict(list)
markers = list()
# ~~~~~~~~~~~~~~ Read the markers from the file (Panda DataFrame) ~~~~~~~~~~~~~~#
for index, row in data.iterrows():
marker = Marker(row['id'], row['marker_name'],
(list(ddf.loc[ddf['marker_name'] == row['marker_name'], 'properties'])),
row['linkage_id'], row['chr'], "-", row['genetic_coord'])
markers.append(marker)
linkageGroupsDict[marker.linkage_group].append(marker)
LinkageGroup.create_linkages(linkageGroupsDict) # Create all linkage groups
Marker.markers = markers
MarkersTabController.markers = markers
MarkersTabController.ui.markersTable.verticalHeader().hide()
# ~~~~~~~~~~~~~~ Display the markers in the table in gui ~~~~~~~~~~~~~~#
for row, marker in enumerate(markers):
MarkersTabController.ui.markersTable.insertRow(row)
for column, variable in enumerate(vars(marker).items()):
item = QTableWidgetItem(str(variable[1])) if str(
variable[0]) != 'alleles' else QTableWidgetItem('N/A') if len(
variable[1]) == 0 else QTableWidgetItem(str(variable[1])[2:-2])
item.setFlags(QtCore.Qt.ItemIsEnabled)
MarkersTabController.ui.markersTable.setItem(row, column, item)
NetworkTabController.initialize_combobox(LinkageGroup.LinkageGroups)
# Display statistics
StatisticsController.display_stat(markers, LinkageGroup.LinkageGroups)
GraphicalGenotypeController.draw_graphical_genotype_map()
def write_to_sample_table(self) -> None:
"""Writes data to sample table."""
table = self.sample_table
ref = 'no'
sample = self.sample_name.text()
if sample:
for cell in range(table.rowCount()):
item = table.item(cell, 0)
if item.text() == sample:
self.same_sample()
return
if self.is_reference.isChecked():
for cell in range(table.rowCount()):
item = table.item(cell, 1)
if item.text() == 'yes':
self.more_than_one_reference()
return
ref = 'yes'
sample = QTableWidgetItem(sample)
is_reference = QTableWidgetItem(ref)
is_reference.setFlags(Qt.ItemIsEnabled)
row_position = table.rowCount()
table.insertRow(row_position)
table.setItem(row_position, 0, sample)
table.setItem(row_position, 1, is_reference)
self.is_reference.setChecked(False)
self.sample_name.setText('')
def update_row(self, row_index, key, value):
"""
Updates a table row by index, with key and value.
:param row_index: Index of the row to be updated
:param key: Key for that row
:param value: Value for that row
:return: None
"""
# Disconnecting cellChanged event so we don't get a feedback loop
self.table.cellChanged.disconnect()
for column_index, cell_text in enumerate([key, value]):
item = QTableWidgetItem()
item.setText(str(cell_text))
if column_index != 1:
# noinspection PyUnresolvedReferences
item.setFlags(Qt.ItemIsEnabled)
self.table.setItem(row_index, column_index, item)
# Connecting the cellChanged event again
self.table.cellChanged.connect(self.handle_cell_change)
self.table.resizeColumnsToContents()
def add_item(self, q=None, item: Item = None):
"""
Добавляет выбранный предмет на складе в хранилище услуги.
:param q: None everytime
:param item: Item
"""
if item is None:
current_name = self.service_ui.right_table.item(
self.service_ui.right_table.currentRow(), 0).text()
volume = int(
self.service_ui.right_table.item(
self.service_ui.right_table.currentRow(), 1).text())
item = self.right_storage[current_name][volume]
if item.name in self.service_storage:
return
self.service_storage[item.name] = item
names = {
0: item.name,
1: f"{item.nominal}/{item.current_volume}",
2: item.rate,
3: item.rate_price
}
row_pos = self.service_ui.left_table.rowCount() - 1
self.service_ui.left_table.insertRow(row_pos)
for i in range(4):
qitem = QTableWidgetItem(str(names[i]))
if i != 2:
qitem.setFlags(Qt.ItemIsEnabled)
self.service_ui.left_table.setItem(row_pos, i, qitem)
total = self.service_ui.left_table.item(
self.service_ui.left_table.rowCount() - 1, 3)
amount = float(total.text())
amount += item.rate_price
total.setText(str(int(amount)))
def refresh_asset_list(self):
types = {
'model': 1,
'layout': 2,
'anim': 3,
'fx_prep': 4,
'fx_sim': 5,
'shader': 6
}
# Match tags
matched_assets = [
k for k, v in self.asset_tags.iteritems()
if all(y in v for y in self.selected_tags)
]
# Filter: all models from build
# Clear table
while self.tbl_assets.rowCount() > 0:
self.tbl_assets.removeRow(0)
# Filter assets based on our rules:
# 1. Include all build+models+shaders
# 2. Include all build+shaders
# 3. Filter everything else based on stage/entity
filtered_assets = {}
for key, grp in self.asset_grps.iteritems():
filtered_assets[key] = []
if key in matched_assets:
for asset in grp:
if asset['stage'] == 'build' and asset['type'] == 'model':
filtered_assets[key].append(asset)
elif asset['stage'] == 'build' and asset[
'type'] == 'shader':
filtered_assets[key].append(asset)
elif asset['stage'] == self.cmb_stages.currentText(
) and asset['entity'] == self.cmb_entities.currentText():
filtered_assets[key].append(asset)
for asset_name in matched_assets:
self.tbl_assets.insertRow(0)
item = QTableWidgetItem(asset_name)
item.setFlags(QtCore.Qt.ItemIsEnabled)
self.tbl_assets.setItem(0, 0, item)
asset = filtered_assets[asset_name]
for sub_asset in asset:
# Safely grab column index based on asset type. Default
# to 1 if no type is present.
tbl_pos = types.get(sub_asset.get('type'))
if tbl_pos is None:
tbl_pos = 1
rad = AssetCell('v{}'.format(str(sub_asset['version'])),
sub_asset['filepath'], sub_asset['_id'])
self.grp_buttons.addButton(rad.getRad())
self.tbl_assets.setCellWidget(0, tbl_pos, rad)
def set_data(self, linhas):
if not linhas:
logging.info("[ListaPadrao] Nenhum registro encontrado.")
self.tableWidget_tabela.clear()
self.set_columns()
self.tableWidget_tabela.setRowCount(0)
return
self.tableWidget_tabela.setRowCount(len(linhas))
row = 0
for linha in linhas:
col = 0
for coluna in self.colunas:
valor_tratado = self.tratar_valor(linha, coluna)
valor = valor_tratado[0]
alinhamento = valor_tratado[1]
item = QTableWidgetItem(str(valor))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item.setTextAlignment(alinhamento)
self.tableWidget_tabela.setItem(row, col, item)
col = col + 1
row = row + 1
self.tableWidget_tabela.resizeColumnsToContents()
# Oculta colunas marcadas como not visible
for coluna in self.colunas.values():
self.tableWidget_tabela.setColumnHidden(coluna[3], not coluna[2])
self.dados_lista_relatorio = linhas
def popular_tabela(self, itens=None):
self.tableWidget_remanufaturas.setRowCount(0)
self.checkBox_selecionar_tudo.setChecked(False)
if itens is not None:
self.remanufaturas = self.remanufaturas + itens
self.tableWidget_remanufaturas.setRowCount(len(self.remanufaturas))
if len(self.remanufaturas) > 0:
row = 0
for remanufatura in self.remanufaturas:
col = 0
for coluna in self.colunas_remanufaturas:
valor = remanufatura.to_dict()[coluna]
item = QTableWidgetItem(str(valor))
self.tableWidget_remanufaturas.setItem(row, col, item)
if remanufatura.situacao != 'CADASTRADA':
item.setSelected(False)
item.setFlags(Qt.NoItemFlags)
col = col + 1
row = row + 1
self.tableWidget_remanufaturas.setColumnHidden(0, True)
self.ativar_botoes()
def _set_item(view, row, column, text, editable=True):
if not text:
text = ""
item = QTableWidgetItem(text)
if not editable:
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
view.setItem(row, column, item)
def _makewidget(parent, val, center=False):
""" Small helper function that builds a TableWidgetItem and sets up the font the way we want"""
out = QTableWidgetItem(str(val))
out.setFlags(Qt.ItemIsEnabled)
out.setFont(getMonospaceFont(parent))
if center:
out.setTextAlignment(Qt.AlignCenter)
return out
def generateIdField(id=''):
"""
@rtype: QTableWidgetItem
"""
idField = QTableWidgetItem(str(id))
idField.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
idField.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
return idField
def _add_row(self, entry):
# Add a row to the table, given an iterable
new_row = self.rowCount()
self.setRowCount(new_row + 1)
for col, v in enumerate(entry):
item = QTableWidgetItem(str(v))
item.setFlags(Qt.ItemIsEnabled
| Qt.ItemIsSelectable) # Do not want ItemIsEditable
self.setItem(new_row, col, item)
def update_row(self, row_number, node_name, key, new_value):
for column_index, cell_text in enumerate([node_name, key, new_value]):
item = QTableWidgetItem()
item.setText(cell_text)
if column_index != 2:
item.setFlags(Qt.ItemIsEnabled)
self.cellChanged.disconnect()
self.setItem(row_number, column_index, item)
self.cellChanged.connect(self.handle_cell_change)
self.resizeColumnsToContents()
def handle_add_action(self):
self.table.cellChanged.disconnect()
row_index = self.table.rowCount()
self.table.insertRow(row_index)
identifierItem = QTableWidgetItem()
identifierItem.setFlags(editDisabledFlags)
self.table.setItem(row_index, 0, identifierItem)
self.table.cellChanged.connect(self.handle_cell_change)
def _fill_list_with_joints(self, controller):
#self.jointTableWidget.clear()
for joint_name in controller.get_animated_joints():
insertRow = self.jointTableWidget.rowCount()
self.jointTableWidget.insertRow(insertRow)
indexItem = QTableWidgetItem("")
indexItem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
indexItem.setCheckState(Qt.Unchecked)
self.jointTableWidget.setItem(insertRow, 0, indexItem)
self.jointTableWidget.setItem(insertRow, 1,
QTableWidgetItem(str(joint_name)))
def show_songs(self):
for i, (tid, info) in enumerate(self.songs_info.items()):
self.songs_table_widget.insertRow(i)
item1 = QTableWidgetItem(info['name'])
item1.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.songs_table_widget.setItem(i, 0, item1)
item2 = QTableWidgetItem(info['file_path'])
item2.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.songs_table_widget.setItem(i, 1, item2)
self.show()
def init_ui(self):
#Add addtional UI setting
self.ui.tableWidget_categories.setColumnCount(2)
self.ui.tableWidget_categories.setColumnWidth(0, 30)
self.ui.tableWidget_categories.setColumnWidth(1, 98)
self.ui.tableWidget_categories.insertRow(0)
self.ui.tableWidget_categories.setSpan(0, 0, 1, 2)
first_row = QTableWidgetItem(" Category Name")
first_row.setFlags(False)
self.ui.tableWidget_categories.setItem(0, 0, first_row)
self.ui.tableWidget_categories.setVerticalHeaderItem(
0, QTableWidgetItem(""))
def get_uneditable_table_widget_item(in_object, is_inf=False):
"""
:param in_object: String to display
:param is_inf: if infection_state is True, cell will be red
:return: QTableWidgetItem that can be used in compartment_table or variable_table
"""
out_item = QTableWidgetItem(str(in_object))
out_item.setFlags(Qt.ItemIsEnabled)
if is_inf:
out_item.setBackground(QBrush(Qt.red))
return out_item
def show_paramlist(self):
"""Show the list of currently set parameters.
"""
self.parent.dialog = QDialog(self.parent)
table = QTableWidget()
vbox = QVBoxLayout()
self.parent.dialog.setLayout(vbox)
self.parent.dialog.setWindowTitle("Parameters list")
header = ["param", "min", "max", "step", "default"]
lst = []
for key, val in self.parent.current_params.items():
sub = []
sub.append(key)
for head in header:
if head in val:
sub.append(val[head])
lst.append(sub)
table.setColumnCount(len(header))
table.setRowCount(len(self.parent.current_params))
table.setHorizontalHeaderLabels(header)
table.verticalHeader().setVisible(False)
table.setAlternatingRowColors(True)
table.horizontalHeader().setStretchLastSection(True)
table.setEditTriggers(QAbstractItemView.NoEditTriggers)
table.setFocusPolicy(Qt.NoFocus)
for row, content in enumerate(lst):
for col, elem in enumerate(content):
item = QTableWidgetItem(str(elem))
item.setTextAlignment(Qt.AlignLeft | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsDragEnabled | Qt.ItemIsUserCheckable
| Qt.ItemIsEnabled)
table.setItem(row, col, item)
table.resizeColumnsToContents()
table.resizeRowsToContents()
table.setColumnWidth(0, 250)
table.setColumnWidth(1, 80)
table.setColumnWidth(2, 80)
table.setColumnWidth(3, 80)
table.setColumnWidth(4, 80)
button = QPushButton("&Ok")
button.clicked.connect(self.close)
button.setAutoDefault(True)
vbox.addWidget(table)
vbox.addWidget(button)
self.parent.dialog.resize(640, 480)
ret = self.parent.dialog.exec_()
def update_locations(self):
self.locations_table.setUpdatesEnabled(False)
self.locations_table.setRowCount(0)
for i in range(2):
if i == 0:
if self.scope() == QSettings.SystemScope:
continue
actualScope = QSettings.UserScope
else:
actualScope = QSettings.SystemScope
for j in range(2):
if j == 0:
if not self.application():
continue
actualApplication = self.application()
else:
actualApplication = ''
settings = QSettings(self.format(), actualScope,
self.organization(), actualApplication)
row = self.locations_table.rowCount()
self.locations_table.setRowCount(row + 1)
item0 = QTableWidgetItem()
item0.setText(settings.fileName())
item1 = QTableWidgetItem()
disable = not (settings.childKeys() or settings.childGroups())
if row == 0:
if settings.isWritable():
item1.setText("Read-write")
disable = False
else:
item1.setText("Read-only")
self.button_box.button(QDialogButtonBox.Ok).setDisabled(disable)
else:
item1.setText("Read-only fallback")
if disable:
item0.setFlags(item0.flags() & ~Qt.ItemIsEnabled)
item1.setFlags(item1.flags() & ~Qt.ItemIsEnabled)
self.locations_table.setItem(row, 0, item0)
self.locations_table.setItem(row, 1, item1)
self.locations_table.setUpdatesEnabled(True)
def table_setup(self, series, item):
"""Generates table elements based on series.
Clears any existing elements in the table, then uses series to
generate a two-column table, with headings in the first column
and data in the second. The first column is not editable,
and the second column is editable.
"""
headings = ["Name", "Alt. Names", "Author", "Volumes Owned",
"Next Volume", "Publisher", "Completed"]
data = [series.name, series.alt_names, series.author,
series.volumes_owned_readable, series.next_volume,
series.publisher, "Yes" if series.is_completed else "No"]
# Prepare table
self.edit_series_table.clear()
self.edit_series_table.setRowCount(len(headings))
self.edit_series_table.setColumnCount(2)
self.edit_series_table.setEditTriggers(
QAbstractItemView.AllEditTriggers)
header = self.edit_series_table.horizontalHeader()
header.setSectionResizeMode(0, QHeaderView.ResizeToContents)
header.setSectionResizeMode(1, QHeaderView.Stretch)
# Populate table
for i in range(len(headings)):
headerItem = QTableWidgetItem(headings[i])
headerItem.setFlags(headerItem.flags() & ~int(Qt.ItemIsEditable))
dataItem = None
self.edit_series_table.setItem(i, 0, headerItem)
if headings[i] == "Completed":
dataItem = QComboBox()
dataItem.insertItem(0, "No")
dataItem.insertItem(1, "Yes")
if str(data[i]) == "No":
dataItem.setCurrentIndex(0)
else:
dataItem.setCurrentIndex(1)
self.edit_series_table.setCellWidget(i, 1, dataItem)
else:
dataItem = QTableWidgetItem(str(data[i]))
if headings[i] == "Next Volume":
dataItem.setFlags(dataItem.flags()
& ~int(Qt.ItemIsEditable))
self.edit_series_table.setItem(i, 1, dataItem)
# set property editable if series_info_display double-clicked
if headings[i] == item and item not in ["Next Volume",
"Completed"]:
self.edit_series_table.editItem(dataItem)
def loadStudyData(self):
"""
Function for loading data from our database and
into the application
Parameters
----------
database : [SQL Lite Object]
Database object that we connect to it
through the db_model
Return
----------
None
"""
# initialize ui
ui = self.ui
helper = self.helper
tasks = helper.select_from_db(
"""SELECT task_name, study_time, notes FROM to_do_tasks""")
for row_number, task in enumerate(tasks):
# insert rows into the application for as
# many tasks as we have
ui.studyWidget.insertRow(row_number)
# loop through the task to get the amount of columns
# since we have rows and columns we insert data
# piece by piece
for column_number, data in enumerate(task):
# store the data the appropriate object
# numerics don't get viewed properly in tablewidget items
cell = QTableWidgetItem()
cell.setText(data)
cell.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
# disable functionality for all cells except the notes cell
# and also edit the alignment for the notes
if column_number == 2:
cell.setTextAlignment(Qt.AlignLeft | Qt.AlignTop)
else:
# disable options
cell.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
# add the data into the cell
ui.studyWidget.setItem(row_number, column_number, cell)
# Load finished task functionality into the table
finishedTask = QPushButton('Finished Task')
finishedTask.clicked.connect(self.levelMessageBox)
ui.studyWidget.setCellWidget(
row_number, 3, finishedTask)\
def load_table(self):
for spent_limit in self.__standard_spent_limit:
initial_row_count = self.ui.tableWidget.rowCount()
self.ui.tableWidget.insertRow(initial_row_count)
#create and insert QTableWidgetItems
twi_category = QTableWidgetItem()
twi_category.setData(Qt.DisplayRole, spent_limit.category.name)
twi_category.setFlags(Qt.ItemIsEnabled) # Disable for edition
self.ui.tableWidget.setItem(initial_row_count, 0, twi_category)
twi_amount = QTableWidgetItem()
twi_amount.setData(Qt.DisplayRole, spent_limit.amount)
self.ui.tableWidget.setItem(initial_row_count, 1, twi_amount)
def fill_db_table_with_skeletons(self):
self.db_skeletons = []
self.skeletonDBTableWidget.clear()
skeleton_list = get_skeletons_from_remote_db(self.db_url)
for idx, s in skeleton_list:
insertRow = self.skeletonDBTableWidget.rowCount()
self.skeletonDBTableWidget.insertRow(insertRow)
indexItem = QTableWidgetItem("")
indexItem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
indexItem.setCheckState(Qt.Checked)
self.skeletonDBTableWidget.setItem(insertRow, 0, indexItem)
self.skeletonDBTableWidget.setItem(insertRow, 1, QTableWidgetItem(str(s)))
self.db_skeletons.append(s)
def update_table_item(self, row, timelog_info):
column = -1
for timelog in timelog_info:
column += 1
item = QTableWidgetItem()
item.setFlags(item.flags() & ~QtCore.Qt.ItemIsEditable)
if column == 2:
timelog += " hour"
item.setText(timelog)
if not column == 3:
item.setTextAlignment(QtCore.Qt.AlignRight
| QtCore.Qt.AlignVCenter)
self.tableWidgetTimelog.setItem(row, column, item)
def addObjectToList(self, sceneId, name, color):
insertRow = self.rowCount()
self.insertRow(insertRow)
indexItem = QTableWidgetItem(str(sceneId))
indexItem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
indexItem.setCheckState(Qt.Checked)
self.setItem(insertRow, 0, indexItem)
self.setItem(insertRow, 1, QTableWidgetItem(str(name)))
self.setItem(insertRow, 2, QTableWidgetItem(""))
self.item(insertRow, 2).setBackground(
QColor(255 * color[0], 255 * color[1], 255 * color[2]))
def _table_item(text='', center=True):
item = QTableWidgetItem(text)
font = QFont()
if center: # 행번호
item.setTextAlignment(Qt.AlignCenter)
item.setFlags(Qt.NoItemFlags)
item.setFont(font)
font.setPointSize(7)
else:
item.setFlags(Qt.NoItemFlags)
item.setFont(font)
font.setPointSize(9)
return item
