def draw_letters(self, cell_width: float, cell_height: float,
left_border: int, top_border: int, painter: QPainter):
font = painter.font()
font_size = round(top_border * 0.99)
font.setPixelSize(font_size)
painter.setFont(font)
ascii_code = ord('A')
for i in range(self.rows):
for j in range(self.cols):
letter = chr(ascii_code)
x = round(left_border + j * cell_width)
y = round(top_border + i * cell_height)
w = round(cell_width)
h = round(cell_height)
if i == 0:
y = top_border - font_size
h = font_size
elif i == self.rows - 1:
y = self.rect.height() - top_border
h = font_size
elif j == 0:
x = left_border - font_size
w = font_size
elif j == self.cols - 1:
x = self.rect.width() - left_border
w = font_size
else:
x = y = w = h = 0
if w != 0:
painter.drawText(x, y, w, h, Qt.AlignmentFlag.AlignCenter,
letter)
ascii_code += 1
def paintEvent(self, event: QtGui.QPaintEvent) -> None:
painter = QPainter(self)
#painter.setPen(QPen(Qt.blue, 1, Qt.DashLine))
# Create transformation for text and other things that will be drawn
transform = QTransform()
# Rotation
shiftX = self.width() // 2
shiftY = self.height() // 2
transform.translate(shiftX, shiftY)
transform.rotate(self._rotate)
transform.translate(-shiftX, -shiftY)
# Scale, NOTICE! Scale change position of the text, i. e. size of frame (?)
scale_x = self._scale[0] / 100
scale_y = self._scale[1] / 100
transform.scale(scale_x, scale_y)
# Apply transformation
painter.setTransform(transform)
# Draw text
painter.setFont(QFont('Times', 20, QFont.Bold))
painter.setPen(
QPen(
QColor(random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)),
1
)
)
# Because of the scale size of the frame is changed, recalculate size according to scale
width_tr = int(self.width() * (1 / scale_x))
height_tr = int(self.height() * (1 / scale_y))
painter.drawText(0, 0, width_tr, height_tr, Qt.AlignCenter | Qt.AlignTop, self._text)
# Update transformation variables
self._rotate += self._addRotation
self._scale[0] += self._addScale[0]
self._scale[1] += self._addScale[1]
# Check bounds and keep variable in the loop
if self._rotate >= max(self._rotationBounds) or self._rotate <= min(self._rotationBounds):
self._addRotation *= (-1)
if self._scale[0] >= max(self._scaleBounds[0]) or self._scale[0] <= min(self._scaleBounds[0]):
self._addScale[0] *= (-1)
if self._scale[1] >= max(self._scaleBounds[1]) or self._scale[1] <= min(self._scaleBounds[1]):
self._addScale[1] *= (-1)
def __init__(self):
# Sidebar icons are 28x28 points. Should be at least 56x56 pixels for
# HiDPI display compatibility. They will be automatically made theme
# aware, so you need only provide a grayscale image, where white is
# the color of the shape.
icon = QImage(56, 56, QImage.Format_RGB32)
icon.fill(0)
# Render an "H" as the example icon
p = QPainter()
p.begin(icon)
p.setFont(QFont("Open Sans", 56))
p.setPen(QColor(255, 255, 255, 255))
p.drawText(QRectF(0, 0, 56, 56), Qt.AlignCenter, "H")
p.end()
SidebarWidgetType.__init__(self, icon, "Hello")
def drawText(self, p: QPainter, innerRect: QRectF, innerRadius: float,
value: float):
if not self.m_format:
return
f = QFont(self.font())
f.setPixelSize(10)
fm = QFontMetricsF(f)
maxWidth = fm.width(self.valueToText(self.m_max))
delta = innerRadius / maxWidth
fontSize = f.pixelSize() * delta * 0.75
f.setPixelSize(int(fontSize))
p.setFont(f)
textRect = QRectF(innerRect)
p.setPen(self.palette().text().color())
p.drawText(textRect, Qt.AlignCenter, self.valueToText(value))
def paintEvent(self, e):
"(re)draw everything inside the rectangle associated with event e"
if self.model is not None:
# get the painting area:
w = QPainter(self.viewport())
f = self.font()
w.setFont(f)
# get rectangle that needs paint:
r = e.rect()
# get line indices for this rectangle:
line0 = self.vb.value()
h = self.line.height
first = line0 + r.top() // h
last = line0 + r.bottom() // h
count = last - first
# update drawing:
self.paintlines(w, first, count, line0)
self.paintframes(w)
self.paintmap(w)
def paintEvent(self, event):
painter = QPainter(self)
painter.fillRect(event.rect(), self.numberBarColor)
block = self.editor.firstVisibleBlock()
# Iterate over all visible text blocks in the document.
while block.isValid():
blockNumber = block.blockNumber()
block_top = self.editor.blockBoundingGeometry(
block).translated(self.editor.contentOffset()).top()
# Check if the position of the block is out side of the visible area.
if not block.isVisible() or block_top >= event.rect().bottom():
break
# We want the line number for the selected line to be bold.
if blockNumber == self.editor.textCursor().blockNumber():
self.font.setBold(True)
painter.setPen(bnstyles["blockSelected"])
else:
self.font.setBold(False)
painter.setPen(bnstyles["blockNormal"])
painter.setFont(self.font)
# Draw the line number right justified at the position of the line.
paint_rect = QRect(0, block_top, self.width(),
self.editor.fontMetrics().height())
painter.drawText(paint_rect, Qt.AlignLeft,
str(blockNumber + 1))
block = block.next()
painter.end()
QWidget.paintEvent(self, event)
def paintEvent(self, ev):
# print("Radio paintEventCalled")
# print("size =", self.paintSize)
opt = QStyleOption()
opt.initFrom(self)
painter = QPainter(self)
# print("minimum size : ", self.minimumSize())
# print("radio: hasHforW : ", self.hasHeightForWidth())
# print("radio: size : ", self.size())
# print("radio : minimumSizeHint() :", self.minimumSizeHint())
# s = self.style()
# s.drawPrimitive(QStyle.PE_Widget, opt, painter, self)
# self.computeSize()
size = self.paintSize
# size = np.min([1/8 * self.width(), self.height()/4])
fontsizefactor = self.fontsizefactor
linewidth = 1
painter.setRenderHint(QPainter.Antialiasing)
pointColor = QColor(painter.pen().color())
bgColor = QColor(painter.background().color())
# bgColor = QColor("white")
painter.setBrush(QBrush(QColor("transparent")))
painter.setPen(QPen(QColor(pointColor), linewidth))
# painter.setBackgroundMode(Qt.TransparentMode)
center = QtCore.QPoint(int(self.width() / 2), int(self.height() / 2))
self.center = center
self.radius = size
painter.drawEllipse(center, size, size)
margin = .4 * size
# painter.drawRect(text_rect)
# self.text()
fontsize = size * fontsizefactor
# self.fontsize = fontsize
f = painter.font()
f.setPointSizeF(fontsize)
painter.setFont(f)
text_rect = QRectF(center.x() + size + margin,
center.y() - fontsize, 100, 2 * fontsize)
# painter.drawRect(text_rect)
painter.drawText(text_rect, Qt.AlignLeft | Qt.AlignVCenter,
self.text())
self.textRect = text_rect
if self.isChecked():
painter.setBrush(QBrush(QColor(int(colors[self._ID], 0))))
# painter.setPen(QPen(Qt.NoPen))
painter.drawEllipse(center, size, size)
# painter.drawLine(QtCore.QPointF(self.width()/2, 0), QtCore.QPointF(self.width()/2, self.height()))
pass
class ScreenSelection(QtWidgets.QGroupBox):
def __init__(self, parent: DisplayCalibration):
QtWidgets.QGroupBox.__init__(self,
'Fullscreen selection (double click)')
self.main = parent
self.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding,
QtWidgets.QSizePolicy.Policy.Expanding)
self.painter = QPainter()
def mouseDoubleClickEvent(self, ev, *args, **kwargs):
for screen_id, screen_coords in enumerate(
self._get_widget_screen_coords()):
rect = QtCore.QRectF(*screen_coords)
if not rect.contains(QtCore.QPoint(ev.pos().x(), ev.pos().y())):
continue
print(f'Set display to fullscreen on screen {screen_id}')
screen = access.application.screens()[screen_id]
px_ratio = screen.devicePixelRatio()
self.main.global_settings.screen_id.set_value(screen_id)
self.main.global_settings.win_x_pos.set_value(
screen.geometry().x())
self.main.global_settings.win_y_pos.set_value(
screen.geometry().y())
self.main.global_settings.win_width.set_value(
int(screen.geometry().width() * px_ratio))
self.main.global_settings.win_height.set_value(
int(screen.geometry().height() * px_ratio))
access.application.processEvents()
@staticmethod
def _get_norm_screen_coords() -> np.ndarray:
# Get connected screens
avail_screens = access.application.screens()
# Calculate total display area bounding box
area = [[
s.geometry().width() * s.devicePixelRatio(),
s.geometry().height() * s.devicePixelRatio()
] for s in avail_screens]
area = np.sum(area, axis=0)
xmin = np.min([s.geometry().x() for s in avail_screens])
ymin = np.min([s.geometry().y() for s in avail_screens])
# Define normalization functions
xnorm = lambda x: (x - xmin) / area[0]
ynorm = lambda y: (y - ymin) / area[1]
# Add screen dimensions
screens = []
for s in avail_screens:
g = s.geometry()
screens.append([
xnorm(g.x() * s.devicePixelRatio()), # x
ynorm(g.y() * s.devicePixelRatio()), # y
xnorm(g.width() * s.devicePixelRatio()), # width
ynorm(g.height() * s.devicePixelRatio())
]) # height
return np.array(screens)
def _get_widget_screen_coords(self):
s = self._get_norm_screen_coords()
s[:, 0] *= self.size().width()
s[:, 1] *= self.size().height()
s[:, 2] *= self.size().width()
s[:, 3] *= self.size().height()
return s.astype(int)
def paintEvent(self, QPaintEvent):
for i, screen in enumerate(self._get_widget_screen_coords()):
rect = QtCore.QRect(*screen)
self.painter.begin(self)
self.painter.setBrush(QtCore.Qt.BrushStyle.Dense4Pattern)
self.painter.drawRect(rect)
self.painter.setPen(QColor(168, 34, 3))
self.painter.setFont(QFont('Decorative', 30))
self.painter.drawText(rect, QtCore.Qt.AlignmentFlag.AlignCenter,
str(i))
self.painter.end()
def paintEvent(self, event):
paint = QPainter()
paint.begin(self)
paint.save()
size = self.size()
width = size.width()
height = size.height()
units = self.data.get('units')
proportion = self.getProportion()
horizontalOrientation = self.data.get('horizontal_orientation')
if horizontalOrientation:
rulerLength = width
traceLengthLimit = height
else: # vertical orientation
rulerLength = height
traceLengthLimit = width
paint.translate(width, 0)
paint.rotate(90)
# the length of the traces (lines)
small = traceLengthLimit / 6
medium = traceLengthLimit / 4
large = traceLengthLimit / 3
limit = rulerLength / proportion
# draw less lines for centimeters
if units == 'cm':
step = 10
else:
step = 5
# begin drawing
fontSize = 10
font = QFont('Serif', fontSize)
fontMetrics = QFontMetrics(font)
# draw background
background = self.data.get('background_color')
paint.fillRect(0, 0, rulerLength, traceLengthLimit, background)
# draw the lines
paint.setPen(self.data.get('lines_color'))
paint.setFont(font)
# the builtin range() doesn't support floats
def float_range(current, end, rangeStep):
while current < end:
yield current
current += rangeStep
# we skip 0 and start in the first step, since there's no point in drawing the first line/text (it would appear cut off, since we're at the limit)
for a in float_range(step, limit, step):
position = a * proportion
if (a % 100) == 0:
lineLength = large
if units == 'px':
text = '{}{}'.format(str(a), units)
else:
text = '{}{}'.format(str(int(a / 100)), units)
textWidth = fontMetrics.boundingRect(text).width()
paint.drawText(position - textWidth / 2,
traceLengthLimit / 2 + fontSize / 2, text)
elif (a % 50) == 0:
lineLength = large
# since 'cm' has a different step compared to the other units
if units == 'cm':
lineLength = medium
elif (a % 25) == 0:
lineLength = medium
else:
lineLength = small
paint.drawLine(position, 0, position, lineLength)
paint.drawLine(position, traceLengthLimit, position,
traceLengthLimit - lineLength)
# paint the division lines
if self.data.get('division_lines'):
paint.setPen(self.data.get('divisions_color'))
halfPoint = rulerLength / 2
quarterPoint = rulerLength / 4
threeQuarterPoint = 3 / 4 * rulerLength
paint.drawLine(quarterPoint, 0, quarterPoint, traceLengthLimit)
paint.drawLine(halfPoint, 0, halfPoint, traceLengthLimit)
paint.drawLine(threeQuarterPoint, 0, threeQuarterPoint,
traceLengthLimit)
paint.restore()
paint.end()
def paintEvent(self, ev):
p = QPainter(self)
p.setFont(self.font)
#p.fillRect(self.rect(), QBrush(Qt.blue))
length = len(self.display_data)
# Reduce to the number of lines that are available in the data
num_rows = length // self.bytes_per_line
if length % self.bytes_per_line > 0:
num_rows += 1
for l in range(num_rows):
p.setPen(self.label_color)
# Draw address label
# self.instance.get_local_label(self.start_offset + l * self.bytes_per_line)
position_string = self.display_labels[l]
p.drawText(QPoint(self.label_offset_x, (l + 1) * self.line_height),
position_string)
for i in range(
0,
min(self.bytes_per_line,
length - self.bytes_per_line * l)):
#virtual_address = self.start_offset + l*self.bytes_per_line + i
p.setPen(self.byte_color)
current_byte = self.display_data[i + l * self.bytes_per_line]
if current_byte.background is not None:
p.setBackground(current_byte.background)
p.setBackgroundMode(Qt.OpaqueMode)
p.drawText(
QPoint(self.label_length + i * self.byte_width,
(l + 1) * self.line_height), current_byte.text)
p.setBackgroundMode(Qt.TransparentMode)
# Draw selection rects
if current_byte.is_selected:
p.setPen(self.selection_color)
p.drawRect(
# TODO make these offsets configurable/dependent on font?
self.label_length + i * self.byte_width - 3,
(l) * self.line_height + 3,
self.byte_width,
self.line_height)
# Draw annotation underlines
if len(current_byte.annotations) > 0:
y_offset = 0
for annotation in current_byte.annotations:
self.annotation_pen.setColor(annotation.color)
p.setPen(self.annotation_pen)
x = self.label_length + i * self.byte_width
y = (l + 1) * self.line_height + y_offset + 2
p.drawLine(x, y, x + self.byte_width, y)
y_offset += 2
# Draw constraint pipes
if len(current_byte.constraints) > 0:
enabled = False
for constraint in current_byte.constraints:
if constraint.enabled:
enabled = True
break
if enabled:
p.setPen(self.enabled_constraint_pen)
else:
p.setPen(self.disabled_constraint_pen)
x = self.label_length + i * self.byte_width - 2
y = (l) * self.line_height + 3
p.drawLine(x, y, x, y + self.line_height)
def paintEvent(self, pe) -> None:
if not self.inhibit_paint:
extent = 1.5 * np.pi
offset = 1.25 * np.pi
painter = QPainter(self)
# So that we can use the background color
painter.setBackgroundMode(Qt.OpaqueMode)
# Smooth out the circle
painter.setRenderHint(QPainter.Antialiasing)
# Use background color
bgColor = painter.background().color()
painter.setBrush(painter.background())
if self._text not in implementedKnobs:
painter.setBrush(QtGui.QBrush(QtGui.QColor(int("0xcccccc",
0))))
# Store color from stylesheet, pen will be overridden
pointColor = QColor(painter.pen().color())
# print(QDial.width(self), QDial.height(self))
# draw widget borders
pen = QPen(QColor(self._ringColor), 1)
pen.setCapStyle(Qt.SquareCap)
painter.setPen(pen)
# uncomment the following line to draw outer rect
# painter.drawRect(0, 0, np.floor(QDial.width(self)), QDial.height(self))
# No border
painter.setPen(QPen(Qt.NoPen))
# the heignt of the widget is 2*radius + 2*fontsize1 + 2*fontsize2
# where fontsize1 = .4radius and fontsize2 = .9*.4*radius
# so QDial.height = radius * (2+.4*2+.4*.9*2)
#
fontsize1factor = .4
fontsize2reduction = .9
fontsize2factor = fontsize1factor * fontsize2reduction
center_x = QDial.width(self) / 2.0
center_y = QDial.height(self) / 2.0
if not self._hasFixedSize:
if not self._hasFixedFontSize:
radius = np.min(
(QDial.width(self) / 2. - self._knobMargin,
QDial.height(self) /
(2. + 2 * fontsize1factor + 2 * fontsize2factor) -
self._knobMargin))
radius = np.max((radius, 1))
# print("Radius = ", radius, ", height = ", QDial.height(self), ", width = ", QDial.width(self))
center_y = center_y - radius * (fontsize1factor +
fontsize2factor)
else:
radius = np.min(
(QDial.width(self) / 2. - self._knobMargin,
(QDial.height(self) - 4 * self._fixedFontSize) / 2. -
self._knobMargin))
radius = np.max((radius, 1))
center_y = center_y - (self._fixedFontSize *
(1 + fontsize2reduction))
else:
radius = self._fixedSize / 2.
radius = np.max((radius, 1))
center_y = center_y - radius * (fontsize1factor +
fontsize2factor)
self.radius = radius
# Draw arc
rectangle = QtCore.QRectF(center_x - radius, center_y - radius,
2 * radius, 2 * radius)
"""The startAngle and spanAngle must be specified in 1/16th of a degree,
i.e. a full circle equals 5760 (16 * 360).
Positive values for the angles mean counter-clockwise
while negative values mean the clockwise direction.
Zero degrees is at the 3 o'clock position."""
linewidth = radius / 30. * 2
# linewidth = 1
pen = QPen(QColor(self._ringColor), linewidth)
pen.setCapStyle(Qt.RoundCap)
# pen.setCapStyle(Qt.FlatCap)
painter.setPen(pen)
# adapt to linewidth to make it more pleasant to the eye
capRadius = linewidth / 4
angleCap = np.arcsin(capRadius / radius)
start_deg = (90 - np.rad2deg(extent / 2)) + np.rad2deg(angleCap)
start_16deg = start_deg * 16
extent_deg = np.rad2deg(extent) - 2 * np.rad2deg(angleCap)
extent_16deg = extent_deg * 16
painter.drawArc(rectangle, start_16deg, extent_16deg)
#draw inner circle
pen = QPen(QColor(pointColor), linewidth)
pen.setCapStyle(Qt.RoundCap)
painter.setPen(pen)
painter.setBrush(QtGui.QColor(bgColor))
radius_inner = 15. / 20. * radius
painter.drawEllipse(QtCore.QPointF(center_x, center_y),
radius_inner, radius_inner)
self.center = QtCore.QPointF(center_x, center_y)
"""
# Get ratio between current value and maximum to calculate angle
if (param != NULL):
if (param->value != this->value())
param->setValue(this->value())
"""
ratio = (QDial.value(self) - QDial.minimum(self)) / (
QDial.maximum(self) - QDial.minimum(self))
# The maximum amount of degrees is 270, offset by 225
angle = ratio * extent - offset
# Draw the indicator
painter.setBrush(QBrush(pointColor))
a_y = center_y + np.sin(angle) * (radius - .1)
a_x = center_x + np.cos(angle) * (radius - .1)
pen = QPen(pointColor, linewidth)
pen.setCapStyle(Qt.RoundCap)
painter.setPen(pen)
painter.drawLine(a_x, a_y, np.round(center_x), center_y)
if not self._hasFixedFontSize:
fontsize1 = radius * fontsize1factor
if self.sizeType == 1 and fontsize1 != Knob.fontsize1:
Knob.fontsize1 = fontsize1
else:
fontsize1 = Knob.fontsize1
fontsize2 = fontsize1 * fontsize2reduction
else:
fontsize1 = self._fixedFontSize
fontsize2 = fontsize1 * fontsize2reduction
self.fontsize1 = fontsize1
textRect_ = QtCore.QRectF(0, center_y + radius, QDial.width(self),
2 * fontsize1)
if self.coloredTitle:
painter.setPen(QColor(int(titleColor, 0)))
f = painter.font()
f.setPointSizeF(fontsize1)
painter.setFont(f)
# painter.drawRect(textRect_)
painter.drawText(textRect_, Qt.AlignHCenter | Qt.AlignTop,
self._text)
# painter.drawText(textRect_, Qt.AlignHCenter | Qt.AlignTop, str(fontsize1))
textRect_ = QtCore.QRectF(0, center_y + radius + fontsize1 * 2,
QDial.width(self), 2 * fontsize2)
if self.hasFocus():
painter.setPen(QtGui.QColor("red"))
f.setPointSizeF(fontsize2)
painter.setFont(f)
# painter.drawRect(textRect_)
painter.drawText(textRect_, Qt.AlignHCenter | Qt.AlignTop,
str(QDial.value(self)))
painter.end()
def paintEvent(self, pe) -> None:
mainradius, fontsizefactor, center_x, center_y_pp, width = self.computeCenter(
)
painter = QPainter(self)
# So that we can use the background color
painter.setBackgroundMode(Qt.OpaqueMode)
# Smooth out the circle
painter.setRenderHint(QPainter.Antialiasing)
# Use background color
textBgColor = QColor(painter.background().color())
# print("bgcolor = ", bgColor)
bgColor = QColor("transparent")
pointColor = QColor(painter.pen().color())
self.pointColor = pointColor
self.bgColor = textBgColor
alpha = 150
if self.parent().displayPp == 'all' or self.parent(
).displayPp == self.io:
pointColor.setAlpha(255)
else:
pointColor.setAlpha(alpha)
# draw text
if not self._hasFixedFontSize:
fontsize = mainradius * fontsizefactor
else:
fontsize = self._fixedFontSize
self.fontsize = fontsize
textRect_ = QtCore.QRectF(0, center_y_pp - mainradius - 2 * fontsize,
width, 2 * fontsize)
f = painter.font()
f.setPointSizeF(fontsize)
# self._io = 'in'
if self.io == 'out':
fm = QFontMetrics(f).boundingRect(self._text)
# print("fm = ", fm)
painter.setBrush(pointColor)
painter.setPen(QPen(pointColor))
painter.drawRect(
QtCore.QRectF(center_x - fm.width() / 2,
center_y_pp - mainradius - 2 * fontsize,
fm.width(), fm.height()))
painter.setPen(QPen(textBgColor))
painter.setFont(f)
painter.setBackgroundMode(Qt.TransparentMode)
painter.drawText(textRect_, Qt.AlignHCenter | Qt.AlignTop, self._text)
# draw hexagon
painter.setBrush(bgColor)
painter.setPen(pointColor)
painter.drawPolygon(
self.createPoly(6, mainradius, center_x, center_y_pp))
# draw outer circle
radius_outer = mainradius * .8
if self.title not in implementedPatchPoints:
painter.setBrush(QtGui.QBrush(QtGui.QColor(int("0x999999", 0))))
painter.drawEllipse(QtCore.QPointF(center_x, center_y_pp),
radius_outer, radius_outer)
# draw inner circle
radius_inner = mainradius * .5
# painter.setBrush(QBrush(pointColor))
painter.setBrush(QColor(self._ppColor))
painter.drawEllipse(QtCore.QPointF(center_x, center_y_pp),
radius_inner, radius_inner)