def getFontFromCmnd(self, fontinfo):
'''
Returns a QFont based on the information in the dictionary
fontinfo.
Recognized keys in the font dictionary are:
"family": font family name (string)
"size": text size in points (1/72 inches)
"italic": italicize? (False/True)
"bold": make bold? (False/True)
"underline": underline? (False/True)
'''
try:
myfont = QFont(fontinfo["family"])
except KeyError:
myfont = self.__viewer.font()
try:
myfont.setPointSizeF(fontinfo["size"])
except KeyError:
pass
try:
myfont.setItalic(fontinfo["italic"])
except KeyError:
pass
try:
myfont.setBold(fontinfo["bold"])
except KeyError:
pass
try:
myfont.setUnderline(fontinfo["underline"])
except KeyError:
pass
return myfont
def set_gui(self, qfont: QFont):
self.setText(qfont.family() + " " +
_format_font_size(qfont.pointSizeF()))
preview_font = QFont(qfont)
preview_font.setPointSizeF(self.font().pointSizeF())
self.setFont(preview_font)
def pixmap(cursor, num_lines=6, scale=0.8):
"""Return a QPixmap displaying the selected lines of the document.
If the cursor has no selection, num_lines are drawn.
By default the text is drawn 0.8 * the normal font size. You can change
that by supplying the scale parameter.
"""
block = cursor.document().findBlock(cursor.selectionStart())
c2 = QTextCursor(block)
if cursor.hasSelection():
c2.setPosition(cursor.selectionEnd(), QTextCursor.KeepAnchor)
c2.movePosition(QTextCursor.EndOfBlock, QTextCursor.KeepAnchor)
else:
c2.movePosition(QTextCursor.NextBlock, QTextCursor.KeepAnchor,
num_lines)
data = textformats.formatData('editor')
doc = QTextDocument()
font = QFont(data.font)
font.setPointSizeF(font.pointSizeF() * scale)
doc.setDefaultFont(font)
doc.setPlainText(c2.selection().toPlainText())
if metainfo.info(cursor.document()).highlighting:
highlighter.highlight(doc, state=tokeniter.state(block))
size = doc.size().toSize() + QSize(8, -4)
pix = QPixmap(size)
pix.fill(data.baseColors['background'])
doc.drawContents(QPainter(pix))
return pix
def labelLines(self, img: Optional[QPixmap], toSrc: bool):
if not img or not self.lines:
return None
painter = QPainter()
painter.begin(img)
painter.setRenderHint(QPainter.Antialiasing, True)
pen = QPen()
pen.setCapStyle(Qt.RoundCap)
font = QFont('Consolas')
if toSrc:
pen.setWidthF(config.lineWidth * self.ratioToSrc)
font.setPointSizeF(config.fontSize * self.ratioToSrc)
else:
pen.setWidthF(config.lineWidth)
font.setPointSizeF(config.fontSize)
painter.setFont(font)
for (indexA, indexB), color in self.lines.items():
isHighlight = indexA in self.highlightPoints and indexB in self.highlightPoints \
and (self.mode == LabelMode.AngleMode or self.mode == LabelMode.VerticalMode)
pen.setColor(QColor.lighter(color) if isHighlight else color)
painter.setPen(pen)
A = self.points[indexA][0]
B = self.points[indexB][0]
srcA = self.getSrcPoint(A)
srcB = self.getSrcPoint(B)
labelPoint: QPointF
if toSrc:
painter.drawLine(srcA, srcB)
labelPoint = static.getMidpoint(srcA, srcB)
else:
painter.drawLine(A, B)
labelPoint = static.getMidpoint(A, B)
painter.drawText(static.getDistanceShift(A, B, labelPoint), str(round(static.getDistance(srcA, srcB), 2)))
painter.end()
def pixmap(cursor, num_lines=6, scale=0.8):
"""Return a QPixmap displaying the selected lines of the document.
If the cursor has no selection, num_lines are drawn.
By default the text is drawn 0.8 * the normal font size. You can change
that by supplying the scale parameter.
"""
block = cursor.document().findBlock(cursor.selectionStart())
c2 = QTextCursor(block)
if cursor.hasSelection():
c2.setPosition(cursor.selectionEnd(), QTextCursor.KeepAnchor)
c2.movePosition(QTextCursor.EndOfBlock, QTextCursor.KeepAnchor)
else:
c2.movePosition(QTextCursor.NextBlock, QTextCursor.KeepAnchor, num_lines)
data = textformats.formatData('editor')
doc = QTextDocument()
font = QFont(data.font)
font.setPointSizeF(font.pointSizeF() * scale)
doc.setDefaultFont(font)
doc.setPlainText(c2.selection().toPlainText())
if metainfo.info(cursor.document()).highlighting:
highlighter.highlight(doc, state=tokeniter.state(block))
size = doc.size().toSize() + QSize(8, -4)
pix = QPixmap(size)
pix.fill(data.baseColors['background'])
doc.drawContents(QPainter(pix))
return pix
def transform(self, value):
if not value:
return None
style_map = {"normal": QFont.StyleNormal, "italic": QFont.StyleItalic, "oblique": QFont.StyleOblique}
weight_map = {"normal": QFont.Normal, "bold": QFont.Bold}
font = QFont()
font.setStyle(QFont.StyleNormal)
font.setWeight(QFont.Normal)
match = self.font_regex.match(value)
style = match.group("style")
weight = match.group("weight")
namedweight = match.group("namedweight")
size = match.group("size")
family = match.group("family")
if style:
font.setStyle(style_map[style])
if namedweight:
font.setWeight(weight_map[namedweight])
if weight:
# based on qcssparser.cpp:setFontWeightFromValue
font.setWeight(min(int(weight) / 8, 99))
if size:
if size.lower().endswith("pt"):
font.setPointSizeF(float(size[:-2]))
elif size.lower().endswith("px"):
font.setPixelSize(int(size[:-2]))
# The Qt CSS parser handles " and ' before passing the string to
# QFont.setFamily. We could do proper CSS-like parsing here, but since
# hopefully nobody will ever have a font with quotes in the family (if
# that's even possible), we take a much more naive approach.
family = family.replace('"', "").replace("'", "")
font.setFamily(family)
return font
def add_line_item(self, userItem: UserItem):
# 新建项目，在这里加载key
# 添加的时候禁用排序，否则后面会混乱
self.ui.table.setSortingEnabled(False)
self.itemList[userItem.id] = userItem.load_key(self.adminPassword)
index = self.ui.table.rowCount()
self.ui.table.setRowCount(index + 1)
# 内容缓存
contents = [
userItem.id, userItem.name, userItem.account, '******',
userItem.email_or_phone, userItem.note
]
# 显示内容，以及设置中间对齐
for i in range(0, 5 + 1):
self.ui.table.setItem(index, i, QTableWidgetItem(contents[i]))
self.ui.table.item(index, i).setTextAlignment(Qt.AlignHCenter
| Qt.AlignVCenter)
font = QFont()
font.setFamily('consolas')
font.setPointSizeF(9.8)
headerItem = QTableWidgetItem(str(index + 1))
headerItem.setFont(font)
self.ui.table.setVerticalHeaderItem(index, headerItem)
self.ui.table.verticalHeaderItem(index).setTextAlignment(
Qt.AlignHCenter | Qt.AlignVCenter)
self.ui.table.setSortingEnabled(True)
class GhostDelta(QGraphicsTextItem):
# Similar to textitem
def __init__(self, delta, fontsize=10):
super(GhostDelta, self).__init__()
self.delta = int(delta)
self.setDefaultTextColor(Qt.blue)
self.setPlainText(" {} ".format(self.delta))
self.font = QFont("Helvetica")
# Slightly larger font than regular textitem.
self.font.setPointSizeF(1.25 * fontsize)
self.setFont(self.font)
# Is not editable.
self.setTextInteractionFlags(Qt.NoTextInteraction)
self.setFlag(QGraphicsItem.ItemIsMovable)
def changeDelta(self, dlt):
self.delta = dlt
self.setPlainText(" {} ".format(self.delta))
def paint(self, painter, option, widget):
# paint the background
painter.setPen(QPen(Qt.blue, 1))
painter.drawRoundedRect(option.rect, 10, 10)
# paint the normal TextItem with the default 'paint' method
super(GhostDelta, self).paint(painter, option, widget)
class GhostText(QGraphicsTextItem):
# Textitem is a qgraphicstextitem, has to handle
# textinput and double-click to start editing etc.
# Shift-return ends the editor
def __init__(self, txt, fontsize=10):
super(GhostText, self).__init__()
self.setDefaultTextColor(Qt.blue)
self.setPlainText(txt)
self.font = QFont("Helvetica")
self.font.setPointSizeF(fontsize)
self.setFont(self.font)
self.setFlag(QGraphicsItem.ItemIsMovable)
# Set it as editably with the text-editor
self.setTextInteractionFlags(Qt.NoTextInteraction)
def changeText(self, txt):
self.setPlainText(txt)
if self.scene() is not None and txt[:4].upper() == "TEX:":
texIt = (
"\\color{blue}\n" + txt[4:].strip()
) # make color blue for ghost rendering
fragfilename = self.scene().latexAFragment(texIt)
if fragfilename:
self.setPlainText("")
tc = self.textCursor()
qi = QImage(fragfilename)
tc.insertImage(qi)
def __init__(self, parent=None, *args, **kwargs):
QLineEdit.__init__(self, *args)
self.ventana = parent
font = QFont()
if 'tamanio' in kwargs:
font.setPointSizeF(kwargs['tamanio'])
else:
font.setPointSizeF(12)
self.setFont(font)
if 'tooltip' in kwargs:
self.setToolTip(kwargs['tooltip'])
if 'placeholderText' in kwargs:
self.setPlaceholderText(kwargs['placeholderText'])
if 'alineacion' in kwargs:
if kwargs['alineacion'].upper() == 'DERECHA':
self.setAlignment(QtCore.Qt.AlignRight)
elif kwargs['alineacion'].upper() == 'IZQUIERDA':
self.setAlignment(QtCore.Qt.AlignLeft)
if 'enabled' in kwargs:
self.setEnabled(kwargs['enabled'])
if 'inputmask' in kwargs:
self.setInputMask(kwargs['inputmask'])
def labelPoints(self, img: Optional[QPixmap], toSrc: bool):
if not img or not self.points:
return None
painter = QPainter()
painter.begin(img)
painter.setRenderHint(QPainter.Antialiasing, True)
pen = QPen()
pen.setCapStyle(Qt.RoundCap)
font = QFont('Consolas')
if toSrc:
pen.setWidthF(config.pointWidth * self.ratioToSrc)
font.setPointSizeF(config.fontSize * self.ratioToSrc)
else:
pen.setWidthF(config.pointWidth)
font.setPointSizeF(config.fontSize)
painter.setFont(font)
for index, (point, color) in self.points.items():
labelPoint: QPointF
if toSrc:
pen.setColor(color)
labelPoint = self.getSrcPoint(point)
else:
pen.setColor(
color if index != self.highlightMoveIndex and index not in self.highlightPoints
else QColor.lighter(color)
)
labelPoint = point
painter.setPen(pen)
painter.drawPoint(labelPoint)
painter.drawText(static.getIndexShift(labelPoint), str(index))
painter.end()
def paintMap(self):
painter = QPainter(self)
painter.setPen(QPen(Qt.black, 2, Qt.SolidLine))
dimension = self.windowHeight / 3
rectangleWidth = dimension * 2 / self.mapa.width
rectangleHeight = dimension * 2 / self.mapa.height
for i in range(self.mapa.width):
for j in range(self.mapa.height):
node = self.mapa.nodeArray[i][j]
painter.setBrush(Qt.white)
if node.isBeginning | node.isDestination:
painter.setBrush(Qt.darkYellow)
elif node.isPath:
painter.setBrush(Qt.yellow)
elif (node.cordX == self.drawTypeFirstX) & (
node.cordY == self.drawTypeFirstY):
painter.setBrush(Qt.gray)
elif not node.isTraversable:
painter.setBrush(Qt.black)
elif not self.mapa.isPathFound:
if node.isOpen:
painter.setBrush(Qt.magenta)
elif node.isClosed:
painter.setBrush(Qt.red)
painter.drawRect(i * rectangleWidth,
j * rectangleHeight + dimension,
rectangleWidth, rectangleHeight)
if node.isBeginning | node.isDestination:
painter.setBrush(Qt.black)
painter.drawLine(i * rectangleWidth,
j * rectangleHeight + dimension,
(i + 1) * rectangleWidth,
(j + 1) * rectangleHeight + dimension)
painter.drawLine(i * rectangleWidth,
(j + 1) * rectangleHeight + dimension,
(i + 1) * rectangleWidth,
j * rectangleHeight + dimension)
if node.isBeginning:
font = QFont()
font.setPointSizeF(rectangleWidth / 2)
painter.setFont(font)
painter.drawText(i * rectangleWidth,
(j + 1) * rectangleHeight + dimension,
'A')
if node.isDestination:
font = QFont()
font.setPointSizeF(rectangleWidth / 2)
painter.setFont(font)
painter.drawText(i * rectangleWidth,
(j + 1) * rectangleHeight + dimension,
'B')
def __init__(self, *args, **kwargs):
QTextEdit.__init__(self, *args)
if 'tamanio' in kwargs:
self.tamanio = kwargs['tamanio']
font = QFont()
font.setPointSizeF(self.tamanio)
self.setFont(font)
def __init__(self, parent=None, *args, **kwargs):
#QCheckBox.__init__(parent)
QCheckBox.__init__(self, *args)
font = QFont()
font.setPointSizeF(12)
self.setFont(font)
if 'texto' in kwargs:
self.setText(kwargs['texto'])
def __init__(self, parent=None, *args, **kwargs):
EntradaTexto.__init__(self, parent, *args, **kwargs)
font = QFont()
font.setPointSizeF(12)
self.setFont(font)
if self.largo != 0:
self.setMaxLength(self.largo)
self.setMaximumWidth(50)
def paintTab(self, painter: QPainter, index: int):
if not self.isValidIndex(index):
return
painter.save()
tab = self._tabs[index]
rect = self._tabRect(index)
selected = index == self._currentIndex
enabled = self._enabled and tab.enabled
if selected:
painter.fillRect(rect, FancyToolButtonSelectedColor)
tabText = tab.text
tabTextRect = QRect(rect)
drawIcon = rect.height() > 36
tabIconRect = QRect(rect)
tabTextRect.translate(0, -2 if drawIcon else 1)
boldFont = QFont(painter.font())
boldFont.setPointSizeF(SIDEBAR_FONT_SIZE)
boldFont.setBold(True)
painter.setFont(boldFont)
#painter.setPen(QColor(255, 255, 255, 160) if selected else QColor(0, 0, 0, 110))
textFlags = Qt.AlignCenter | (Qt.AlignBottom if drawIcon else
Qt.AlignVCenter) | Qt.TextWordWrap
fader = tab.fader
if fader > 0 and not selected and enabled:
painter.save()
painter.setOpacity(fader)
painter.fillRect(rect, FancyToolButtonHoverColor)
painter.restore()
if not enabled:
painter.setOpacity(0.7)
if drawIcon:
textHeight = (painter.fontMetrics().boundingRect(
QRect(0, 0, self.width(), self.height()), Qt.TextWordWrap,
tabText).height())
tabIconRect.adjust(0, 4, 0, -textHeight - 4)
iconMode = (QIcon.Active if selected else
QIcon.Normal) if enabled else QIcon.Disabled
iconRect = QRect(0, 0, MODEBAR_ICON_SIZE, MODEBAR_ICON_SIZE)
iconRect.moveCenter(tabIconRect.center())
iconRect = iconRect.intersected(tabIconRect)
drawIconWithShadow(tab.icon, iconRect, painter, iconMode)
if enabled:
penColor = FancyTabWidgetEnabledSelectedTextColor if selected else FancyTabWidgetEnabledUnselectedTextColor
else:
penColor = FancyTabWidgetDisabledSelectedTextColor if selected else FancyTabWidgetDisabledUnselectedTextColor
painter.setPen(penColor)
painter.translate(0, -1)
painter.drawText(tabTextRect, textFlags, tabText)
painter.restore()
def __init__(self, *args, **kwargs):
QTableWidget.__init__(self, *args)
if 'tamanio' in kwargs:
self.tamanio = kwargs['tamanio']
font = QFont()
font.setPointSizeF(self.tamanio)
self.setFont(font)
self.setSortingEnabled(True)
def to_py(self, value):
self._basic_py_validation(value, str)
if not value:
return None
style_map = {
'normal': QFont.StyleNormal,
'italic': QFont.StyleItalic,
'oblique': QFont.StyleOblique,
}
weight_map = {
'normal': QFont.Normal,
'bold': QFont.Bold,
}
font = QFont()
font.setStyle(QFont.StyleNormal)
font.setWeight(QFont.Normal)
match = self.font_regex.match(value)
if not match: # pragma: no cover
# This should never happen, as the regex always matches everything
# as family.
raise configexc.ValidationError(value, "must be a valid font")
style = match.group('style')
weight = match.group('weight')
namedweight = match.group('namedweight')
size = match.group('size')
family = match.group('family')
if style:
font.setStyle(style_map[style])
if namedweight:
font.setWeight(weight_map[namedweight])
if weight:
# based on qcssparser.cpp:setFontWeightFromValue
font.setWeight(min(int(weight) / 8, 99))
if size:
if size.lower().endswith('pt'):
font.setPointSizeF(float(size[:-2]))
elif size.lower().endswith('px'):
font.setPixelSize(int(size[:-2]))
else:
# This should never happen as the regex only lets pt/px
# through.
raise ValueError("Unexpected size unit in {!r}!".format(
size)) # pragma: no cover
if family == 'monospace':
family = self.monospace_fonts
# The Qt CSS parser handles " and ' before passing the string to
# QFont.setFamily. We could do proper CSS-like parsing here, but since
# hopefully nobody will ever have a font with quotes in the family (if
# that's even possible), we take a much more naive approach.
family = family.replace('"', '').replace("'", '')
font.setFamily(family)
return font
def fitTextToWidth(text: str, font: QFont, width: int) -> QFont:
text_width = QFontMetrics(font).horizontalAdvance(text)
step = font.pointSize() / 20
new_font = QFont(font)
while text_width > width:
new_font.setPointSizeF(max(0, new_font.pointSize() - step))
text_width = QFontMetrics(new_font).horizontalAdvance(text)
return new_font
def to_py(self, value):
self._basic_py_validation(value, str)
if not value:
return None
style_map = {
'normal': QFont.StyleNormal,
'italic': QFont.StyleItalic,
'oblique': QFont.StyleOblique,
}
weight_map = {
'normal': QFont.Normal,
'bold': QFont.Bold,
}
font = QFont()
font.setStyle(QFont.StyleNormal)
font.setWeight(QFont.Normal)
match = self.font_regex.match(value)
if not match: # pragma: no cover
# This should never happen, as the regex always matches everything
# as family.
raise configexc.ValidationError(value, "must be a valid font")
style = match.group('style')
weight = match.group('weight')
namedweight = match.group('namedweight')
size = match.group('size')
family = match.group('family')
if style:
font.setStyle(style_map[style])
if namedweight:
font.setWeight(weight_map[namedweight])
if weight:
# based on qcssparser.cpp:setFontWeightFromValue
font.setWeight(min(int(weight) / 8, 99))
if size:
if size.lower().endswith('pt'):
font.setPointSizeF(float(size[:-2]))
elif size.lower().endswith('px'):
font.setPixelSize(int(size[:-2]))
else:
# This should never happen as the regex only lets pt/px
# through.
raise ValueError("Unexpected size unit in {!r}!".format(
size)) # pragma: no cover
# The Qt CSS parser handles " and ' before passing the string to
# QFont.setFamily. We could do proper CSS-like parsing here, but since
# hopefully nobody will ever have a font with quotes in the family (if
# that's even possible), we take a much more naive approach.
family = family.replace('"', '').replace("'", '')
if family == 'monospace':
family = self.monospace_fonts
font.setFamily(family)
return font
def get_optimal_font(family_font: str, w, h, text: str) -> QFont:
font = QFont(family_font)
font.setStyleHint(QFont.Courier, QFont.PreferAntialias)
metrics = QFontMetrics(font)
# SOURCE: https://github.com/gil9red/SimplePyScripts/blob/add91e36e1ee59b3956b9fafdcffc9f4ff10ed3d/qt__pyqt__pyside__pyqode/pyqt__QPainter__draw_table.py#L98
factor = w / metrics.boundingRect(0, 0, w, h, Qt.AlignCenter, text).width()
if factor < 1 or factor > 1.25:
font.setPointSizeF(font.pointSizeF() * factor)
return font
def __init__(self, *args, **kwargs):
super().__init__()
font = QFont()
font.setPointSizeF(10)
self.setFont(font)
if 'orden' in kwargs:
self.cOrden = kwargs['orden']
if 'checkeable' in kwargs:
self.CargaDatos(checkeable=kwargs['checkeable'])
else:
self.CargaDatos()
def loadSettings(self):
s = QSettings()
s.beginGroup("log")
font = QFont(s.value("fontfamily", "monospace", str))
font.setPointSizeF(s.value("fontsize", 9.0, float))
with qutil.signalsBlocked(self.fontChooser, self.fontSize):
self.fontChooser.setCurrentFont(font)
self.fontSize.setValue(font.pointSizeF())
self.showlog.setChecked(s.value("show_on_start", True, bool))
self.rawview.setChecked(s.value("rawview", True, bool))
self.hideauto.setChecked(s.value("hide_auto_engrave", False, bool))
def __init__(self, str, x, y, size, w, fontname):
super().__init__()
font = QFont(fontname)
fontMetrics = QFontMetrics(font)
scale = float(fontMetrics.width(str)) / w
font.setPointSizeF(font.pointSizeF() / scale)
self.setFont(font)
self.setPos(x - w / 2, y - fontMetrics.height())
self.setPlainText(str)
def loadSettings(self):
s = QSettings()
s.beginGroup("log")
font = QFont(s.value("fontfamily", "monospace", str))
font.setPointSizeF(s.value("fontsize", 9.0, float))
with qutil.signalsBlocked(self.fontChooser, self.fontSize):
self.fontChooser.setCurrentFont(font)
self.fontSize.setValue(font.pointSizeF())
self.showlog.setChecked(s.value("show_on_start", True, bool))
self.rawview.setChecked(s.value("rawview", True, bool))
self.hideauto.setChecked(s.value("hide_auto_engrave", False, bool))
def __init__(self, *args, **kwargs):
QTextEdit.__init__(self, *args)
if 'tamanio' in kwargs:
self.tamanio = kwargs['tamanio']
if 'placeholdertext' in kwargs:
self.setPlaceholderText(kwargs['placeholdertext'])
font = QFont()
font.setPointSizeF(self.tamanio)
self.setFont(font)
def draw(self, pnt, t_start, t_end, **kwargs):
p = QPointF(*eval_at(self._pos, t_end))
pen = QPen(QColor(*self._to_qt_color(self.border_color)))
pen.setWidth(self.border_width)
pnt.setPen(pen)
f = QFont()
f.setPointSizeF(eval_at(self._size, t_end))
pnt.setFont(f)
pnt.drawText(p, eval_at(self._text, t_end))
def __init__(self, parent=None, *args, **kwargs):
QComboBox.__init__(self, parent)
font = QFont()
if 'tamanio' in kwargs:
font.setPointSizeF(kwargs['tamanio'])
else:
font.setPointSizeF(12)
if 'enabled' in kwargs:
self.setEnabled(kwargs['enabled'])
self.setFont(font)
def parseFont(self, info):
font = QFont(self.font())
for s in info.split(' '):
s = s.strip().lower()
if (s.endswith("pt")):
font.setPointSizeF(float(s[:-2]))
elif s == "bold" or s == "b": font.setBold(True)
elif s == "italic" or s == "i": font.setItalic(True)
elif s == "underline" or s == "u": font.setUnderline(True)
elif s == "strike": font.setStrikeOut(True)
print(font.toString())
return font
def logformats(self):
"""Returns a dictionary with QTextCharFormats for the different types of messages.
Besides the STDOUT, STDERR, NEUTRAL, FAILURE and SUCCESS formats there is also
a "link" format, that looks basically the same as the output formats, but blueish
and underlined, to make parts of the output (e.g. filenames) look clickable.
"""
textColor = QApplication.palette().color(QPalette.WindowText)
successColor = qutil.addcolor(textColor, 0, 128, 0) # more green
failureColor = qutil.addcolor(textColor, 128, 0, 0) # more red
linkColor = qutil.addcolor(textColor, 0, 0, 128) # more blue
stdoutColor = qutil.addcolor(textColor, 64, 64, 0) # more purple
s = QSettings()
s.beginGroup("log")
outputFont = QFont(s.value("fontfamily", "monospace", str))
outputFont.setPointSizeF(s.value("fontsize", 9.0, float))
output = QTextCharFormat()
output.setFont(outputFont)
# enable zooming the log font size
output.setProperty(QTextFormat.FontSizeAdjustment, 0)
stdout = QTextCharFormat(output)
stdout.setForeground(stdoutColor)
stderr = QTextCharFormat(output)
link = QTextCharFormat(output)
link.setForeground(linkColor)
link.setFontUnderline(True)
status = QTextCharFormat()
status.setFontWeight(QFont.Bold)
neutral = QTextCharFormat(status)
success = QTextCharFormat(status)
success.setForeground(successColor)
failure = QTextCharFormat(status)
failure.setForeground(failureColor)
return {
job.STDOUT: stdout,
job.STDERR: stderr,
job.NEUTRAL: neutral,
job.SUCCESS: success,
job.FAILURE: failure,
'link': link,
}
def logformats(self):
"""Returns a dictionary with QTextCharFormats for the different types of messages.
Besides the STDOUT, STDERR, NEUTRAL, FAILURE and SUCCESS formats there is also
a "link" format, that looks basically the same as the output formats, but blueish
and underlined, to make parts of the output (e.g. filenames) look clickable.
"""
textColor = QApplication.palette().color(QPalette.WindowText)
successColor = qutil.addcolor(textColor, 0, 128, 0) # more green
failureColor = qutil.addcolor(textColor, 128, 0, 0) # more red
linkColor = qutil.addcolor(textColor, 0, 0, 128) # more blue
stdoutColor = qutil.addcolor(textColor, 64, 64, 0) # more purple
s = QSettings()
s.beginGroup("log")
outputFont = QFont(s.value("fontfamily", "monospace", str))
outputFont.setPointSizeF(s.value("fontsize", 9.0, float))
output = QTextCharFormat()
output.setFont(outputFont)
# enable zooming the log font size
output.setProperty(QTextFormat.FontSizeAdjustment, 0)
stdout = QTextCharFormat(output)
stdout.setForeground(stdoutColor)
stderr = QTextCharFormat(output)
link = QTextCharFormat(output)
link.setForeground(linkColor)
link.setFontUnderline(True)
status = QTextCharFormat()
status.setFontWeight(QFont.Bold)
neutral = QTextCharFormat(status)
success = QTextCharFormat(status)
success.setForeground(successColor)
failure = QTextCharFormat(status)
failure.setForeground(failureColor)
return {
job.STDOUT: stdout,
job.STDERR: stderr,
job.NEUTRAL: neutral,
job.SUCCESS: success,
job.FAILURE: failure,
'link': link,
}
def __init__(self, *args, **kwargs):
QTextEdit.__init__(self, *args)
if 'tamanio' in kwargs:
self.tamanio = kwargs['tamanio']
if 'placeholderText' in kwargs:
self.setPlaceholderText(kwargs['placeholderText'])
if 'alto' in kwargs:
self.setMaximumHeight(kwargs['alto'])
if 'enabled' in kwargs:
self.setEnabled(kwargs['enabled'])
font = QFont()
font.setPointSizeF(self.tamanio)
self.setFont(font)
def __init__(self, *args, **kwargs):
QTableWidget.__init__(self, *args)
if 'tamanio' in kwargs:
self.tamanio = kwargs['tamanio']
font = QFont()
font.setPointSizeF(self.tamanio)
self.setFont(font)
if 'habilitarorden' in kwargs:
self.setSortingEnabled(kwargs['habilitarorden'])
else:
self.setSortingEnabled(True)
# self.itemClicked.connect(self.handleItemClicked)
self.setEditTriggers(QAbstractItemView.AllEditTriggers)#para que se pueda editar el contenido con solo un click
def set_font_to_text_edit(self, text_edit, size, family, bold, italic,
strikeout, color):
"""
Функция set_font_and_color() получает настройки шрифта и цвет текста из базы и применяет их к компоненту QTextEdit
"""
font = QFont()
font.setPointSizeF(size)
font.setFamily(family)
font.setBold(int(bold))
font.setItalic(int(italic))
font.setStrikeOut(int(strikeout))
text_edit.setFont(font)
text_edit.setStyleSheet("QTextEdit {background-color: #00356a}")
text_edit.setTextColor(QColor(color))
def __init__(self, *args, **kwargs):
QTableWidget.__init__(self, *args)
if 'tamanio' in kwargs:
self.tamanio = kwargs['tamanio']
font = QFont()
font.setPointSizeF(self.tamanio)
self.setFont(font)
if 'habilitarorden' in kwargs:
self.setSortingEnabled(kwargs['habilitarorden'])
else:
self.setSortingEnabled(True)
if 'enabled' in kwargs:
self.setEnabled(kwargs['enabled'])
def importTheme(filename, widget, schemeWidget):
"""Loads the colors theme from a file"""
try:
d = ET.parse(filename)
root = d.getroot()
if root.tag != 'frescobaldi-theme':
raise ValueError(_("No theme found."))
except Exception as e:
QMessageBox.critical(widget, app.caption(_("Error")),
_("Can't read from source:\n\n{url}\n\n{error}").format(
url=filename, error=e))
return
schemeWidget.scheme.blockSignals(True)
key = schemeWidget.addScheme(root.get('name'))
schemeWidget.scheme.blockSignals(False)
tfd = textformats.TextFormatData(key)
fontElt = root.find('font')
defaultfont = "Lucida Console" if os.name == "nt" else "monospace"
if fontElt.get('fontFamily') in QFontDatabase().families():
fontFamily = fontElt.get('fontFamily')
else:
fontFamily = defaultfont
font = QFont(fontFamily)
font.setPointSizeF(float(fontElt.get('fontSize')))
tfd.font = font
for elt in root.find('baseColors'):
tfd.baseColors[elt.tag] = QColor(elt.get('color'))
for elt in root.find('defaultStyles'):
tfd.defaultStyles[elt.tag] = eltToStyle(elt)
for style in root.find('allStyles'):
if not style in tfd.allStyles:
tfd.allStyles[style] = {}
for elt in style:
tfd.allStyles[style.tag][elt.tag] = eltToStyle(elt)
widget.addSchemeData(key, tfd)
schemeWidget.disableDefault(False)
schemeWidget.currentChanged.emit()
schemeWidget.changed.emit()
def wheelEvent(self, event):
"""
We catch wheelEvent if key modifier is CTRL to change font size.
Note: this should be in a class specific for main textEditView (#TODO).
"""
if event.modifiers() & Qt.ControlModifier:
# Get the wheel angle.
d = event.angleDelta().y() / 120
# Update settings
f = QFont()
f.fromString(settings.textEditor["font"])
f.setPointSizeF(f.pointSizeF() + d)
settings.textEditor["font"] = f.toString()
# Update font to all textEditView. Drastically.
for w in F.mainWindow().findChildren(textEditView, QRegExp(".*")):
w.loadFontSettings()
# We tell the world that we accepted this event
event.accept()
return
QTextEdit.wheelEvent(self, event)
class TextFormatData(object):
"""Encapsulates all settings in the Fonts & Colors page for a scheme."""
def __init__(self, scheme):
"""Loads the data from scheme."""
self.font = None
self.baseColors = {}
self.defaultStyles = {}
self.allStyles = {}
self._inherits = {}
self.load(scheme)
def load(self, scheme):
"""Load the settings for the scheme. Called on init."""
s = QSettings()
s.beginGroup("fontscolors/" + scheme)
# load font
defaultfont = "Lucida Console" if os.name == "nt" else "monospace"
self.font = QFont(s.value("fontfamily", defaultfont, str))
self.font.setPointSizeF(s.value("fontsize", 10.0, float))
# load base colors
s.beginGroup("basecolors")
for name in baseColors:
if s.contains(name):
self.baseColors[name] = QColor(s.value(name, "", str))
else:
self.baseColors[name] = baseColorDefaults[name]()
s.endGroup()
# get the list of supported styles from ly.colorize
all_styles = ly.colorize.default_mapping()
default_styles = set()
for group, styles in all_styles:
d = self._inherits[group] = {}
for style in styles:
if style.base:
default_styles.add(style.base)
d[style.name] = style.base
default_scheme = ly.colorize.default_scheme
# load default styles
s.beginGroup("defaultstyles")
for name in default_styles:
self.defaultStyles[name] = f = QTextCharFormat()
css = default_scheme[None].get(name)
if css:
css2fmt(css, f)
s.beginGroup(name)
self.loadTextFormat(f, s)
s.endGroup()
s.endGroup()
# load specific styles
s.beginGroup("allstyles")
for group, styles in all_styles:
self.allStyles[group]= {}
s.beginGroup(group)
for style in styles:
self.allStyles[group][style.name] = f = QTextCharFormat()
css = default_scheme[group].get(style.name)
if css:
css2fmt(css, f)
s.beginGroup(style.name)
self.loadTextFormat(f, s)
s.endGroup()
s.endGroup()
s.endGroup()
def save(self, scheme):
"""Save the settings to the scheme."""
s = QSettings()
s.beginGroup("fontscolors/" + scheme)
# save font
s.setValue("fontfamily", self.font.family())
s.setValue("fontsize", self.font.pointSizeF())
# save base colors
for name in baseColors:
s.setValue("basecolors/"+name, self.baseColors[name].name())
# save default styles
s.beginGroup("defaultstyles")
for name in defaultStyles:
s.beginGroup(name)
self.saveTextFormat(self.defaultStyles[name], s)
s.endGroup()
s.endGroup()
# save all specific styles
s.beginGroup("allstyles")
for group, styles in ly.colorize.default_mapping():
s.beginGroup(group)
for style in styles:
s.beginGroup(style.name)
self.saveTextFormat(self.allStyles[group][style.name], s)
s.endGroup()
s.endGroup()
s.endGroup()
def textFormat(self, group, name):
"""Return a QTextCharFormat() for the specified group and name."""
inherit = self._inherits[group].get(name)
f = QTextCharFormat(self.defaultStyles[inherit]) if inherit else QTextCharFormat()
f.merge(self.allStyles[group][name])
return f
def css_scheme(self):
"""Return a dictionary of css dictionaries representing this scheme.
This can be fed to the ly.colorize.format_stylesheet() function.
"""
scheme = {}
# base/default styles
d = scheme[None] = {}
for name, fmt in self.defaultStyles.items():
d[name] = fmt2css(fmt)
# mode/group styles
for mode, styles in self.allStyles.items():
d = scheme[mode] = {}
for name, fmt in styles.items():
d[name] = fmt2css(fmt)
return scheme
def palette(self):
"""Return a basic palette with text, background, selection and selection background filled in."""
p = QApplication.palette()
p.setColor(QPalette.Text, self.baseColors['text'])
p.setColor(QPalette.Base, self.baseColors['background'])
p.setColor(QPalette.HighlightedText, self.baseColors['selectiontext'])
p.setColor(QPalette.Highlight, self.baseColors['selectionbackground'])
return p
def saveTextFormat(self, fmt, settings):
"""(Internal) Store one QTextCharFormat in the QSettings instance."""
if fmt.hasProperty(QTextFormat.FontWeight):
settings.setValue('bold', fmt.fontWeight() >= 70)
else:
settings.remove('bold')
if fmt.hasProperty(QTextFormat.FontItalic):
settings.setValue('italic', fmt.fontItalic())
else:
settings.remove('italic')
if fmt.hasProperty(QTextFormat.TextUnderlineStyle):
settings.setValue('underline', fmt.fontUnderline())
else:
settings.remove('underline')
if fmt.hasProperty(QTextFormat.ForegroundBrush):
settings.setValue('textColor', fmt.foreground().color().name())
else:
settings.remove('textColor')
if fmt.hasProperty(QTextFormat.BackgroundBrush):
settings.setValue('backgroundColor', fmt.background().color().name())
else:
settings.remove('backgroundColor')
if fmt.hasProperty(QTextFormat.TextUnderlineColor):
settings.setValue('underlineColor', fmt.underlineColor().name())
else:
settings.remove('underlineColor')
def loadTextFormat(self, fmt, settings):
"""(Internal) Merge values from the QSettings instance into the QTextCharFormat."""
if settings.contains('bold'):
fmt.setFontWeight(QFont.Bold if settings.value('bold', False, bool) else QFont.Normal)
if settings.contains('italic'):
fmt.setFontItalic(settings.value('italic', False, bool))
if settings.contains('underline'):
fmt.setFontUnderline(settings.value('underline', False, bool))
if settings.contains('textColor'):
fmt.setForeground(QColor(settings.value('textColor', '' , str)))
if settings.contains('backgroundColor'):
fmt.setBackground(QColor(settings.value('backgroundColor', '' , str)))
if settings.contains('underlineColor'):
fmt.setUnderlineColor(QColor(settings.value('underlineColor', '' , str)))
def __init__(self, *args, mode=None):
QApplication.__init__(self, *args)
# Log some basic system info
try:
v = openshot.GetVersion()
log.info("openshot-qt version: %s" % info.VERSION)
log.info("libopenshot version: %s" % v.ToString())
log.info("platform: %s" % platform.platform())
log.info("processor: %s" % platform.processor())
log.info("machine: %s" % platform.machine())
log.info("python version: %s" % platform.python_version())
log.info("qt5 version: %s" % QT_VERSION_STR)
log.info("pyqt5 version: %s" % PYQT_VERSION_STR)
except:
pass
# Setup application
self.setApplicationName('openshot')
self.setApplicationVersion(info.SETUP['version'])
# Init settings
self.settings = settings.SettingStore()
self.settings.load()
# Init and attach exception handler
from classes import exceptions
sys.excepthook = exceptions.ExceptionHandler
# Init translation system
language.init_language()
# Detect minimum libopenshot version
_ = self._tr
libopenshot_version = openshot.GetVersion().ToString()
if mode != "unittest" and libopenshot_version < info.MINIMUM_LIBOPENSHOT_VERSION:
QMessageBox.warning(None, _("Wrong Version of libopenshot Detected"),
_("<b>Version %(minimum_version)s is required</b>, but %(current_version)s was detected. Please update libopenshot or download our latest installer.") %
{"minimum_version": info.MINIMUM_LIBOPENSHOT_VERSION, "current_version": libopenshot_version})
# Stop launching and exit
sys.exit()
# Tests of project data loading/saving
self.project = project_data.ProjectDataStore()
# Init Update Manager
self.updates = updates.UpdateManager()
# It is important that the project is the first listener if the key gets update
self.updates.add_listener(self.project)
# Load ui theme if not set by OS
ui_util.load_theme()
# Start libopenshot logging thread
self.logger_libopenshot = logger_libopenshot.LoggerLibOpenShot()
self.logger_libopenshot.start()
# Track which dockable window received a context menu
self.context_menu_object = None
# Set Font for any theme
if self.settings.get("theme") != "No Theme":
# Load embedded font
try:
log.info("Setting font to %s" % os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_id = QFontDatabase.addApplicationFont(os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_family = QFontDatabase.applicationFontFamilies(font_id)[0]
font = QFont(font_family)
font.setPointSizeF(10.5)
QApplication.setFont(font)
except Exception as ex:
log.error("Error setting Ubuntu-R.ttf QFont: %s" % str(ex))
# Set Experimental Dark Theme
if self.settings.get("theme") == "Humanity: Dark":
# Only set if dark theme selected
log.info("Setting custom dark theme")
self.setStyle(QStyleFactory.create("Fusion"))
darkPalette = self.palette()
darkPalette.setColor(QPalette.Window, QColor(53, 53, 53))
darkPalette.setColor(QPalette.WindowText, Qt.white)
darkPalette.setColor(QPalette.Base, QColor(25, 25, 25))
darkPalette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ToolTipBase, Qt.white)
darkPalette.setColor(QPalette.ToolTipText, Qt.white)
darkPalette.setColor(QPalette.Text, Qt.white)
darkPalette.setColor(QPalette.Button, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ButtonText, Qt.white)
darkPalette.setColor(QPalette.BrightText, Qt.red)
darkPalette.setColor(QPalette.Highlight, QColor(42, 130, 218))
darkPalette.setColor(QPalette.HighlightedText, Qt.black)
darkPalette.setColor(QPalette.Disabled, QPalette.Text, QColor(104, 104, 104))
self.setPalette(darkPalette)
self.setStyleSheet("QToolTip { color: #ffffff; background-color: #2a82da; border: 0px solid white; }")
# Create main window
from windows.main_window import MainWindow
self.window = MainWindow(mode)
# Reset undo/redo history
self.updates.reset()
self.window.updateStatusChanged(False, False)
log.info('Process command-line arguments: %s' % args)
if len(args[0]) == 2:
path = args[0][1]
if ".osp" in path:
# Auto load project passed as argument
self.window.OpenProjectSignal.emit(path)
else:
# Auto import media file
self.window.filesTreeView.add_file(path)
else:
# Recover backup file (this can't happen until after the Main Window has completely loaded)
self.window.RecoverBackup.emit()
def setTextSize(self, size):
font = QFont()
font.setPointSizeF(size)
self.text.setFont(font)
def __init__(self, *args):
QApplication.__init__(self, *args)
# Setup appication
self.setApplicationName('openshot')
self.setApplicationVersion(info.SETUP['version'])
# Init settings
self.settings = settings.SettingStore()
try:
self.settings.load()
except Exception as ex:
log.error("Couldn't load user settings. Exiting.\n{}".format(ex))
exit()
# Init translation system
language.init_language()
# Tests of project data loading/saving
self.project = project_data.ProjectDataStore()
# Init Update Manager
self.updates = updates.UpdateManager()
# It is important that the project is the first listener if the key gets update
self.updates.add_listener(self.project)
# Load ui theme if not set by OS
ui_util.load_theme()
# Track which dockable window received a context menu
self.context_menu_object = None
# Set Font for any theme
if self.settings.get("theme") != "No Theme":
# Load embedded font
log.info("Setting font to %s" % os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_id = QFontDatabase.addApplicationFont(os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_family = QFontDatabase.applicationFontFamilies(font_id)[0]
font = QFont(font_family)
font.setPointSizeF(10.5)
QApplication.setFont(font)
# Set Experimental Dark Theme
if self.settings.get("theme") == "Humanity: Dark":
# Only set if dark theme selected
log.info("Setting custom dark theme")
self.setStyle(QStyleFactory.create("Fusion"))
darkPalette = self.palette()
darkPalette.setColor(QPalette.Window, QColor(53, 53, 53))
darkPalette.setColor(QPalette.WindowText, Qt.white)
darkPalette.setColor(QPalette.Base, QColor(25, 25, 25))
darkPalette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ToolTipBase, Qt.white)
darkPalette.setColor(QPalette.ToolTipText, Qt.white)
darkPalette.setColor(QPalette.Text, Qt.white)
darkPalette.setColor(QPalette.Button, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ButtonText, Qt.white)
darkPalette.setColor(QPalette.BrightText, Qt.red)
darkPalette.setColor(QPalette.Highlight, QColor(42, 130, 218))
darkPalette.setColor(QPalette.HighlightedText, Qt.black)
self.setPalette(darkPalette)
self.setStyleSheet("QToolTip { color: #ffffff; background-color: #2a82da; border: 0px solid white; }")
# Create main window
from windows.main_window import MainWindow
self.window = MainWindow()
self.window.show()
# Load new/blank project (which sets default profile)
self.project.load("")
log.info('Process command-line arguments: %s' % args)
if len(args[0]) == 2:
path = args[0][1]
if ".osp" in path:
# Auto load project passed as argument
self.window.open_project(path)
else:
# Auto import media file
self.window.filesTreeView.add_file(path)
def __init__(self, *args, mode=None):
QApplication.__init__(self, *args)
# Log some basic system info
try:
v = openshot.GetVersion()
log.info("openshot-qt version: %s" % info.VERSION)
log.info("libopenshot version: %s" % v.ToString())
log.info("platform: %s" % platform.platform())
log.info("processor: %s" % platform.processor())
log.info("machine: %s" % platform.machine())
log.info("python version: %s" % platform.python_version())
log.info("qt5 version: %s" % QT_VERSION_STR)
log.info("pyqt5 version: %s" % PYQT_VERSION_STR)
except:
pass
# Setup appication
self.setApplicationName('openshot')
self.setApplicationVersion(info.SETUP['version'])
# Init settings
self.settings = settings.SettingStore()
try:
self.settings.load()
except Exception as ex:
log.error("Couldn't load user settings. Exiting.\n{}".format(ex))
exit()
# Init translation system
language.init_language()
# Tests of project data loading/saving
self.project = project_data.ProjectDataStore()
# Init Update Manager
self.updates = updates.UpdateManager()
# It is important that the project is the first listener if the key gets update
self.updates.add_listener(self.project)
# Load ui theme if not set by OS
ui_util.load_theme()
# Start libopenshot logging thread
self.logger_libopenshot = logger_libopenshot.LoggerLibOpenShot()
self.logger_libopenshot.start()
# Track which dockable window received a context menu
self.context_menu_object = None
# Set unique install id (if blank)
if not self.settings.get("unique_install_id"):
self.settings.set("unique_install_id", str(uuid4()))
# Track 1st launch metric
import classes.metrics
classes.metrics.track_metric_screen("initial-launch-screen")
# Set Font for any theme
if self.settings.get("theme") != "No Theme":
# Load embedded font
try:
log.info("Setting font to %s" % os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_id = QFontDatabase.addApplicationFont(os.path.join(info.IMAGES_PATH, "fonts", "Ubuntu-R.ttf"))
font_family = QFontDatabase.applicationFontFamilies(font_id)[0]
font = QFont(font_family)
font.setPointSizeF(10.5)
QApplication.setFont(font)
except Exception as ex:
log.error("Error setting Ubuntu-R.ttf QFont: %s" % str(ex))
# Set Experimental Dark Theme
if self.settings.get("theme") == "Humanity: Dark":
# Only set if dark theme selected
log.info("Setting custom dark theme")
self.setStyle(QStyleFactory.create("Fusion"))
darkPalette = self.palette()
darkPalette.setColor(QPalette.Window, QColor(53, 53, 53))
darkPalette.setColor(QPalette.WindowText, Qt.white)
darkPalette.setColor(QPalette.Base, QColor(25, 25, 25))
darkPalette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ToolTipBase, Qt.white)
darkPalette.setColor(QPalette.ToolTipText, Qt.white)
darkPalette.setColor(QPalette.Text, Qt.white)
darkPalette.setColor(QPalette.Button, QColor(53, 53, 53))
darkPalette.setColor(QPalette.ButtonText, Qt.white)
darkPalette.setColor(QPalette.BrightText, Qt.red)
darkPalette.setColor(QPalette.Highlight, QColor(42, 130, 218))
darkPalette.setColor(QPalette.HighlightedText, Qt.black)
darkPalette.setColor(QPalette.Disabled, QPalette.Text, QColor(104, 104, 104))
self.setPalette(darkPalette)
self.setStyleSheet("QToolTip { color: #ffffff; background-color: #2a82da; border: 0px solid white; }")
# Create main window
from windows.main_window import MainWindow
self.window = MainWindow(mode)
log.info('Process command-line arguments: %s' % args)
if len(args[0]) == 2:
path = args[0][1]
if ".osp" in path:
# Auto load project passed as argument
self.window.open_project(path)
else:
# Auto import media file
self.window.filesTreeView.add_file(path)
# Reset undo/redo history
self.updates.reset()
self.window.updateStatusChanged(False, False)
class CharMap(QWidget):
"""A widget displaying a table of characters."""
characterSelected = pyqtSignal(str)
characterClicked = pyqtSignal(str)
def __init__(self, parent=None):
super(CharMap, self).__init__(parent)
self._showToolTips = True
self._showWhatsThis = True
self._selected = -1
self._column_count = 32
self._square = 24
self._range = (0, 0)
self._font = QFont()
def setRange(self, first, last):
self._range = (first, last)
self._selected = -1
self.adjustSize()
self.update()
def range(self):
return self._range
def square(self):
"""Returns the width of one item (determined by font size)."""
return self._square
def select(self, charcode):
"""Selects the specified character (int or str)."""
if not isinstance(charcode, int):
charcode = ord(charcode)
if not self._range[0] <= charcode <= self._range[1]:
charcode = -1
if self._selected != charcode:
self._selected = charcode
self.characterSelected.emit(chr(charcode))
self.update()
def character(self):
"""Returns the currently selected character, if any."""
if self._selected != -1:
return chr(self._selected)
def setDisplayFont(self, font):
self._font.setFamily(font.family())
self.update()
def displayFont(self):
return QFont(self._font)
def setDisplayFontSize(self, size):
self._font.setPointSize(size)
self._square = max(24, QFontMetrics(self._font).xHeight() * 3)
self.adjustSize()
self.update()
def displayFontSize(self):
return self._font.pointSize()
def setDisplayFontSizeF(self, size):
self._font.setPointSizeF(size)
self._square = max(24, QFontMetrics(self._font).xHeight() * 3)
self.adjustSize()
self.update()
def displayFontSizeF(self):
return self._font.pointSizeF()
def setColumnCount(self, count):
"""Sets how many columns should be used."""
count = max(1, count)
self._column_count = count
self.adjustSize()
self.update()
def columnCount(self):
return self._column_count
def sizeHint(self):
return self.sizeForColumnCount(self._column_count)
def paintEvent(self, ev):
rect = ev.rect()
s = self._square
rows = range(rect.top() // s, rect.bottom() // s + 1)
cols = range(rect.left() // s, rect.right() // s + 1)
painter = QPainter(self)
painter.setPen(QPen(self.palette().color(QPalette.Window)))
painter.setFont(self._font)
metrics = QFontMetrics(self._font)
# draw characters on white tiles
tile = self.palette().color(QPalette.Base)
selected_tile = self.palette().color(QPalette.Highlight)
selected_tile.setAlpha(96)
selected_box = self.palette().color(QPalette.Highlight)
text_pen = QPen(self.palette().text().color())
disabled_pen = QPen(self.palette().color(QPalette.Disabled, QPalette.Text))
selection_pen = QPen(selected_box)
for row in rows:
for col in cols:
char = row * self._column_count + col + self._range[0]
if char > self._range[1]:
break
printable = self.isprint(char)
painter.setClipRect(col * s, row * s, s, s)
if char == self._selected:
painter.fillRect(col * s + 1, row * s + 1, s - 2, s - 2, selected_tile)
painter.setPen(selection_pen)
painter.drawRect(col * s, row * s, s - 1, s - 1)
elif printable:
painter.fillRect(col * s + 1, row * s + 1, s - 2, s - 2, tile)
painter.setPen(text_pen if printable else disabled_pen)
t = chr(char)
x = col * s + s // 2 - metrics.width(t) // 2
y = row * s + 4 + metrics.ascent()
painter.drawText(x, y, t)
else:
continue
break
def sizeForColumnCount(self, count):
"""Returns the size the widget would have in a certain column count.
This can be used in e.g. a resizable scroll area.
"""
first, last = self._range
rows = ((last - first) // count) + 1
return QSize(count, rows) * self._square
def columnCountForWidth(self, width):
"""Returns the number of columns that would fit into the given width."""
return width // self._square
def mousePressEvent(self, ev):
charcode = self.charcodeAt(ev.pos())
if charcode != -1 and self.isprint(charcode):
self.select(charcode)
if ev.button() != Qt.RightButton:
self.characterClicked.emit(chr(charcode))
def charcodeRect(self, charcode):
"""Returns the rectangular box around the given charcode, if any."""
if self._range[0] <= charcode <= self._range[1]:
row, col = divmod(charcode - self._range[0], self._column_count)
s = self._square
return QRect(col * s, row * s, s, s)
def charcodeAt(self, position):
row = position.y() // self._square
col = position.x() // self._square
if col <= self._column_count:
charcode = self._range[0] + row * self._column_count + col
if charcode <= self._range[1]:
return charcode
return -1
def event(self, ev):
if ev.type() == QEvent.ToolTip:
if self._showToolTips:
c = self.charcodeAt(ev.pos())
if c:
text = self.getToolTipText(c)
if text:
rect = self.charcodeRect(c)
QToolTip.showText(ev.globalPos(), text, self, rect)
ev.accept()
return True
elif ev.type() == QEvent.QueryWhatsThis:
if self._showWhatsThis:
ev.accept()
return True
elif ev.type() == QEvent.WhatsThis:
ev.accept()
if self._showWhatsThis:
c = self.charcodeAt(ev.pos())
text = self.getWhatsThisText(c) if c else None
if text:
QWhatsThis.showText(ev.globalPos(), text, self)
else:
QWhatsThis.leaveWhatsThisMode()
return True
return super(CharMap, self).event(ev)
def getToolTipText(self, charcode):
try:
return unicodedata.name(chr(charcode))
except ValueError:
pass
def getWhatsThisText(self, charcode):
try:
name = unicodedata.name(chr(charcode))
except ValueError:
return
return whatsthis_html.format(
self._font.family(), chr(charcode), name, charcode)
def setShowToolTips(self, enabled):
self._showToolTips = bool(enabled)
def showToolTips(self):
return self._showToolTips
def setShowWhatsThis(self, enabled):
self._showWhatsThis = bool(enabled)
def showWhatsThis(self):
return self._showWhatsThis
def isprint(self, charcode):
"""Returns True if the given charcode is printable."""
return isprint(charcode)
