def populate_table_row(self, row, line):
href = line['href']
if line['anchor']:
href = "%s#%s" % (href, line['anchor'])
href_cell = ReadOnlyTableWidgetItem(href)
href_cell.setToolTip(line['sample'] + SAMPLE_NOTE)
href_cell.setData(Qt.UserRole, line['num'])
self.setItem(row, 0, href_cell)
if 'guide' in line:
guide = "(%s):%s" % line['guide']
else:
guide = ""
guide_cell = ReadOnlyTableWidgetItem(guide)
guide_cell.setToolTip(
_("Indicates 'special' pages: copyright, titlepage, etc."))
self.setItem(row, 1, guide_cell)
toc_str = "|".join(line['toc'])
toc_cell = QTableWidgetItem(toc_str)
toc_cell.setData(Qt.UserRole, toc_str)
toc_cell.setToolTip(
_('''Click and copy hotkey to copy text.
Double-click to edit ToC entry.
Pipes(|) divide different ToC entries to the same place.'''))
self.setItem(row, 2, toc_cell)
def populate_table_row(self, row, line):
if True:
checkbox_cell = QTableWidgetItem()
checkbox_cell.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
checkbox_cell.setCheckState(Qt.Unchecked)
checkbox_cell.setToolTip(_('Checked sections will be included in <i>all</i> split books.<br>Default title will still be taken from the first <i>selected</i> section, and section order will remain as shown.')+
'<br>'+_('Use Context Menu (right-click) on selected sections to check or uncheck all selected sections.'))
self.setItem(row, 0, checkbox_cell)
href = line['href']
if line['anchor']:
href = "%s#%s"%(href,line['anchor'])
href_cell = ReadOnlyTableWidgetItem(href)
href_cell.setToolTip(line['sample']+SAMPLE_NOTE)
self.setItem(row, 1, href_cell)
if 'guide' in line:
guide = "(%s):%s"%line['guide']
else:
guide = ""
guide_cell = ReadOnlyTableWidgetItem(guide)
guide_cell.setToolTip(_("Indicates 'special' pages: copyright, titlepage, etc."))
self.setItem(row, 2, guide_cell)
toc_str = "|".join(line['toc'])
toc_cell = QTableWidgetItem(toc_str)
toc_cell.setData(Qt.UserRole, toc_str)
toc_cell.setToolTip(_('''Click and copy hotkey to copy text.
Double-click to edit ToC entry.
Pipes(|) divide different ToC entries to the same place.'''))
self.setItem(row, 3, toc_cell)
def update_customs(self, host_item):
"""
Update customs QTableWidget with customs of host item
:param host_item: Host item
:type host_item: alignak_app.items.host.Host
"""
logger.debug('Open Customs for %s', host_item.name)
self.customs_table.clear()
self.customs_table.setHorizontalHeaderLabels(self.table_headers)
self.customs_table.setRowCount(len(host_item.data['customs']))
row = 0
for custom in host_item.data['customs']:
title_item = QTableWidgetItem()
title = ''
if '_' in custom[:1]:
title = custom[1:]
title = title.replace('_', ' ').capitalize()
title_item.setText(title)
title_item.setToolTip(custom)
self.customs_table.setItem(row, 0, title_item)
data_item = QTableWidgetItem()
data_item.setText(str(host_item.data['customs'][custom]))
self.customs_table.setItem(row, 1, data_item)
row += 1
def _on_table_logged_item_clicked(self, item: QTableWidgetItem):
# Удаление строк таблицы
while self.table_logged_info.rowCount():
self.table_logged_info.removeRow(0)
row = item.row()
date_str = self.table_logged.item(row, 0).text()
logged_list = self.logged_dict[date_str]
logged_list = reversed(logged_list)
for i, logged in enumerate(logged_list):
self.table_logged_info.setRowCount(
self.table_logged_info.rowCount() + 1)
self.table_logged_info.setItem(i, 0,
QTableWidgetItem(logged['time']))
self.table_logged_info.setItem(
i, 1, QTableWidgetItem(logged['logged_human_time']))
item = QTableWidgetItem(logged['jira_id'])
item.setToolTip(logged['jira_title'])
self.table_logged_info.setItem(i, 2, item)
def _updateModel(self, what=SkyModel.UpdateAll, origin=None):
if origin is self or not what & (SkyModel.UpdateTags
| SkyModel.UpdateGroupStyle):
return
model = self.model
self._setting_model = True # to ignore cellChanged() signals (in valueChanged())
# _item_cb is a dict (with row,col keys) containing the widgets (CheckBoxes ComboBoxes) per each cell
self._item_cb = {}
# lists of "list" and "plot" checkboxes per each grouping (excepting the default grouping); each entry is an (row,col,item) tuple.
# used as argument to self._showControls()
self._list_controls = []
self._plot_controls = []
# list of selection callbacks (to which signals are connected)
self._callbacks = []
# set requisite number of rows,and start filling
self.table.setRowCount(len(model.groupings))
for irow, group in enumerate(model.groupings):
self.table.setItem(irow, 0, QTableWidgetItem(group.name))
if group is model.selgroup:
self._irow_selgroup = irow
# total # source in group: skip for "current"
if group is not model.curgroup:
self.table.setItem(irow, 1, QTableWidgetItem(str(group.total)))
# selection controls: skip for current and selection
if group not in (model.curgroup, model.selgroup):
btns = QWidget()
lo = QHBoxLayout(btns)
lo.setContentsMargins(0, 0, 0, 0)
lo.setSpacing(0)
# make selector buttons (depending on which group we're in)
if group is model.defgroup:
Buttons = (("+", lambda src, grp=group: True,
"select all sources"),
("-", lambda src, grp=group: False,
"unselect all sources"))
else:
Buttons = (
("=", lambda src, grp=group: grp.func(src),
"select only this grouping"),
("+",
lambda src, grp=group: src.selected or grp.func(src),
"add grouping to selection"),
("-", lambda src, grp=group: src.selected and not grp.
func(src), "remove grouping from selection"),
("&&",
lambda src, grp=group: src.selected and grp.func(src),
"intersect selection with grouping"))
lo.addStretch(1)
for label, predicate, tooltip in Buttons:
btn = QToolButton(btns)
btn.setText(label)
btn.setMinimumWidth(24)
btn.setMaximumWidth(24)
btn.setToolTip(tooltip)
lo.addWidget(btn)
# add callback
btn.clicked.connect(
self._currier.curry(self.selectSources, predicate))
lo.addStretch(1)
self.table.setCellWidget(irow, 2, btns)
# "list" checkbox (not for current and selected groupings: these are always listed)
if group not in (model.curgroup, model.selgroup):
item = self._makeCheckItem("", group, "show_list")
self.table.setItem(irow, self.ColList, item)
item.setToolTip(
"""<P>If checked, sources in this grouping will be listed in the source table. If un-checked, sources will be
excluded from the table. If partially checked, then the default list/no list setting of "all sources" will be in effect.
</P>""")
# "plot" checkbox (not for the current grouping, since that's always plotted)
if group is not model.curgroup:
item = self._makeCheckItem("", group, "show_plot")
self.table.setItem(irow, self.ColPlot, item)
item.setToolTip(
"""<P>If checked, sources in this grouping will be included in the plot. If un-checked, sources will be
excluded from the plot. If partially checked, then the default plot/no plot setting of "all sources" will be in effect.
</P>""")
# custom style control
# for default, current and selected, this is just a text label
if group is model.defgroup:
item = QTableWidgetItem("default:")
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setToolTip(
"""<P>This is the default plot style used for all sources for which a custom grouping style is not selected.</P>"""
)
self.table.setItem(irow, self.ColApply, item)
elif group is model.curgroup:
item = QTableWidgetItem("")
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setToolTip(
"""<P>This is the plot style used for the highlighted source, if any.</P>"""
)
self.table.setItem(irow, self.ColApply, item)
elif group is model.selgroup:
item = QTableWidgetItem("")
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setToolTip(
"""<P>This is the plot style used for the currently selected sources.</P>"""
)
self.table.setItem(irow, self.ColApply, item)
# for the rest, a combobox with custom priorities
else:
cb = QComboBox()
cb.addItems(["default"] +
["custom %d" % p for p in range(1, 10)])
index = max(0, min(group.style.apply, 9))
# dprint(0,group.name,"apply",index)
cb.setCurrentIndex(index)
cb.activated[int].connect(
self._currier.xcurry(self._valueChanged,
(irow, self.ColApply)))
self.table.setCellWidget(irow, self.ColApply, cb)
cb.setToolTip(
"""<P>This controls whether sources within this group are plotted with a customized
plot style. Customized styles have numeric priority; if a source belongs to multiple groups, then
the style with the lowest priority takes precedence.<P>""")
# attribute comboboxes
for icol, attr in self.AttrByCol.items():
# get list of options for this style attribute. If dealing with first grouping (i==0), which is
# the "all sources" grouping, then remove the "default" option (which is always first in the list)
options = PlotStyles.StyleAttributeOptions[attr]
if irow == 0:
options = options[1:]
# make combobox
cb = QComboBox()
cb.addItems(list(map(str, options)))
# the "label" option is also editable
if attr == "label":
cb.setEditable(True)
try:
index = options.index(getattr(group.style, attr))
cb.setCurrentIndex(index)
except ValueError:
cb.setEditText(str(getattr(group.style, attr)))
slot = self._currier.xcurry(self._valueChanged, (irow, icol))
cb.activated[int].connect(slot)
cb.editTextChanged['QString'].connect(slot)
cb.setEnabled(group is model.defgroup or group.style.apply)
self.table.setCellWidget(irow, icol, cb)
label = attr
if irow:
cb.setToolTip(
"""<P>This is the %s used to plot sources in this group, when a "custom" style for the group
is enabled via the style control.<P>""" % label)
else:
cb.setToolTip(
"<P>This is the default %s used for all sources for which a custom style is not specified below.<P>"
% label)
self.table.resizeColumnsToContents()
# re-enable processing of cellChanged() signals
self._setting_model = False
def _fill_tables(self, xml_data: bytes):
import io
buffer_io = io.StringIO()
from contextlib import redirect_stdout
try:
with redirect_stdout(buffer_io):
print(len(xml_data), repr(xml_data[:50]))
# Структура документа -- xml
self.logged_dict = parse_logged_dict(xml_data)
print(self.logged_dict)
if not self.logged_dict:
return
import json
print(
json.dumps(self.logged_dict, indent=4, ensure_ascii=False))
print()
logged_list = get_logged_list_by_now_utc_date(self.logged_dict)
logged_total_seconds = get_logged_total_seconds(logged_list)
logged_total_seconds_str = seconds_to_str(logged_total_seconds)
print('entry_logged_list:', logged_list)
print('today seconds:', logged_total_seconds)
print('today time:', logged_total_seconds_str)
print()
# Для красоты выводим результат в табличном виде
lines = []
# Удаление строк таблицы
while self.table_logged.rowCount():
self.table_logged.removeRow(0)
for i, (date_str, logged_list) in enumerate(
get_sorted_logged(self.logged_dict)):
total_seconds = get_logged_total_seconds(logged_list)
total_seconds_str = seconds_to_str(total_seconds)
row = date_str, total_seconds_str, total_seconds
lines.append(row)
self.table_logged.setRowCount(
self.table_logged.rowCount() + 1)
self.table_logged.setItem(i, 0, QTableWidgetItem(date_str))
item = QTableWidgetItem(total_seconds_str)
item.setToolTip('Total seconds: {}'.format(total_seconds))
self.table_logged.setItem(i, 1, item)
self.table_logged.setCurrentCell(0, 0)
self.table_logged.setFocus()
self._on_table_logged_item_clicked(
self.table_logged.currentItem())
# Список строк станет списком столбцов, у каждого столбца подсчитается максимальная длина
max_len_columns = [
max(map(len, map(str, col))) for col in zip(*lines)
]
# Создание строки форматирования: [30, 14, 5] -> "{:<30} | {:<14} | {:<5}"
my_table_format = ' | '.join('{:<%s}' % max_len
for max_len in max_len_columns)
for line in lines:
print(my_table_format.format(*line))
finally:
text = buffer_io.getvalue()
self.log.setPlainText(text)
print(text)
