def updateRect(self):
fm = QFontMetrics(self._font)
self._useRect = fm.size(Qt.TextExpandTabs, self.simpleUse())
self._nameRect = fm.size(Qt.TextExpandTabs, self.simpleName())
self._rect = QRect(
0, 0,
self._useRect.width() + self._nameRect.width() + 23,
max(self._useRect.height(), self._nameRect.height()) + 4)
x = self._useRect.width() + self._nameRect.width() + 12
y = self._rect.center().y() - 3
self._closeRect = QRect(x, y, 6, 6)
def __init__(self, parent=None, name=None, modal=False, fl=Qt.Widget):
QDialog.__init__(self, parent, fl)
Ui_B_CraftWindow.setupUi(self, self)
if name:
self.setObjectName(name)
if modal:
self.setModal(modal)
self.gems = []
self.GemName = []
self.GemCost = []
self.GemMakes = []
for i in range(0, 4):
idx = i + 1
self.GemName.append(getattr(self, 'Gem%dName' % idx))
self.GemCost.append(getattr(self, 'Gem%dCost' % idx))
self.GemMakes.append(getattr(self, 'Gem%dMakes' % idx))
self.GemMakes[i].setSpecialValueText(" ")
self.GemMakes[i].valueChanged[int].connect(self.RemakeChanged)
self.Close.clicked.connect(self.CloseWindow)
self.parent = parent
testfont = QFontMetrics(QApplication.font())
width = testfont.size(Qt.TextSingleLine, " 199g 00s 00c").width()
self.gridlayout.setColumnMinimumWidth(2, width)
def paintEvent(self, e):
p = QPainter(self)
for a in self.arcs:
a.PaintArc(p)
p.setPen(QPen(QColor(0, 115, 119)))
rectW = self.width() * 0.45
rectX = self.width() * 0.275
rect = QRect(rectX, rectX, rectW, rectW / 2)
font = QFont("Tahoma")
font.setBold(True)
font.setPixelSize(50)
fontM = QFontMetrics(font)
fontSize = fontM.size(0, "Recovery").width() + 20
font.setPixelSize(50 * (rectW / fontSize))
p.setFont(font)
p.drawText(rect, Qt.AlignHCenter | Qt.AlignBottom, self.arcs[0].id)
rect = QRect(rectX, rectX + rectW / 2, rectW, rectW / 2)
font.setBold(False)
p.setFont(font)
p.drawText(rect, Qt.AlignHCenter | Qt.AlignTop,
"{:.1f}%".format(self.arcs[0].v * 100))
def get_text_size(text, painter=None):
if not painter:
metrics = QFontMetrics(QFont())
else:
metrics = painter.fontMetrics()
size = metrics.size(Qt.TextSingleLine, text)
return size
def __init__(self, text, parent):
super(DragLabel, self).__init__(parent)
metric = QFontMetrics(self.font())
size = metric.size(Qt.TextSingleLine, text)
image = QImage(size.width() + 12, size.height() + 12, QImage.Format_ARGB32_Premultiplied)
image.fill(qRgba(0, 0, 0, 0))
font = QFont()
font.setStyleStrategy(QFont.ForceOutline)
painter = QPainter()
painter.begin(image)
painter.setRenderHint(QPainter.Antialiasing)
painter.setBrush(Qt.white)
painter.drawRoundedRect(QRectF(0.5, 0.5, image.width() - 1, image.height() - 1), 25, 25, Qt.RelativeSize)
painter.setFont(font)
painter.setBrush(Qt.black)
painter.drawText(QRect(QPoint(6, 6), size), Qt.AlignCenter, text)
painter.end()
self.setPixmap(QPixmap.fromImage(image))
self.labelText = text
def __init__(self, category, nameClass, parent=None):
super(seeCode, self).__init__(parent)
imp = importlib.import_module('NodeEditor.modules.' + category)
importlib.reload(imp)
src = category + ' , ' + nameClass
for name, obj in inspect.getmembers(imp):
if inspect.isclass(obj):
if name == nameClass:
try:
src = inspect.getcomments(obj) + '\n'
src += inspect.getsource(obj)
except Exception as e:
src = inspect.getsource(obj)
break
self.setWindowTitle('Source code of ' + nameClass)
layout = QVBoxLayout()
txt = QTextEdit()
txt.setReadOnly(True)
txt.setPlainText(src)
PythonHighlighter(txt)
font = txt.document().defaultFont()
fontMetrics = QFontMetrics(font)
textSize = fontMetrics.size(0, txt.toPlainText())
w = textSize.width() + 10
h = 250
txt.setMinimumSize(w, h)
txt.resize(w, h)
layout.addWidget(txt)
self.setLayout(layout)
self.setMinimumWidth(w + 50)
def __init__(self, text, parent):
super(DragLabel, self).__init__(parent)
metric = QFontMetrics(self.font())
size = metric.size(Qt.TextSingleLine, text)
image = QImage(size.width() + 12,
size.height() + 12, QImage.Format_ARGB32_Premultiplied)
image.fill(qRgba(0, 0, 0, 0))
font = QFont()
font.setStyleStrategy(QFont.ForceOutline)
painter = QPainter()
painter.begin(image)
painter.setRenderHint(QPainter.Antialiasing)
painter.setBrush(Qt.white)
painter.drawRoundedRect(
QRectF(0.5, 0.5,
image.width() - 1,
image.height() - 1), 25, 25, Qt.RelativeSize)
painter.setFont(font)
painter.setBrush(Qt.black)
painter.drawText(QRect(QPoint(6, 6), size), Qt.AlignCenter, text)
painter.end()
self.setPixmap(QPixmap.fromImage(image))
self.labelText = text
def set_size(self):
# Adjust window size to text (if possible)
# These values were chosen in Windows 7
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
font_metrics = QFontMetrics(self.font)
max_width = min(QDesktopWidget().availableGeometry(self).width(), QDesktopWidget().screenGeometry(self).width())
max_height = min(QDesktopWidget().availableGeometry(self).height(), QDesktopWidget().screenGeometry(self).height())
width = max(400, min(max_width-16, self.txt.document().idealWidth() + 42+10))
height = max(400, min(max_height-38, font_metrics.size(0, self._doc).height() + 145))
self.resize(width, height)
def __init__(self):
QObject.__init__(self)
self._rowHeight = 32
self._mainFont = QFont('Hack')
self._mainFont.setPixelSize(16)
# updateFontSize
fm = QFontMetrics(self._mainFont)
self._hexLetter = fm.size(0, ' ')
def upload_config_file(self):
self.file_name, _ = QFileDialog.getOpenFileName(caption='Select File', directory=os.getcwd(),
filter='Config files (*.yaml *.yml)')
self.showpath_lineEdit.setText(self.file_name)
fontMetrics = QFontMetrics(QtGui.QFont())
textSize = fontMetrics.size(0, self.file_name)
textWidth = textSize.width() + 30
textHeight = textSize.height() + 30
self.showpath_lineEdit.resize(textWidth, textHeight)
def adjust(self):
font = self.document().defaultFont()
fontMetrics = QFontMetrics(font)
text = self.toPlainText()
paragraphs = 0
for line in text.split('\n'):
paragraphs += (fontMetrics.size(0, line).width() +
30) // self.width() + 1
textWidth = self.width()
textHeight = max(1, paragraphs) * 20 + 10
self.setMaximumSize(textWidth, textHeight)
def _positions(self, option, qidx):
fm = QFontMetrics(option.font)
txt = u'%s' % qidx.data()
if not txt.startswith('['):
return
tags = literal_eval(txt)
for tag in tags:
sz = fm.size(Qt.TextSingleLine, tag)
yield sz, tag
def measure_text(self, font, text):
qfont = QFont(font.family)
qfont.setPixelSize(font.size)
qfont.setBold(FontStyle.bold in font.style)
qfont.setItalic(FontStyle.italic in font.style)
qfont.setStrikeOut(FontStyle.strike in font.style)
qfont.setUnderline(FontStyle.underline in font.style)
metrics = QFontMetrics(qfont)
size = metrics.size(0, text)
return Size(size.width(), size.height())
def box(text, tool_tip):
w = QLineEdit(self)
w.setReadOnly(True)
w.setFont(get_monospace_font())
w.setText(str(text))
w.setToolTip(tool_tip)
fm = QFontMetrics(w.font())
magic_number = 10
text_size = fm.size(0, w.text())
w.setMinimumWidth(text_size.width() + magic_number)
return w
def _positions(self, option, qidx):
fm = QFontMetrics(option.font)
txt = u'%s' % qidx.data()
if not txt.startswith('['):
return
tags = literal_eval(txt)
for tag in tags:
sz = fm.size(Qt.TextSingleLine, tag)
yield sz, tag
def cellSize(self, leafIndex: QModelIndex, hv: QHeaderView,
styleOptions: QStyleOptionHeader) -> QSize:
res = QSize()
variant = leafIndex.data(Qt.SizeHintRole)
if variant:
res = variant
fnt = QFont(hv.font())
var = leafIndex.data(Qt.FontRole)
if var:
fnt = var
fnt.setBold(True)
fm = QFontMetrics(fnt)
size = QSize(
fm.size(0, leafIndex.data(Qt.DisplayRole)) +
QSize(4, 0)) # WA: add more horizontal size (4px)
if leafIndex.data(Qt.UserRole):
size.transpose()
decorationsSize = QSize(hv.style().sizeFromContents(
QStyle.CT_HeaderSection, styleOptions, QSize(), hv))
emptyTextSize = QSize(fm.size(0, ""))
return res.expandedTo(size + decorationsSize - emptyTextSize)
def __init__(self, text):
super().__init__()
self.append(text)
self.setReadOnly(True)
self.setLineWrapMode(True)
font = self.document().defaultFont()
fontMetrics = QFontMetrics(font)
textSize = fontMetrics.size(0, text)
self.textHeight = textSize.height() + 15
self.setFixedHeight(self.textHeight)
def sizeHint(self, option, qidx):
tags = qidx.sibling(qidx.row(), 0).data(qidx.model().ThreadTagsRole)
fm = QFontMetrics(option.font)
x = self.xmargin
y = 0
for sz, tag in self._positions(option, tags):
x += sz.width() + self.xmargin + 2 * self.xpadding
y = self.ymargin * 2 + fm.height()
x += fm.size(Qt.TextSingleLine, qidx.data()).width()
return QSize(x, y)
def __init__(self, text):
super().__init__()
self.append(text)
self.setReadOnly(True)
self.setLineWrapMode(True)
font = self.document().defaultFont()
fontMetrics = QFontMetrics(font)
textSize = fontMetrics.size(0, text)
self.textHeight = textSize.height() + 50
self.setFixedHeight(self.textHeight)
self.setStyleSheet(
'QWidget {border-bottom: 22px solid #333333;padding: 3;}')
def size_changed(self):
font = self.document().defaultFont()
fontMetrics = QFontMetrics(font)
textSize = fontMetrics.size(0, self.toPlainText())
w = textSize.width() + 10
row_count = 1
while w > self._max_width:
row_count += 1
w -= self._max_width
h = (textSize.height() + 4) * row_count + 4
self.setMinimumSize(w, h)
self.setMaximumSize(self._max_width, h)
self.resize(self._max_width, h)
self.contentsMargins().setLeft(10)
self.contentsMargins().setRight(10)
def __init__(self, text, parent):
QLabel.__init__(self, parent=parent)
font = QFont()
metric = QFontMetrics(font)
size = metric.size(Qt.TextSingleLine, text)
image = QImage(size.width() + 12,
size.height() + 12, QImage.Format_ARGB32_Premultiplied)
image.fill(QColor(0, 0, 0, 0))
font.setStyleStrategy(QFont.ForceOutline)
gradient = QLinearGradient(0, 0, 0, image.height() - 1)
gradient.setColorAt(0.0, Qt.white)
gradient.setColorAt(0.2, QColor(200, 200, 255))
gradient.setColorAt(0.8, QColor(200, 200, 255))
gradient.setColorAt(1.0, QColor(127, 127, 200))
painter = QPainter()
painter.begin(image)
painter.setRenderHint(QPainter.Antialiasing)
painter.setBrush(gradient)
painter.drawRoundedRect(
QRectF(0.5, 0.5,
image.width() - 1,
image.height() - 1), 25, 25, Qt.RelativeSize)
painter.setFont(font)
painter.setBrush(Qt.black)
painter.drawText(QRect(QPoint(6, 6), size),
Qt.AlignCenter | Qt.AlignVCenter, text)
painter.end()
self.setPixmap(QPixmap.fromImage(image))
self._label_text = text
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setFont(self.__font)
painter.setPen(self.__pen_line)
metrics = QFontMetrics(self.__font)
# text_height = metrics.height()
text_width = max(
metrics.size(Qt.TextExpandTabs, name).width()
for name in self.__names) * 1.2
self.__item_width = self.width() / float(len(self.__names))
# self.__item_height = 2.5 * text_height
self.__item_height = self.frameGeometry().height(
) # modified to auto-fit height from layout
for i, name in enumerate(self.__names):
if self.__availables[i]:
color = self.__color_unselected
else:
color = self.__color_notavailable
if i == 0:
if len(self.__names) == 1:
self.__paintOnlyOne(painter, color)
else:
self.__paintStart(painter, color)
elif i == len(self.__names) - 1:
self.__paintStop(painter, self.__item_width * i, color)
else:
self.__paintMiddle(painter, self.__item_width * i, color)
if self.__selected is not None:
if self.__mode == 'stop':
pos_x = self.__selected * self.__item_width
if self.__selected == 0:
if len(self.__names) == 1:
self.__paintOnlyOne(painter, self.__color_selected)
else:
self.__paintStart(painter, self.__color_selected)
elif self.__selected == len(self.__names) - 1:
self.__paintStop(painter,
self.__item_width * self.__selected,
self.__color_selected)
else:
self.__paintMiddle(painter,
self.__item_width * self.__selected,
self.__color_selected)
else:
self.__paintMiddle(painter, self.__pos, self.__color_selected)
painter.setPen(self.__pen_text)
for i, name in enumerate(self.__names):
if i == self.__selected:
painter.setPen(self.__textColor_selected)
else:
painter.setPen(self.__textColor_unselected)
painter.drawText(
QRect(self.__item_width * i, 0, self.__item_width,
self.__item_height), Qt.AlignCenter, name)
painter.end()
self.setMinimumHeight(self.__item_height)
self.setMinimumWidth(text_width * len(self.__names))
def __init__(self, *args, **kwargs):
super(KwWorkFontDialog, self).__init__(*args, **kwargs)
#fontIds = []
#for font_fname in free_font_path_generator():
# fontIds = QFontDatabase.addApplicationFont(font_fname)
#QFontDatabase.removeAllApplicationFonts()
fontFreeFilterChecker = QCheckBox(u'Вільні')
fontNoFreeFilterChecker = QCheckBox(u'Невільні')
fontRating5FilterChecker = QCheckBox(u'Найкращі')
fontRating4FilterChecker = QCheckBox(u'Добрі')
fontRating3FilterChecker = QCheckBox(u'Задовільні')
fontUseStrict_FilterChecker = QCheckBox(u'Діловодство, наука')
fontUseWriting_FilterChecker = QCheckBox(u'Рукопис')
fontUseFantasy_FilterChecker = QCheckBox(u'Декорації, реклама')
fontFamilyListView = QListView()
fontFamilyListView.setMinimumWidth(250)
#fontFamilyModel = QStringListModel([str(fontDatabase.sty)])
fontStyleListView = QListView()
fontStyleListView.setFixedWidth(150)
fontSizeListView = QListView()
fontSizeListView.setFixedWidth(60)
fontSizeModel = QStringListModel([
str(v) for v in (6, 7, 8, 9, 10, 11, 12, 14, 16, 18, 20, 22, 24,
26, 28, 36, 48, 72)
])
fontSizeListView.setModel(fontSizeModel)
fontSizeListView.setEditTriggers(QAbstractItemView.NoEditTriggers)
fontSampleWidget = QLabel(u'ІіЇїРр')
fontSampleWidget.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
fontSampleWidget.setStyleSheet(r'''QLabel {
font: normal normal 72pt "Consolas";
padding: 3px;
qproperty-alignment: AlignCenter;
color: black;
background-color: white;
}''')
sampleGroup = QGroupBox(u'Зразок:')
sampleLayout = QHBoxLayout(sampleGroup)
sampleLayout.addWidget(fontSampleWidget)
fontFilterLayout = QHBoxLayout()
fontAccessFilterGroup = QGroupBox(u'Доступність:')
fontAccessFilterLayout = QVBoxLayout(fontAccessFilterGroup)
fontAccessFilterLayout.addWidget(fontFreeFilterChecker)
fontAccessFilterLayout.addWidget(fontNoFreeFilterChecker)
fontAccessFilterLayout.addStretch()
fontFilterLayout.addWidget(fontAccessFilterGroup)
fontUseFilterGroup = QGroupBox(u'Призначення:')
fontUseFilterLayout = QVBoxLayout(fontUseFilterGroup)
fontUseFilterLayout.addWidget(fontUseStrict_FilterChecker)
fontUseFilterLayout.addWidget(fontUseWriting_FilterChecker)
fontUseFilterLayout.addWidget(fontUseFantasy_FilterChecker)
fontFilterLayout.addWidget(fontUseFilterGroup)
fontRatingFilterGroup = QGroupBox(u'Оцінка:')
fontRatingFilterLayout = QVBoxLayout(fontRatingFilterGroup)
fontRatingFilterLayout.addWidget(fontRating5FilterChecker)
fontRatingFilterLayout.addWidget(fontRating4FilterChecker)
fontRatingFilterLayout.addWidget(fontRating3FilterChecker)
fontFilterLayout.addWidget(fontRatingFilterGroup)
fontLayout = QGridLayout()
familyLayout = QVBoxLayout()
familyLayout.setSpacing(3)
familyLayout.addWidget(QLabel(u'Шрифт:'))
familyLayout.addWidget(fontFamilyListView)
fontLayout.addLayout(familyLayout, 0, 0)
styleLayout = QVBoxLayout()
styleLayout.setSpacing(3)
styleLayout.addWidget(QLabel(u'Стиль:'))
styleLayout.addWidget(fontStyleListView)
fontLayout.addLayout(styleLayout, 0, 1)
sizeLayout = QVBoxLayout()
sizeLayout.setSpacing(3)
sizeLayout.addWidget(QLabel(u'Розмір:'))
sizeLayout.addWidget(fontSizeListView)
fontLayout.addLayout(sizeLayout, 0, 2)
fontLayout.addWidget(sampleGroup, 1, 0, 1, 3)
bbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
layout = QVBoxLayout(self)
testButton = QPushButton(u'Тестова: відкрити шрифт')
testButton.clicked.connect(lambda: QFontDialog.getFont())
layout.addWidget(testButton)
layout.addLayout(fontFilterLayout)
layout.addLayout(fontLayout)
layout.addSpacing(5)
layout.addWidget(bbox)
self.setWindowTitle(u'Вибір шрифта')
self.setWindowFlags(self.windowFlags()
^ Qt.WindowContextHelpButtonHint)
# Налаштування.
fontMaxPointSize = fontSizeListView.font()
# print(QFontDatabase.families())
fontMaxPointSize.setPointSize(72)
fm = QFontMetrics(fontMaxPointSize)
fontSampleWidget.setMinimumHeight(
fm.size(Qt.TextSingleLine
| Qt.TextShowMnemonic, u'Їр').height())
fontSizeListView.setCurrentIndex(
fontSizeModel.match(fontSizeModel.index(0, 0), Qt.DisplayRole,
fontSizeListView.font().pointSize())[0])
fontFreeFilterChecker.setChecked(True)
fontUseStrict_FilterChecker.setChecked(True)
fontRating5FilterChecker.setChecked(True)
fontRating4FilterChecker.setChecked(True)
def __init__(self, pathYaml, nameclass, ports, parent=None):
super(chOptions, self).__init__(parent)
doc = "No description"
# try:
# if '_' in nameclass:
# firstAttr = nameclass[0:nameclass.index("_")]
# secondAttr = nameclass[nameclass.index("_") + 1:]
# TxtToExecute = firstAttr + "." + secondAttr + "().help(True)"
# else:
# firstAttr = nameclass
# secondAttr = ''
# TxtToExecute = firstAttr + ".help(True)"
# TxtToImport = "from nipype.interfaces import " + firstAttr
# exec(TxtToImport)
# doc = eval(TxtToExecute)
# doc = doc[doc.index('[Optional]') + 11:doc.index('Outputs')]
# except Exception as e:
# doc = "No description"
self.nameclass = nameclass
self.poqs = ports
self.labels_inputs = self.poqs[0]
self.values_inputs = self.poqs[1]
self.setWindowTitle(nameclass)
self.setWindowFlags(self.windowFlags()
& QtCore.Qt.WindowCloseButtonHint)
menubar = QMenuBar()
checkAll = QAction('Check all options', self)
checkAll.setShortcut('Ctrl+A')
menubar.addAction(checkAll)
checkAll.triggered.connect(self.checkAllOptions)
uncheckAll = QAction('Uncheck all options', self)
uncheckAll.setShortcut('Ctrl+U')
menubar.addAction(uncheckAll)
uncheckAll.triggered.connect(self.uncheckAllOptions)
self.listCh = []
listLabels = []
vbox = QVBoxLayout(self)
vbox.addWidget(menubar)
_ss = ports
self.list1 = []
self.list2 = []
self.list3 = []
for tr in _ss[0]:
self.list1.append(tr)
for tr in _ss[1]:
self.list2.append(tr)
self.list3.append(tr)
scrolllayout = QVBoxLayout()
scrollwidget = QWidget()
scrollwidget.setLayout(scrolllayout)
scroll = QScrollArea()
scroll.setWidgetResizable(True)
scroll.setWidget(scrollwidget)
desc = QTextEdit()
desc.setPlainText(doc)
desc.setReadOnly(True)
desc.setLineWrapMode(True)
font = desc.document().defaultFont()
fontMetrics = QFontMetrics(font)
textSize = fontMetrics.size(0, doc)
textWidth = textSize.width() + 30
textHeight = textSize.height() + 30
desc.setMinimumSize(textWidth, textHeight)
desc.resize(textWidth, textHeight)
hbox2 = QHBoxLayout()
vbox2 = QVBoxLayout()
with open(pathYaml, 'r', encoding='utf8') as stream:
try:
self.dicts = yaml.load(stream, yaml.FullLoader)
for el in self.dicts[nameclass]:
checkedTo = False
enableTo = True
if el in self.list1:
ind = self.list1.index(el)
self.list1.remove(el)
if 'Node(' in str(self.list2[ind]):
enableTo = False
vals = self.list2[ind]
del self.list2[ind]
del self.list3[ind]
checkedTo = True
b = QCheckBox(el, self)
b.setChecked(checkedTo)
b.setEnabled(enableTo)
self.listCh.append(b)
listLabels.append(b.text())
vbox2.addWidget(self.listCh[-1])
except Exception as exc:
print('yamlerror', exc)
return
with open(pathYaml, 'r', encoding='utf8') as stream:
rd = stream.readlines()
rd = rd[rd.index(nameclass + ":\n") + 1:]
# rd = rd[:len(self.listCh)]
doc = ''
n = len(listLabels)
for lst in rd:
tmp = ''
try:
tmp = lst.rstrip()
tmp = tmp[:tmp.index('#')]
tmp = tmp[:tmp.index(':')]
if n == 0:
break
if tmp.strip() in listLabels:
n = n - 1
doc = doc + "<br><span style=\" font-size:10pt; font-weight:600; color:#222222;\" >" + tmp + " : </span><br>"
except Exception as e:
pass
comm = ''
try:
comm = lst[lst.index('#') + 1:]
doc = doc + "<span style=\" font-size:10pt; font-weight:600; color:#2222ee;\" >" + comm + "</span><br>"
except Exception as e:
pass
# if len(comm) != 0:
if len(doc) != 0:
desc.clear()
desc.append(doc)
hbox2.addLayout(vbox2)
hbox2.addWidget(desc)
scrolllayout.addLayout(hbox2)
vbox.addWidget(scroll)
buttonOk = QPushButton('Ok', self)
buttonCancel = QPushButton('Cancel', self)
hboxButton = QHBoxLayout()
hboxButton.addWidget(buttonOk)
hboxButton.addWidget(buttonCancel)
vbox.addLayout(hboxButton)
self.setMinimumWidth(800)
buttonOk.clicked.connect(self.go)
buttonCancel.clicked.connect(self.CANCEL)
def _set_render_parameters(self):
# get size of widget
size = self.size()
w = size.width()
h = size.height()
# starting coordinates of drawing
# TODO: modify for horizontal/vertical alignment
#-----------------------------------------------------------------------
widget_x = 0.0
widget_y = 0.0
# x-axis tick labels
#-----------------------------------------------------------------------
labelFontMetrics = QFontMetrics(self._labelFont)
xaxis_min = min(self._xMin, self._xMax)
xaxis_max = max(self._xMin, self._xMax)
self._xaxis_ticks_value = []
self._xaxis_ticks_text_size = []
tick_value = self._xOriginValue
while tick_value < xaxis_max:
if tick_value > xaxis_min:
self._xaxis_ticks_value.append(tick_value)
tick_text = "{:.1f}".format(tick_value)
self._xaxis_ticks_text_size.append(
labelFontMetrics.size(Qt.TextSingleLine, tick_text))
tick_value += self._xTickInterval
tick_value = self._xOriginValue - self._xTickInterval
while tick_value > xaxis_min:
if tick_value < xaxis_max:
self._xaxis_ticks_value.append(tick_value)
tick_text = "{:.1f}".format(tick_value)
self._xaxis_ticks_text_size.append(
labelFontMetrics.size(Qt.TextSingleLine, tick_text))
tick_value -= self._xTickInterval
xaxis_ticks_text_max_height = max(
[s.height() for s in self._xaxis_ticks_text_size])
xaxis_ticks_text_max_width = max(
[s.width() for s in self._xaxis_ticks_text_size])
# y-axis tick labels
#-----------------------------------------------------------------------
yaxis_min = min(self._yMin, self._yMax)
yaxis_max = max(self._yMin, self._yMax)
self._yaxis_ticks_value = []
self._yaxis_ticks_text_size = []
tick_value = self._yOriginValue
while tick_value < yaxis_max:
if tick_value > yaxis_min:
self._yaxis_ticks_value.append(tick_value)
tick_text = "{:.1f}".format(tick_value)
self._yaxis_ticks_text_size.append(
labelFontMetrics.size(Qt.TextSingleLine, tick_text))
tick_value += self._yTickInterval
tick_value = self._yOriginValue - self._yTickInterval
while tick_value > yaxis_min:
if tick_value < yaxis_max:
self._yaxis_ticks_value.append(tick_value)
tick_text = "{:.1f}".format(tick_value)
self._yaxis_ticks_text_size.append(
labelFontMetrics.size(Qt.TextSingleLine, tick_text))
tick_value -= self._yTickInterval
yaxis_ticks_text_max_height = max(
[s.height() for s in self._yaxis_ticks_text_size])
yaxis_ticks_text_max_width = max(
[s.width() for s in self._yaxis_ticks_text_size]) * 1.1
# axes
#-----------------------------------------------------------------------
self._axes_tick_pen = QPen(Qt.black, 1.0, Qt.DashLine)
self._axes_tick_brush = QBrush(Qt.NoBrush)
#self._axes_origin_pen = QPen(Qt.black, 2.0, Qt.DashDotLine)
self._axes_origin_pen = QPen(Qt.black, 2.0, Qt.SolidLine)
self._axes_origin_brush = QBrush(Qt.NoBrush)
# bounding box for plot
#-----------------------------------------------------------------------
self._bbox_pen = QPen(Qt.black, 1.0)
self._bbox_brush = QBrush(Qt.NoBrush)
self._bbox_x0 = widget_x + yaxis_ticks_text_max_width
self._bbox_x1 = w - 1
self._bbox_y0 = widget_y
self._bbox_y1 = h - xaxis_ticks_text_max_height - 1
self._bbox_rect = QRectF(QPointF(self._bbox_x0, self._bbox_y0),
QPointF(self._bbox_x1, self._bbox_y1))
# origin lines
#-----------------------------------------------------------------------
self._xaxis_origin_x = map_value_to_scale(self._xOriginValue,
self._xMin, self._xMax,
self._bbox_x0, self._bbox_x1)
self._xaxis_origin_line = QLineF(
QPointF(self._xaxis_origin_x, self._bbox_y0),
QPointF(self._xaxis_origin_x, self._bbox_y1))
self._yaxis_origin_y = map_value_to_scale(self._yOriginValue,
self._yMin, self._yMax,
self._bbox_y1, self._bbox_y0)
self._yaxis_origin_line = QLineF(
QPointF(self._bbox_x0, self._yaxis_origin_y),
QPointF(self._bbox_x1, self._yaxis_origin_y))
# x-axis ticks
#-----------------------------------------------------------------------
self._xaxis_ticks = []
self._xaxis_ticks_text = []
self._xaxis_ticks_text_rect = []
for tick_value in self._xaxis_ticks_value:
# define the tick lines to draw
tick_x = map_value_to_scale(tick_value, self._xMin, self._xMax,
self._bbox_x0, self._bbox_x1)
tick_line = QLineF(QPointF(tick_x, self._bbox_y0),
QPointF(tick_x, self._bbox_y1))
self._xaxis_ticks.append(tick_line)
# define the tick labels to draw
tick_text = "{:.1f}".format(tick_value)
tick_size = labelFontMetrics.size(Qt.TextSingleLine, tick_text)
tick_rect = QRectF(
QPointF(tick_x - (tick_size.width() / 2.0), self._bbox_y1),
QSizeF(tick_size))
self._xaxis_ticks_text.append(tick_text)
self._xaxis_ticks_text_rect.append(tick_rect)
# y-axis ticks
#-----------------------------------------------------------------------
self._yaxis_ticks = []
self._yaxis_ticks_text = []
self._yaxis_ticks_text_rect = []
for tick_value in self._yaxis_ticks_value:
# define the tick lines to draw
tick_y = map_value_to_scale(tick_value, self._yMin, self._yMax,
self._bbox_y1, self._bbox_y0)
tick_line = QLineF(QPointF(self._bbox_x0, tick_y),
QPointF(self._bbox_x1, tick_y))
self._yaxis_ticks.append(tick_line)
# define the tick labels to draw
tick_text = "{:.1f}".format(tick_value)
tick_size = labelFontMetrics.size(Qt.TextSingleLine, tick_text)
tick_rect = QRectF(
QPointF(widget_x, tick_y - (tick_size.height() / 2.0)),
QSizeF(yaxis_ticks_text_max_width, tick_size.height()))
self._yaxis_ticks_text.append(tick_text)
self._yaxis_ticks_text_rect.append(tick_rect)
# define plot traces
#-----------------------------------------------------------------------
for plot_key in self._plots.keys():
self._plot_points[plot_key] = []
for plot_value in self._plots[plot_key]:
plot_value_x = map_value_to_scale(plot_value[0], self._xMin,
self._xMax, self._bbox_x0,
self._bbox_x1)
plot_value_y = map_value_to_scale(plot_value[1], self._yMin,
self._yMax, self._bbox_y1,
self._bbox_y0)
self._plot_points[plot_key].append(
QPointF(plot_value_x, plot_value_y))
def _set_render_parameters(self):
# get size of widget
size = self.size()
w = size.width()
h = size.height()
# starting coordinates of drawing
# TODO: modify for horizontal/vertical alignment
#-----------------------------------------------------------------------
widget_x = 0.0
widget_y = 0.0
# x-axis tick labels
#-----------------------------------------------------------------------
labelFontMetrics = QFontMetrics(self._labelFont);
xaxis_min = min(self._xMin, self._xMax)
xaxis_max = max(self._xMin, self._xMax)
self._xaxis_ticks_value = []
self._xaxis_ticks_text_size = []
tick_value = self._xOriginValue
while tick_value < xaxis_max:
if tick_value > xaxis_min:
self._xaxis_ticks_value.append(tick_value)
tick_text = "{:.1f}".format(tick_value)
self._xaxis_ticks_text_size.append(labelFontMetrics.size(Qt.TextSingleLine, tick_text))
tick_value += self._xTickInterval
tick_value = self._xOriginValue - self._xTickInterval
while tick_value > xaxis_min:
if tick_value < xaxis_max:
self._xaxis_ticks_value.append(tick_value)
tick_text = "{:.1f}".format(tick_value)
self._xaxis_ticks_text_size.append(labelFontMetrics.size(Qt.TextSingleLine, tick_text))
tick_value -= self._xTickInterval
xaxis_ticks_text_max_height = max([s.height() for s in self._xaxis_ticks_text_size])
xaxis_ticks_text_max_width = max([s.width() for s in self._xaxis_ticks_text_size])
# y-axis tick labels
#-----------------------------------------------------------------------
yaxis_min = min(self._yMin, self._yMax)
yaxis_max = max(self._yMin, self._yMax)
self._yaxis_ticks_value = []
self._yaxis_ticks_text_size = []
tick_value = self._yOriginValue
while tick_value < yaxis_max:
if tick_value > yaxis_min:
self._yaxis_ticks_value.append(tick_value)
tick_text = "{:.1f}".format(tick_value)
self._yaxis_ticks_text_size.append(labelFontMetrics.size(Qt.TextSingleLine, tick_text))
tick_value += self._yTickInterval
tick_value = self._yOriginValue - self._yTickInterval
while tick_value > yaxis_min:
if tick_value < yaxis_max:
self._yaxis_ticks_value.append(tick_value)
tick_text = "{:.1f}".format(tick_value)
self._yaxis_ticks_text_size.append(labelFontMetrics.size(Qt.TextSingleLine, tick_text))
tick_value -= self._yTickInterval
yaxis_ticks_text_max_height = max([s.height() for s in self._yaxis_ticks_text_size])
yaxis_ticks_text_max_width = max([s.width() for s in self._yaxis_ticks_text_size]) * 1.1
# axes
#-----------------------------------------------------------------------
self._axes_tick_pen = QPen(Qt.black, 1.0, Qt.DashLine)
self._axes_tick_brush = QBrush(Qt.NoBrush)
#self._axes_origin_pen = QPen(Qt.black, 2.0, Qt.DashDotLine)
self._axes_origin_pen = QPen(Qt.black, 2.0, Qt.SolidLine)
self._axes_origin_brush = QBrush(Qt.NoBrush)
# bounding box for plot
#-----------------------------------------------------------------------
self._bbox_pen = QPen(Qt.black, 1.0)
self._bbox_brush = QBrush(Qt.NoBrush)
self._bbox_x0 = widget_x + yaxis_ticks_text_max_width
self._bbox_x1 = w - 1
self._bbox_y0 = widget_y
self._bbox_y1 = h - xaxis_ticks_text_max_height - 1
self._bbox_rect = QRectF(QPointF(self._bbox_x0, self._bbox_y0), QPointF(self._bbox_x1, self._bbox_y1))
# origin lines
#-----------------------------------------------------------------------
self._xaxis_origin_x = map_value_to_scale(self._xOriginValue, self._xMin, self._xMax, self._bbox_x0, self._bbox_x1)
self._xaxis_origin_line = QLineF(QPointF(self._xaxis_origin_x, self._bbox_y0), QPointF(self._xaxis_origin_x, self._bbox_y1))
self._yaxis_origin_y = map_value_to_scale(self._yOriginValue, self._yMin, self._yMax, self._bbox_y1, self._bbox_y0)
self._yaxis_origin_line = QLineF(QPointF(self._bbox_x0, self._yaxis_origin_y), QPointF(self._bbox_x1, self._yaxis_origin_y))
# x-axis ticks
#-----------------------------------------------------------------------
self._xaxis_ticks = []
self._xaxis_ticks_text = []
self._xaxis_ticks_text_rect = []
for tick_value in self._xaxis_ticks_value:
# define the tick lines to draw
tick_x = map_value_to_scale(tick_value, self._xMin, self._xMax, self._bbox_x0, self._bbox_x1)
tick_line = QLineF(QPointF(tick_x, self._bbox_y0), QPointF(tick_x, self._bbox_y1))
self._xaxis_ticks.append(tick_line)
# define the tick labels to draw
tick_text = "{:.1f}".format(tick_value)
tick_size = labelFontMetrics.size(Qt.TextSingleLine, tick_text)
tick_rect = QRectF(QPointF(tick_x - (tick_size.width() / 2.0), self._bbox_y1), QSizeF(tick_size))
self._xaxis_ticks_text.append(tick_text)
self._xaxis_ticks_text_rect.append(tick_rect)
# y-axis ticks
#-----------------------------------------------------------------------
self._yaxis_ticks = []
self._yaxis_ticks_text = []
self._yaxis_ticks_text_rect = []
for tick_value in self._yaxis_ticks_value:
# define the tick lines to draw
tick_y = map_value_to_scale(tick_value, self._yMin, self._yMax, self._bbox_y1, self._bbox_y0)
tick_line = QLineF(QPointF(self._bbox_x0, tick_y), QPointF(self._bbox_x1, tick_y))
self._yaxis_ticks.append(tick_line)
# define the tick labels to draw
tick_text = "{:.1f}".format(tick_value)
tick_size = labelFontMetrics.size(Qt.TextSingleLine, tick_text)
tick_rect = QRectF(QPointF(widget_x, tick_y - (tick_size.height() / 2.0)), QSizeF(yaxis_ticks_text_max_width, tick_size.height()))
self._yaxis_ticks_text.append(tick_text)
self._yaxis_ticks_text_rect.append(tick_rect)
# define plot traces
#-----------------------------------------------------------------------
for plot_key in self._plots.keys():
self._plot_points[plot_key] = []
for plot_value in self._plots[plot_key]:
plot_value_x = map_value_to_scale(plot_value[0], self._xMin, self._xMax, self._bbox_x0, self._bbox_x1)
plot_value_y = map_value_to_scale(plot_value[1], self._yMin, self._yMax, self._bbox_y1, self._bbox_y0)
self._plot_points[plot_key].append(QPointF(plot_value_x, plot_value_y))
def _positions(self, option, tags):
fm = QFontMetrics(option.font)
for tag in tags:
sz = fm.size(Qt.TextSingleLine, tag)
yield sz, tag
class TimedDigram(QWidget, object):
class WrongDataFormatException(Exception):
pass
def __init__(self, padding=4, y_unit="kg", y_format="{:3.0f}", *args):
super(TimedDigram, self).__init__(*args)
self.padding = padding
self.y_unit = y_unit
self.data = []
self.x_range = datetime.now(), datetime.now()
self.y_range = 0.0, 0.0
self.y_format = y_format
self.gray_line_color = QColor(140, 140, 140)
self.axis_number_color = QColor(0, 0, 0)
self.gray_pen = QPen(self.gray_line_color, 1, Qt.SolidLine)
self.text_pen = QPen(self.axis_number_color, 1, Qt.SolidLine)
self.gray_brush = QBrush(self.gray_line_color)
self.font = QFont("Helvetica", pointSize=8, weight=0, italic=False)
self.fm = QFontMetrics(self.font)
def paintEvent(self, *args):
qp = QPainter()
qp.begin(self)
qp.setRenderHint(QPainter.TextAntialiasing, True)
qp.setRenderHint(QPainter.Antialiasing, True)
self.draw(qp)
qp.end()
def draw(self, qp):
size = self.size()
self.draw_x_axis(qp, size)
self.draw_y_axis(qp, size)
def draw_x_axis(self, qp, size):
qp.setPen(self.gray_pen)
qp.setBrush(self.gray_brush)
unit_text_width = self.fm.size(Qt.TextSingleLine, self.y_unit).width()
time_text_height = self.fm.size(Qt.TextSingleLine, "12:00").height()
qp.drawLine(self.padding + unit_text_width + 1 - 4,
size.height() - time_text_height - self.padding,
size.width() - self.padding,
size.height() - time_text_height - self.padding)
polygon = QPolygon()
polygon.append(
QPoint(size.width() - self.padding,
size.height() - time_text_height - self.padding))
polygon.append(
QPoint(size.width() - self.padding - 6,
size.height() - time_text_height - self.padding + 4))
polygon.append(
QPoint(size.width() - self.padding - 6,
size.height() - time_text_height - self.padding - 4))
qp.drawPolygon(polygon, fillRule=Qt.WindingFill)
if self.x_range[1] - self.x_range[0] > timedelta(seconds=0):
self.draw_x_axis_labels(qp, size, unit_text_width,
time_text_height)
def draw_y_axis(self, qp, size):
qp.setPen(self.gray_pen)
qp.setBrush(self.gray_brush)
unit_text_width = self.fm.size(Qt.TextSingleLine, self.y_unit).width()
time_text_height = self.fm.size(Qt.TextSingleLine, "12:00").height()
qp.drawLine(self.padding + unit_text_width + 1,
size.height() - time_text_height + 4 - self.padding,
self.padding + unit_text_width + 1, self.padding)
polygon = QPolygon()
polygon.append(QPoint(self.padding + unit_text_width + 1,
self.padding))
polygon.append(
QPoint(self.padding + unit_text_width + 1 - 4, self.padding + 6))
polygon.append(
QPoint(self.padding + unit_text_width + 1 + 4, self.padding + 6))
qp.drawPolygon(polygon, fillRule=Qt.WindingFill)
if self.y_range[1] - self.y_range[0] > 0:
self.draw_y_axis_labels(qp, size, unit_text_width,
time_text_height)
qp.setFont(self.font)
qp.setPen(self.text_pen)
qp.drawText(self.padding, self.padding + 15, self.y_unit)
def draw_x_axis_labels(self, qp, size, unit_text_width, time_text_height):
qp.setFont(self.font)
available_x_distance = size.width() - self.padding - 6 - (
self.padding + unit_text_width + 1)
display_hours = (self.x_range[1] - self.x_range[0]) < timedelta(
days=1, hours=3)
if display_hours:
current_tick = datetime(year=self.x_range[0].year,
month=self.x_range[0].month,
day=self.x_range[0].day,
hour=self.x_range[0].hour + 1)
else:
current_tick = datetime(year=self.x_range[0].year,
month=self.x_range[0].month,
day=self.x_range[0].day + 1)
x_tick_pos = self.padding + unit_text_width + 1 + (
(current_tick - self.x_range[0]) /
(self.x_range[1] - self.x_range[0]) * available_x_distance)
qp.setPen(self.gray_pen)
qp.drawLine(x_tick_pos,
size.height() - time_text_height - self.padding - 3,
x_tick_pos,
size.height() - time_text_height - self.padding + 7)
qp.setPen(self.text_pen)
if display_hours:
current_text = current_tick.strftime("%H:%M")
else:
current_text = current_tick.strftime("%d.%m.")
current_text_width = self.fm.size(Qt.TextSingleLine,
current_text).width()
qp.drawText(x_tick_pos - current_text_width // 2,
size.height() - self.padding, current_text)
current_text_end = x_tick_pos + current_text_width // 2
if display_hours:
current_tick = current_tick + timedelta(hours=1)
else:
current_tick = current_tick + timedelta(days=1)
while current_tick < self.x_range[1]:
qp.setPen(self.gray_pen)
x_tick_pos = self.padding + unit_text_width + 1 + (
(current_tick - self.x_range[0]) /
(self.x_range[1] - self.x_range[0]) * available_x_distance)
if x_tick_pos - current_text_width * 1.1 > current_text_end and \
x_tick_pos + current_text_width // 2 <= size.width() - self.padding:
qp.drawLine(
x_tick_pos,
size.height() - time_text_height - self.padding - 3,
x_tick_pos,
size.height() - time_text_height - self.padding + 7)
else:
qp.drawLine(
x_tick_pos,
size.height() - time_text_height - self.padding - 3,
x_tick_pos,
size.height() - time_text_height - self.padding + 3)
if display_hours:
current_text = current_tick.strftime("%H:%M")
else:
current_text = current_tick.strftime("%d.%m.")
current_text_width = self.fm.size(Qt.TextSingleLine,
current_text).width()
if x_tick_pos - current_text_width * 1.1 > current_text_end and \
x_tick_pos + current_text_width // 2 <= size.width() - self.padding:
qp.setPen(self.text_pen)
qp.drawText(x_tick_pos - current_text_width // 2,
size.height() - self.padding, current_text)
current_text_end = x_tick_pos + current_text_width // 2
if display_hours:
current_tick = current_tick + timedelta(hours=1)
else:
current_tick = current_tick + timedelta(days=1)
def draw_y_axis_labels(self, qp, size, unit_text_width, time_text_height):
qp.setFont(self.font)
available_y_distance = size.height(
) - time_text_height + 4 - 2 * self.padding
tick_distance = ceil(time_text_height *
(self.y_range[1] - self.y_range[0]) /
available_y_distance)
current_tick = ceil(self.y_range[0])
y_tick_pos = size.height() - time_text_height - self.padding - (
current_tick - self.y_range[0]) / (
self.y_range[1] - self.y_range[0]) * available_y_distance
current_text = self.y_format.format(current_tick)
current_text_size = self.fm.size(Qt.TextSingleLine, current_text)
qp.setPen(self.gray_pen)
qp.drawLine(self.padding + unit_text_width + 1 - 3, y_tick_pos,
self.padding + unit_text_width + 1 + 3, y_tick_pos)
qp.setPen(self.text_pen)
qp.drawText(
self.padding + unit_text_width + 1 - 3 - current_text_size.width(),
y_tick_pos + current_text_size.height() / 4, current_text)
current_tick_end = y_tick_pos - current_text_size.height() / 2
current_tick = current_tick + tick_distance
while current_tick < self.y_range[1]:
qp.setPen(self.gray_pen)
y_tick_pos = size.height(
) - time_text_height + 4 - self.padding - (
current_tick - self.y_range[0]) / (
self.y_range[1] - self.y_range[0]) * available_y_distance
current_text = self.y_format.format(current_tick)
current_text_size = self.fm.size(Qt.TextSingleLine, current_text)
qp.setPen(self.gray_pen)
if current_tick_end >= y_tick_pos - current_text_size.height(
) // 2 > self.padding + 15:
qp.drawLine(self.padding + unit_text_width + 1 - 3, y_tick_pos,
self.padding + unit_text_width + 1 + 3, y_tick_pos)
qp.setPen(self.text_pen)
qp.drawText(
self.padding + unit_text_width + 1 - 3 -
current_text_size.width(),
y_tick_pos + current_text_size.height() / 4, current_text)
current_tick_end = y_tick_pos - current_text_size.height() / 2
else:
qp.drawLine(self.padding + unit_text_width + 1 - 3, y_tick_pos,
self.padding + unit_text_width + 1 + 3, y_tick_pos)
current_tick = current_tick + tick_distance
class PFSActivity(PFSActive):
def __init__(self, id: str, x: int, y: int, text: str="Atividade"):
PFSActive.__init__(self, id, x, y)
self._subPage = None
self._textFont = QFont("Helvetica", 15)
self._fontMetrics = QFontMetrics(self._textFont)
self._minWidth = 0
self._minHeight = 0
self.setText(text)
self._width = self._minWidth
self._height = self._minHeight
self._inputNum = 1
self._outputNum = 1
self._space = 5
def inputNum(self):
return self._inputNum
def outputNum(self):
return self._outputNum
def copy(self, x, y):
ans = PFSActivityContent()
ans._id = self._id
ans._x = self.x() - x
ans._y = self.y() - y
ans._text = self._text
ans._width = self._width
ans._height = self._height
ans._textFont = self._textFont
ans._fontMetrics = self._fontMetrics
ans._pen = self._pen
ans._brush = self._brush
ans._tags = self._tags
ans._inputNum = self._inputNum
ans._outputNum = self._outputNum
return ans
def paste(content, id, dx, dy):
ans = PFSActivity(id, content._x + dx, content._y + dy, content._text)
ans._width = content._width
ans._height = content._height
ans._textFont = content._textFont
ans._fontMetrics = content._fontMetrics
ans._pen = content._pen
ans._brush = content._brush
ans._inputNum = content._inputNum
ans._outputNum = content._outputNum
for tag in content._tags:
ans.addTag(tag._name, tag._use, False)
return ans
def tree(self, parent):
tree = PFSTreeItem(parent, [self._id], 0, QIcon(PFSActivityIcon()))
tree.clicked.connect(self.selectSingle)
if self._subPage is not None:
child = self._subPage.tree(tree)
return tree
def simpleTree(self, parent):
tree = PFSTreeItem(parent, [self._id], 0, QIcon(PFSActivityIcon()))
tree.clicked.connect(self.selectSingle)
return tree
def hasSubPage(self):
return self._subPage is not None
def setSubPage(self, page):
if self._subPage is not None:
return False
self._subPage = page
return True
def removeSubPage(self):
self._subPage = None
def subPage(self):
return self._subPage
def generateXml(self, xml: QXmlStreamWriter):
PFSXmlBase.open(xml)
xml.writeStartElement("activity")
xml.writeAttribute("id", self._id)
xml.writeAttribute("inputnum", str(self._inputNum))
xml.writeAttribute("outputnum", str(self._outputNum))
PFSXmlBase.graphicsNode(xml, QRectF(self.x(), self.y(), self._width, self._height), self._pen, self._brush)
PFSXmlBase.text(xml, self._text, 0, 0, font=self._textFont, tag="text", align="center")
PFSBasicElement.generateXml(self, xml)
xml.writeEndElement() #fecha activity
PFSXmlBase.close(xml)
def createFromXml(node: QDomNode):
if node.nodeName() != "activity":
return None
if not (node.hasAttributes() and node.attributes().contains("id")):
return None
id = node.attributes().namedItem("id").nodeValue()
childs = node.childNodes()
graphics = None
text = None
if node.attributes().contains("inputnum"):
inputNum = int(node.attributes().namedItem("inputnum").nodeValue())
else:
inputNum = 1
if node.attributes().contains("outputnum"):
outputNum = int(node.attributes().namedItem("outputnum").nodeValue())
else:
outputNum = 1
tags = []
for i in range(childs.count()):
child = childs.at(i)
if child.nodeName() == "graphics":
graphics = PFSXmlBase.getNode(child)
if child.nodeName() == "text":
text = PFSXmlBase.getText(child)
if child.nodeName() == "tags":
tags = PFSBasicElement.createFromXml(child)
if graphics is not None and text is not None:
ac = PFSActivityContent()
ac._id = id
ac._x = graphics.rect.x()
ac._y = graphics.rect.y()
ac._text = text.annotation
ac._width = graphics.rect.width()
ac._height = graphics.rect.height()
if text.font is not None:
ac._textFont = text.font
ac._fontMetrics = QFontMetrics(text.font)
if graphics.line is not None:
ac._pen = graphics.line
if graphics.brush is not None:
ac._brush = graphics.brush
ac._tags = tags
ac._inputNum = inputNum
ac._outputNum = outputNum
return ac
return None
def paint(self, p: QPainter, o: QStyleOptionGraphicsItem, w: QWidget):
p.setPen(Qt.NoPen)
p.setBrush(self._brush)
rect = self.boundingRect()
p.drawRect(rect)
p.setPen(self._pen)
p.setFont(self._textFont)
p.drawText(rect, Qt.AlignCenter, self._text)
p.save()
if self.isSelected():
if self._pen.color() == PFSElement.SELECTED_PEN:
p.setPen(PFSElement.SELECTED_PEN_ALT)
else:
p.setPen(PFSElement.SELECTED_PEN)
h = (self._height -self._space*(self._inputNum-1))/self._inputNum
p.save()
p.translate(self.x(), self.y())
for i in range(self._inputNum):
p.drawLine(0, 0, 6, 0)
p.drawLine(0, h, 6, h)
p.drawLine(0, 0, 0, h)
p.translate(0, h + self._space)
p.restore()
h = (self._height -self._space*(self._outputNum-1))/self._outputNum
p.translate(self.x() + self._width, self.y())
for i in range(self._outputNum):
p.drawLine(0, 0, -6, 0)
p.drawLine(0, h, -6, h)
p.drawLine(0, 0, 0, h)
p.translate(0, h + self._space)
p.restore()
def setText(self, text: str):
self._text = text
s = self.minimunSize()
if self._width < s.width():
self._width = s.width()
if self._height < s.height():
self._height = s.height()
if self.scene() is not None:
self.scene().update()
self.changed.emit()
def setInputNum(self, text: str):
self._inputNum = int(text)
if self.scene() is not None:
self.scene().update()
self.changed.emit()
def setOutputNum(self, text: str):
self._outputNum = int(text)
if self.scene() is not None:
self.scene().update()
self.changed.emit()
def setFont(self, font: QFont):
self._textFont = font
self._fontMetrics = QFontMetrics(font)
self.scene().update()
def getText(self):
return self._text
def minimunSize(self):
s = self._fontMetrics.size(Qt.TextExpandTabs, self._text)
self._minWidth = s.width() + 15
self._minHeight = s.height() + 4
return QSizeF(self._minWidth, self._minHeight)
def boundingRect(self):
s = self.minimunSize()
width = max(self._width,s.width())
height = max(self._height,s.height())
return QRectF(self.x(), self.y(), width, height)
def getBestRelationPoint(self, p: QPointF) -> QPointF:
r = self.sceneBoundingRect()
if p.x() > r.center().x():
x = r.right()
else:
x = r.x()
y = p.y()
if p.y() < r.y():
y = r.y()
elif p.y() > r.bottom():
y = r.bottom()
return QPointF(x, y)
def getBestRelationPointInput(self, p: QPointF, i: int) -> QPointF:
r = self.sceneBoundingRect()
x = r.x()
h = (self._height - (self._inputNum - 1)*self._space)/self._inputNum
y0 = r.y() + (self._space + h)*i
y = p.y()
if y < y0:
y = y0
elif y > y0 + h:
y = y0 + h
return QPointF(x, y)
def getBestRelationPointOutput(self, p: QPointF, i: int) -> QPointF:
r = self.sceneBoundingRect()
x = r.right()
h = (self._height - (self._outputNum - 1)*self._space)/self._outputNum
y0 = r.y() + (self._space + h)*i
y = p.y()
if y < y0:
y = y0
elif y > y0 + h:
y = y0 + h
return QPointF(x, y)
def getBestRelationPointSecondary(self, p: QPointF, posX: float) -> QPointF:
r = self.sceneBoundingRect()
x = r.x() + 6 + posX/100*(self._width - 12)
y = r.y()
if p.y() > r.center().y():
y = r.bottom()
return QPointF(x, y)
def propertiesTable(self):
ans = []
lblType = PFSTableLabel("Elemento")
lblValue = PFSTableNormal("Atividade")
lblValue.setFlags(Qt.NoItemFlags)
ans.append([lblType, lblValue])
lblType = PFSTableLabel("ID")
lblValue = PFSTableNormal(self._id)
lblValue.setFlags(Qt.NoItemFlags)
ans.append([lblType, lblValue])
lblType = PFSTableLabel("Posição X")
lblValue = PFSTableValueText(str(self.x()))
lblValue.edited.connect(self.changeElementPosX)
ans.append([lblType, lblValue])
lblType = PFSTableLabel("Posição Y")
lblValue = PFSTableValueText(str(self.y()))
lblValue.edited.connect(self.changeElementPosY)
ans.append([lblType, lblValue])
lblType = PFSTableLabel("Largura")
lblValue = PFSTableValueText(str(self._width))
lblValue.edited.connect(self.changeElementWidth)
ans.append([lblType, lblValue])
lblType = PFSTableLabel("Altura")
lblValue = PFSTableValueText(str(self._height))
lblValue.edited.connect(self.changeElementHeight)
ans.append([lblType, lblValue])
lblType = PFSTableLabel("Texto")
lblValue = PFSTableValueText(self._text)
lblValue.edited.connect(self.changeText)
ans.append([lblType, lblValue])
lblType = PFSTableLabel("Fonte")
lblValue = PFSTableValueButton(self._textFont.toString())
lblValue.clicked.connect(self.changeFont)
ans.append([lblType, lblValue])
lblType = PFSTableLabel("Cor do contorno")
lblValue = PFSTableValueButton(self._pen.color().name())
lblValue.clicked.connect(self.changeLineColor)
ans.append([lblType, lblValue])
lblType = PFSTableLabel("Linha do contorno")
lblValue = PFSTableValueCombo(self.PEN_LIST, self._pen.style())
self.penEdited.connect(lblValue.updateText)
lblValue.currentTextChanged.connect(self.changeLineStyle)
ans.append([lblType, lblValue])
lblType = PFSTableLabel("Espessura do contorno")
lblValue = PFSTableValueText(str(self._pen.width()))
lblValue.edited.connect(self.changeLineWidth)
ans.append([lblType, lblValue])
lblType = PFSTableLabel("Cor do preenchimento")
lblValue = PFSTableValueButton(self._brush.color().name())
lblValue.clicked.connect(self.changeFillColor)
ans.append([lblType, lblValue])
lblType = PFSTableLabel("Entradas")
lblValue = PFSTableValueText(str(self._inputNum))
lblValue.edited.connect(self.changeInputNum)
ans.append([lblType, lblValue])
lblType = PFSTableLabel("Saídas")
lblValue = PFSTableValueText(str(self._outputNum))
lblValue.edited.connect(self.changeOutputNum)
ans.append([lblType, lblValue])
lblType = PFSTableLabelTags("Tags")
lblValue = PFSTableValueBox(self._tags, self.createTag)
ans.append([lblType, lblValue])
return ans
def changeText(self, prop):
x = PFSUndoPropertyText(prop, self.setText)
x.setText("Alterar texto")
self.scene()._page._net.undoStack.push(x)
def changeInputNum(self, prop):
x = PFSUndoPropertyText(prop, self.setInputNum)
x.setText("Alterar entradas")
self.scene()._page._net.undoStack.push(x)
def changeOutputNum(self, prop):
x = PFSUndoPropertyText(prop, self.setOutputNum)
x.setText("Alterar saídas")
self.scene()._page._net.undoStack.push(x)
def changeFont(self):
font, ans = QFontDialog.getFont(self._textFont, self.scene()._page._net, "Escolha a fonte do texto")
if ans:
x = PFSUndoPropertyButton(font, self._textFont, self.setFont)
x.setText("Alterar fonte")
self.scene()._page._net.undoStack.push(x)
def changeElementWidth(self, prop):
if float(prop.text()) > self._minWidth:
x = PFSUndoPropertyText(prop, self.resizeWidth)
x.setText("Alterar largura")
self.scene()._page._net.undoStack.push(x)
def changeElementHeight(self, prop):
if float(prop.text()) > self._minHeight:
x = PFSUndoPropertyText(prop, self.resizeHeight)
x.setText("Alterar altura")
self.scene()._page._net.undoStack.push(x)
def __init__(self, parent = None):
super(MainWindow, self).__init__(parent)
self.setWindowTitle('Basic Drawing')
self.app = QCoreApplication.instance()
self.setGeometry(self.app.myRectangle)
st = self.app.style()
self.params = (
(str(QStyle.PM_ButtonMargin), 'ButtonMargin', st.pixelMetric(QStyle.PM_ButtonMargin)),
(str(QStyle.PM_DockWidgetTitleBarButtonMargin), 'DockWidgetTitleBarButtonMargin', st.pixelMetric(QStyle.PM_DockWidgetTitleBarButtonMargin)),
(str(QStyle.PM_ButtonDefaultIndicator), 'ButtonDefaultIndicator', st.pixelMetric(QStyle.PM_ButtonDefaultIndicator)),
(str(QStyle.PM_MenuButtonIndicator), 'MenuButtonIndicator', st.pixelMetric(QStyle.PM_MenuButtonIndicator)),
(str(QStyle.PM_ButtonShiftHorizontal), 'ButtonShiftHorizontal', st.pixelMetric(QStyle.PM_ButtonShiftHorizontal)),
(str(QStyle.PM_ButtonShiftVertical), 'ButtonShiftVertical', st.pixelMetric(QStyle.PM_ButtonShiftVertical)),
(str(QStyle.PM_DefaultFrameWidth), 'DefaultFrameWidth', st.pixelMetric(QStyle.PM_DefaultFrameWidth)),
(str(QStyle.PM_SpinBoxFrameWidth), 'SpinBoxFrameWidth', st.pixelMetric(QStyle.PM_SpinBoxFrameWidth)),
(str(QStyle.PM_ComboBoxFrameWidth), 'ComboBoxFrameWidth', st.pixelMetric(QStyle.PM_ComboBoxFrameWidth)),
(str(QStyle.PM_MdiSubWindowFrameWidth), 'MdiSubWindowFrameWidth', st.pixelMetric(QStyle.PM_MdiSubWindowFrameWidth)),
(str(QStyle.PM_MdiSubWindowMinimizedWidth), 'MdiSubWindowMinimizedWidth', st.pixelMetric(QStyle.PM_MdiSubWindowMinimizedWidth)),
(str(QStyle.PM_LayoutLeftMargin), 'LayoutLeftMargin', st.pixelMetric(QStyle.PM_LayoutLeftMargin)),
(str(QStyle.PM_LayoutTopMargin), 'LayoutTopMargin', st.pixelMetric(QStyle.PM_LayoutTopMargin)),
(str(QStyle.PM_LayoutRightMargin), 'LayoutRightMargin', st.pixelMetric(QStyle.PM_LayoutRightMargin)),
(str(QStyle.PM_LayoutBottomMargin), 'LayoutBottomMargin', st.pixelMetric(QStyle.PM_LayoutBottomMargin)),
(str(QStyle.PM_LayoutHorizontalSpacing), 'LayoutHorizontalSpacing', st.pixelMetric(QStyle.PM_LayoutHorizontalSpacing)),
(str(QStyle.PM_LayoutVerticalSpacing), 'LayoutVerticalSpacing', st.pixelMetric(QStyle.PM_LayoutVerticalSpacing)),
(str(QStyle.PM_MaximumDragDistance), 'MaximumDragDistance', st.pixelMetric(QStyle.PM_MaximumDragDistance)),
(str(QStyle.PM_ScrollBarExtent), 'ScrollBarExtent', st.pixelMetric(QStyle.PM_ScrollBarExtent)),
(str(QStyle.PM_ScrollBarSliderMin), 'ScrollBarSliderMin', st.pixelMetric(QStyle.PM_ScrollBarSliderMin)),
(str(QStyle.PM_SliderThickness), 'SliderThickness', st.pixelMetric(QStyle.PM_SliderThickness)),
(str(QStyle.PM_SliderControlThickness), 'SliderControlThickness', st.pixelMetric(QStyle.PM_SliderControlThickness)),
(str(QStyle.PM_SliderLength), 'SliderLength', st.pixelMetric(QStyle.PM_SliderLength)),
(str(QStyle.PM_SliderTickmarkOffset), 'SliderTickmarkOffset', st.pixelMetric(QStyle.PM_SliderTickmarkOffset)),
(str(QStyle.PM_SliderSpaceAvailable), 'SliderSpaceAvailable', st.pixelMetric(QStyle.PM_SliderSpaceAvailable)),
(str(QStyle.PM_DockWidgetSeparatorExtent), 'DockWidgetSeparatorExtent', st.pixelMetric(QStyle.PM_DockWidgetSeparatorExtent)),
(str(QStyle.PM_DockWidgetHandleExtent), 'DockWidgetHandleExtent', st.pixelMetric(QStyle.PM_DockWidgetHandleExtent)),
(str(QStyle.PM_DockWidgetFrameWidth), 'DockWidgetFrameWidth', st.pixelMetric(QStyle.PM_DockWidgetFrameWidth)),
(str(QStyle.PM_DockWidgetTitleMargin), 'DockWidgetTitleMargin', st.pixelMetric(QStyle.PM_DockWidgetTitleMargin)),
(str(QStyle.PM_MenuBarPanelWidth), 'MenuBarPanelWidth', st.pixelMetric(QStyle.PM_MenuBarPanelWidth)),
(str(QStyle.PM_MenuBarItemSpacing), 'MenuBarItemSpacing', st.pixelMetric(QStyle.PM_MenuBarItemSpacing)),
(str(QStyle.PM_MenuBarHMargin), 'MenuBarHMargin', st.pixelMetric(QStyle.PM_MenuBarHMargin)),
(str(QStyle.PM_MenuBarVMargin), 'MenuBarVMargin', st.pixelMetric(QStyle.PM_MenuBarVMargin)),
(str(QStyle.PM_ToolBarFrameWidth), 'ToolBarFrameWidth', st.pixelMetric(QStyle.PM_ToolBarFrameWidth)),
(str(QStyle.PM_ToolBarHandleExtent), 'ToolBarHandleExtent', st.pixelMetric(QStyle.PM_ToolBarHandleExtent)),
(str(QStyle.PM_ToolBarItemMargin), 'ToolBarItemMargin', st.pixelMetric(QStyle.PM_ToolBarItemMargin)),
(str(QStyle.PM_ToolBarItemSpacing), 'ToolBarItemSpacing', st.pixelMetric(QStyle.PM_ToolBarItemSpacing)),
(str(QStyle.PM_ToolBarSeparatorExtent), 'ToolBarSeparatorExtent', st.pixelMetric(QStyle.PM_ToolBarSeparatorExtent)),
(str(QStyle.PM_ToolBarExtensionExtent), 'ToolBarExtensionExtent', st.pixelMetric(QStyle.PM_ToolBarExtensionExtent)),
(str(QStyle.PM_TabBarTabOverlap), 'TabBarTabOverlap', st.pixelMetric(QStyle.PM_TabBarTabOverlap)),
(str(QStyle.PM_TabBarTabHSpace), 'TabBarTabHSpace', st.pixelMetric(QStyle.PM_TabBarTabHSpace)),
(str(QStyle.PM_TabBarTabVSpace), 'TabBarTabVSpace', st.pixelMetric(QStyle.PM_TabBarTabVSpace)),
(str(QStyle.PM_TabBarBaseHeight), 'TabBarBaseHeight', st.pixelMetric(QStyle.PM_TabBarBaseHeight)),
(str(QStyle.PM_TabBarBaseOverlap), 'TabBarBaseOverlap', st.pixelMetric(QStyle.PM_TabBarBaseOverlap)),
(str(QStyle.PM_TabBarScrollButtonWidth), 'TabBarScrollButtonWidth', st.pixelMetric(QStyle.PM_TabBarScrollButtonWidth)),
(str(QStyle.PM_TabBarTabShiftHorizontal), 'TabBarTabShiftHorizontal', st.pixelMetric(QStyle.PM_TabBarTabShiftHorizontal)),
(str(QStyle.PM_TabBarTabShiftVertical), 'TabBarTabShiftVertical', st.pixelMetric(QStyle.PM_TabBarTabShiftVertical)),
(str(QStyle.PM_ProgressBarChunkWidth), 'ProgressBarChunkWidth', st.pixelMetric(QStyle.PM_ProgressBarChunkWidth)),
(str(QStyle.PM_SplitterWidth), 'SplitterWidth', st.pixelMetric(QStyle.PM_SplitterWidth)),
(str(QStyle.PM_TitleBarHeight), 'TitleBarHeight', st.pixelMetric(QStyle.PM_TitleBarHeight)),
(str(QStyle.PM_IndicatorWidth), 'IndicatorWidth', st.pixelMetric(QStyle.PM_IndicatorWidth)),
(str(QStyle.PM_IndicatorHeight), 'IndicatorHeight', st.pixelMetric(QStyle.PM_IndicatorHeight)),
(str(QStyle.PM_ExclusiveIndicatorWidth), 'ExclusiveIndicatorWidth', st.pixelMetric(QStyle.PM_ExclusiveIndicatorWidth)),
(str(QStyle.PM_ExclusiveIndicatorHeight), 'ExclusiveIndicatorHeight', st.pixelMetric(QStyle.PM_ExclusiveIndicatorHeight)),
(str(QStyle.PM_MenuPanelWidth), 'MenuPanelWidth', st.pixelMetric(QStyle.PM_MenuPanelWidth)),
(str(QStyle.PM_MenuHMargin), 'MenuHMargin', st.pixelMetric(QStyle.PM_MenuHMargin)),
(str(QStyle.PM_MenuVMargin), 'MenuVMargin', st.pixelMetric(QStyle.PM_MenuVMargin)),
(str(QStyle.PM_MenuScrollerHeight), 'MenuScrollerHeight', st.pixelMetric(QStyle.PM_MenuScrollerHeight)),
(str(QStyle.PM_MenuTearoffHeight), 'MenuTearoffHeight', st.pixelMetric(QStyle.PM_MenuTearoffHeight)),
(str(QStyle.PM_MenuDesktopFrameWidth), 'MenuDesktopFrameWidth', st.pixelMetric(QStyle.PM_MenuDesktopFrameWidth)),
(str(QStyle.PM_HeaderMarkSize), 'HeaderMarkSize', st.pixelMetric(QStyle.PM_HeaderMarkSize)),
(str(QStyle.PM_HeaderGripMargin), 'HeaderGripMargin', st.pixelMetric(QStyle.PM_HeaderGripMargin)),
(str(QStyle.PM_HeaderMargin), 'HeaderMargin', st.pixelMetric(QStyle.PM_HeaderMargin)),
(str(QStyle.PM_SpinBoxSliderHeight), 'SpinBoxSliderHeight', st.pixelMetric(QStyle.PM_SpinBoxSliderHeight)),
(str(QStyle.PM_ToolBarIconSize), 'ToolBarIconSize', st.pixelMetric(QStyle.PM_ToolBarIconSize)),
(str(QStyle.PM_SmallIconSize), 'SmallIconSize', st.pixelMetric(QStyle.PM_SmallIconSize)),
(str(QStyle.PM_LargeIconSize), 'LargeIconSize', st.pixelMetric(QStyle.PM_LargeIconSize)),
(str(QStyle.PM_FocusFrameHMargin), 'FocusFrameHMargin', st.pixelMetric(QStyle.PM_FocusFrameHMargin)),
(str(QStyle.PM_FocusFrameVMargin), 'FocusFrameVMargin', st.pixelMetric(QStyle.PM_FocusFrameVMargin)),
(str(QStyle.PM_IconViewIconSize), 'IconViewIconSize', st.pixelMetric(QStyle.PM_IconViewIconSize)),
(str(QStyle.PM_ListViewIconSize), 'ListViewIconSize', st.pixelMetric(QStyle.PM_ListViewIconSize)),
(str(QStyle.PM_ToolTipLabelFrameWidth), 'ToolTipLabelFrameWidth', st.pixelMetric(QStyle.PM_ToolTipLabelFrameWidth)),
(str(QStyle.PM_CheckBoxLabelSpacing), 'CheckBoxLabelSpacing', st.pixelMetric(QStyle.PM_CheckBoxLabelSpacing)),
(str(QStyle.PM_RadioButtonLabelSpacing), 'RadioButtonLabelSpacing', st.pixelMetric(QStyle.PM_RadioButtonLabelSpacing)),
(str(QStyle.PM_TabBarIconSize), 'TabBarIconSize', st.pixelMetric(QStyle.PM_TabBarIconSize)),
(str(QStyle.PM_SizeGripSize), 'SizeGripSize', st.pixelMetric(QStyle.PM_SizeGripSize)),
(str(QStyle.PM_MessageBoxIconSize), 'MessageBoxIconSize', st.pixelMetric(QStyle.PM_MessageBoxIconSize)),
(str(QStyle.PM_ButtonIconSize), 'ButtonIconSize', st.pixelMetric(QStyle.PM_ButtonIconSize)),
(str(QStyle.PM_TextCursorWidth), 'TextCursorWidth', st.pixelMetric(QStyle.PM_TextCursorWidth)),
(str(QStyle.PM_TabBar_ScrollButtonOverlap), 'TabBar_ScrollButtonOverlap', st.pixelMetric(QStyle.PM_TabBar_ScrollButtonOverlap)),
(str(QStyle.PM_TabCloseIndicatorWidth), 'TabCloseIndicatorWidth', st.pixelMetric(QStyle.PM_TabCloseIndicatorWidth)),
(str(QStyle.PM_TabCloseIndicatorHeight), 'TabCloseIndicatorHeight', st.pixelMetric(QStyle.PM_TabCloseIndicatorHeight)),
(str(QStyle.PM_ScrollView_ScrollBarSpacing), 'ScrollView_ScrollBarSpacing', st.pixelMetric(QStyle.PM_ScrollView_ScrollBarSpacing)),
(str(QStyle.PM_ScrollView_ScrollBarOverlap), 'ScrollView_ScrollBarOverlap', st.pixelMetric(QStyle.PM_ScrollView_ScrollBarOverlap)),
(str(QStyle.PM_SubMenuOverlap), 'SubMenuOverlap', st.pixelMetric(QStyle.PM_SubMenuOverlap)),
(str(QStyle.PM_TreeViewIndentation), 'TreeViewIndentation', st.pixelMetric(QStyle.PM_TreeViewIndentation)),
(str(QStyle.PM_HeaderDefaultSectionSizeHorizontal), 'HeaderDefaultSectionSizeHorizontal', st.pixelMetric(QStyle.PM_HeaderDefaultSectionSizeHorizontal)),
(str(QStyle.PM_HeaderDefaultSectionSizeVertical), 'HeaderDefaultSectionSizeVertical', st.pixelMetric(QStyle.PM_HeaderDefaultSectionSizeVertical)),
(str(QStyle.PM_CustomBase), 'CustomBase', st.pixelMetric(QStyle.PM_CustomBase))
)
self.tw = QTableWidget(len(self.params), 3)
vh = self.tw.verticalHeader()
print(vh.sectionSize(0))
# vh.setSectionResizeMode(QHeaderView.Fixed)
# vh.setDefaultSectionSize(30)
for i in range(len(self.params)):
item1 = QTableWidgetItem (self.params[i][0])
item2 = QTableWidgetItem (str(self.params[i][1]))
item3 = QTableWidgetItem (str(self.params[i][2]))
self.tw.setItem(i, 0, item1)
self.tw.setItem(i, 1, item2)
self.tw.setItem(i, 2, item3)
self.setCentralWidget(self.tw)
#fm = QFontMetrics(self.tw.font())
fm = QFontMetrics(self.tw.item(1,1).font())
#fm = self.tw.fontMetrics()
strin = ''
length = 0
for param in self.params:
l = fm.size(1, self.tr(param[1])).width()
if l > length:
length = l
strin = self.tr(param[1])
print('MaxWidth: {0}, for string: {1}'.format(length, strin))
self.tw.setColumnWidth(1, length)
appFont = self.app.font()
cellFont = self.tw.item(1,1).font()
tableFont = self.tw.font()
print(appFont)
print(cellFont)
print(tableFont)
print(fm)
