def setupBarChartDemo(self):
self.demoName = "Bar Chart Demo"
# set dark background gradient:
gradient = QLinearGradient(0, 0, 0, 400)
gradient.setColorAt(0, QColor(90, 90, 90))
gradient.setColorAt(0.38, QColor(105, 105, 105))
gradient.setColorAt(1, QColor(70, 70, 70))
self.customPlot.setBackground(QBrush(gradient))
# create empty bar chart objects:
regen = QCustomPlot.QCPBars(self.customPlot.xAxis, self.customPlot.yAxis)
nuclear = QCustomPlot.QCPBars(self.customPlot.xAxis, self.customPlot.yAxis)
fossil = QCustomPlot.QCPBars(self.customPlot.xAxis, self.customPlot.yAxis)
regen.setAntialiased(False) # gives more crisp, pixel aligned bar borders
nuclear.setAntialiased(False)
fossil.setAntialiased(False)
regen.setStackingGap(1)
nuclear.setStackingGap(1)
fossil.setStackingGap(1)
# set names and colors:
fossil.setName("Fossil fuels")
fossil.setPen(QPen(QColor(111, 9, 176).lighter(170)))
fossil.setBrush(QColor(111, 9, 176))
nuclear.setName("Nuclear")
nuclear.setPen(QPen(QColor(250, 170, 20).lighter(150)))
nuclear.setBrush(QColor(250, 170, 20))
regen.setName("Regenerative")
regen.setPen(QPen(QColor(0, 168, 140).lighter(130)))
regen.setBrush(QColor(0, 168, 140))
# stack bars on top of each other:
nuclear.moveAbove(fossil)
regen.moveAbove(nuclear)
# prepare x axis with country labels:
ticks = [float(i) for i in range(1, 8)]
labels = ["USA", "Japan", "Germany", "France", "UK", "Italy", "Canada"]
textTicker = QCustomPlot.QCPAxisTickerText()
textTicker.addTicks(ticks, labels)
self.customPlot.xAxis.setTicker(textTicker)
self.customPlot.xAxis.setTickLabelRotation(60)
self.customPlot.xAxis.setSubTicks(False)
self.customPlot.xAxis.setTickLength(0, 4)
self.customPlot.xAxis.setRange(0, 8)
self.customPlot.xAxis.setBasePen(QPen(Qt.white))
self.customPlot.xAxis.setTickPen(QPen(Qt.white))
self.customPlot.xAxis.grid().setVisible(True)
self.customPlot.xAxis.grid().setPen(QPen(QColor(130, 130, 130), 0, Qt.DotLine))
self.customPlot.xAxis.setTickLabelColor(Qt.white)
self.customPlot.xAxis.setLabelColor(Qt.white)
# prepare y axis:
self.customPlot.yAxis.setRange(0, 12.1)
self.customPlot.yAxis.setPadding(5) # a bit more space to the left border
self.customPlot.yAxis.setLabel("Power Consumption in\nKilowatts per Capita (2007)")
self.customPlot.yAxis.setBasePen(QPen(Qt.white))
self.customPlot.yAxis.setTickPen(QPen(Qt.white))
self.customPlot.yAxis.setSubTickPen(QPen(Qt.white))
self.customPlot.yAxis.grid().setSubGridVisible(True)
self.customPlot.yAxis.setTickLabelColor(Qt.white)
self.customPlot.yAxis.setLabelColor(Qt.white)
self.customPlot.yAxis.grid().setPen(QPen(QColor(130, 130, 130), 0, Qt.SolidLine))
self.customPlot.yAxis.grid().setSubGridPen(QPen(QColor(130, 130, 130), 0, Qt.DotLine))
# Add data:
fossilData = [0.86*10.5, 0.83*5.5, 0.84*5.5, 0.52*5.8, 0.89*5.2, 0.90*4.2, 0.67*11.2]
nuclearData = [0.08*10.5, 0.12*5.5, 0.12*5.5, 0.40*5.8, 0.09*5.2, 0.00*4.2, 0.07*11.2]
regenData = [0.06*10.5, 0.05*5.5, 0.04*5.5, 0.06*5.8, 0.02*5.2, 0.07*4.2, 0.25*11.2]
fossil.setData(ticks, fossilData)
nuclear.setData(ticks, nuclearData)
regen.setData(ticks, regenData)
# setup legend:
self.customPlot.legend.setVisible(True)
self.customPlot.axisRect().insetLayout().setInsetAlignment(0, Qt.AlignTop|Qt.AlignHCenter)
self.customPlot.legend.setBrush(QColor(255, 255, 255, 100))
self.customPlot.legend.setBorderPen(QPen(Qt.NoPen))
legendFont = self.font()
legendFont.setPointSize(10)
self.customPlot.legend.setFont(legendFont)
self.customPlot.setInteractions(QCustomPlot.QCP.Interactions(QCP.iRangeDrag | QCP.iRangeZoom))
def paintEvent(self, e):
"""
draw pixmap as a the background with a dark overlay
HELP: currently, this cost much CPU
"""
if self._pixmap is None:
return
painter = QPainter(self)
painter.setPen(Qt.NoPen)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
# calculate available size
draw_width = self.width()
draw_height = self.bottom_panel.height()
if self.table_container.meta_widget.isVisible():
draw_height += self.table_container.meta_widget.height()
if self.table_container.toolbar.isVisible():
draw_height += self.table_container.toolbar.height()
scrolled = self.scrollarea.verticalScrollBar().value()
max_scroll_height = draw_height - self.bottom_panel.height()
if scrolled >= max_scroll_height:
painter.save()
painter.setBrush(self.palette().brush(QPalette.Window))
painter.drawRect(self.rect())
painter.restore()
return
# scale pixmap
scaled_pixmap = self._pixmap.scaledToWidth(
draw_width, mode=Qt.SmoothTransformation)
pixmap_size = scaled_pixmap.size()
# draw the center part of the pixmap on available rect
painter.save()
brush = QBrush(scaled_pixmap)
painter.setBrush(brush)
# note: in practice, most of the time, we can't show the
# whole artist pixmap, as a result, the artist head will be cut,
# which causes bad visual effect. So we render the top-center part
# of the pixmap here.
y = (pixmap_size.height() - draw_height) // 3
painter.translate(0, -y - scrolled)
rect = QRect(0, y, draw_width, draw_height)
painter.drawRect(rect)
# draw overlay
gradient = QLinearGradient(rect.topLeft(), rect.bottomLeft())
color = self.palette().color(QPalette.Base)
if draw_height == self.height():
gradient.setColorAt(0, add_alpha(color, 180))
gradient.setColorAt(1, add_alpha(color, 230))
else:
gradient.setColorAt(0, add_alpha(color, 50))
gradient.setColorAt(0.6, add_alpha(color, 100))
gradient.setColorAt(0.8, add_alpha(color, 200))
gradient.setColorAt(0.9, add_alpha(color, 240))
gradient.setColorAt(1, color)
painter.setBrush(gradient)
painter.drawRect(rect)
painter.restore()
painter.end()
def paintGraph(self, graph, painter):
brush = QBrush(Qt.SolidPattern)
pen = QPen()
brush.setColor(Qt.white)
for i, edge in enumerate(graph.edges):
if ("color" in edge.kwargs.keys()):
pen.setColor(QColor(edge.kwargs["color"]))
else:
pen.setColor(QColor("black"))
if ("width" in edge.kwargs.keys()):
pen.setWidth(int(edge.kwargs["width"]))
else:
pen.setWidth(1)
painter.setPen(pen)
painter.setBrush(brush)
if (edge.source.parent_graph != graph and not self.show_subgraphs):
gspos = edge.source.parent_graph.global_pos
else:
gspos = edge.source.global_pos
if (edge.dest.parent_graph != graph and not self.show_subgraphs):
gspos = edge.dest.parent_graph.global_pos
else:
gdpos = edge.dest.global_pos
nb_next = 0
for j in range(i, len(graph.edges)):
if (graph.edges[j].source == edge.source
and graph.edges[j].dest == edge.dest):
nb_next += 1
offset = [0, 0]
if (nb_next % 2 == 1):
offset[0] = 20 * (nb_next / 2)
else:
offset[0] = -20 * (nb_next / 2)
path = QPainterPath()
path.moveTo(gspos[0], gspos[1])
path.cubicTo(gspos[0], gspos[1],
offset[0] + (gspos[0] + gdpos[0]) / 2,
(gspos[1] + gdpos[1]) / 2, gdpos[0], gdpos[1])
painter.strokePath(path, pen)
"""
painter.drawLine(gspos[0],gspos[1],
gdpos[0],
gdpos[1])
"""
if (self.show_subgraphs):
for node in graph.nodes:
if type(node) == Graph:
subgraph = node
self.paintSubgraph(subgraph, painter, pen, brush)
# TODO : add more painting parameters
for node in graph.nodes:
if type(node) != Graph:
if ("color" in node.kwargs.keys()):
pen.setColor(QColor(node.kwargs["color"]))
else:
pen.setColor(QColor("black"))
if ("fillcolor" in node.kwargs.keys()):
if (":" in node.kwargs["fillcolor"]):
gradient = QLinearGradient(
node.pos[0] - node.size[0] / 2, node.pos[1],
node.pos[0] + node.size[0] / 2, node.pos[1])
c = node.kwargs["fillcolor"].split(":")
for i, col in enumerate(c):
stop = i / (len(c) - 1)
gradient.setColorAt(stop, QColor(col))
brush = QBrush(gradient)
else:
brush = QBrush(QColor(node.kwargs["fillcolor"]))
else:
brush = QBrush(QColor("white"))
if ("width" in node.kwargs.keys()):
pen.setWidth(int(node.kwargs["width"]))
else:
pen.setWidth(1)
gpos = node.global_pos
painter.setPen(pen)
painter.setBrush(brush)
if ("shape" in node.kwargs.keys()):
if (node.kwargs["shape"] == "box"):
painter.drawRect(gpos[0] - node.size[0] / 2,
gpos[1] - node.size[1] / 2,
node.size[0], node.size[1])
elif (node.kwargs["shape"] == "circle"):
painter.drawEllipse(gpos[0] - node.size[0] / 2,
gpos[1] - node.size[1] / 2,
node.size[0], node.size[1])
elif (node.kwargs["shape"] == "triangle"):
rect = QRect(gpos[0] - node.size[0] / 2,
gpos[1] - 2 * node.size[1] / 3,
node.size[0], node.size[1])
path = QPainterPath()
path.moveTo(rect.left() + (rect.width() / 2),
rect.top())
path.lineTo(rect.bottomLeft())
path.lineTo(rect.bottomRight())
path.lineTo(rect.left() + (rect.width() / 2),
rect.top())
painter.fillPath(path, brush)
painter.drawPath(path)
elif (node.kwargs["shape"] == "polygon"):
rect = QRect(gpos[0] - node.size[0] / 2,
gpos[1] - node.size[1] / 2, node.size[0],
node.size[1])
path = QPainterPath()
path.moveTo(rect.left() + (rect.width() / 4),
rect.top())
path.lineTo(rect.left() + 3 * rect.width() / 4,
rect.top())
path.lineTo(rect.left() + rect.width(),
rect.top() + rect.height() / 2)
path.lineTo(rect.left() + 3 * rect.width() / 4,
rect.top() + rect.height())
path.lineTo(rect.left() + rect.width() / 4,
rect.top() + rect.height())
path.lineTo(rect.left(),
rect.top() + rect.height() / 2)
path.lineTo(rect.left() + (rect.width() / 4),
rect.top())
painter.fillPath(path, brush)
painter.drawPath(path)
elif (node.kwargs["shape"] == "diamond"):
rect = QRect(gpos[0] - node.size[0] / 2,
gpos[1] - node.size[1] / 2, node.size[0],
node.size[1])
path = QPainterPath()
path.moveTo(rect.left() + (rect.width() / 2),
rect.top())
path.lineTo(rect.left() + rect.width(),
rect.top() + rect.height() / 2)
path.lineTo(rect.left() + rect.width() / 2,
rect.top() + rect.height())
path.lineTo(rect.left(),
rect.top() + rect.height() / 2)
path.lineTo(rect.left() + (rect.width() / 2),
rect.top())
painter.fillPath(path, brush)
painter.drawPath(path)
# Image as a node, this implementation checks to see if a
# file path was provided in the shape parameter
if (os.path.isfile(node.kwargs["shape"])):
img_path = node.kwargs["shape"]
painter.drawImage(
QRect(gpos[0] - node.size[0] / 2,
gpos[1] - node.size[1] / 2, node.size[0],
node.size[1]), QImage(img_path))
else:
painter.drawEllipse(gpos[0] - node.size[0] / 2,
gpos[1] - node.size[1] / 2,
node.size[0], node.size[1])
if ("label" in node.kwargs.keys()):
painter.drawText(gpos[0] - node.size[0] / 2,
gpos[1] - node.size[1] / 2, node.size[0],
node.size[1],
Qt.AlignCenter | Qt.AlignTop,
node.kwargs["label"])
else:
if (self.show_subgraphs):
self.paintGraph(subgraph, painter)
else:
subgraph = node
self.paintSubgraph(subgraph, painter, pen, brush)
def paintEvent(self, event: QPaintEvent):
_start = perf_counter()
num = self.num_tabs
selected = self.selected
arrow_width = self._arrow_width
height = self.height()
width = self._button_width
first_width = self._first_button_width
button = self._button_path
button_box = QRect(0, 0, width + arrow_width, height)
first_box = QRect(0, 0, first_width + arrow_width, height)
icon_area = QRect(arrow_width + 10, 0, max(48, width / 2), height)
text_box = QRect(arrow_width, 0, width - arrow_width, height)
text_flags = Qt.AlignCenter | Qt.AlignVCenter
states = self.states
painter = QPainter(self)
region = event.region()
painter.setClipRegion(region)
#torender = self._tabs_within(event.region())
#print("regions:")
#for rect in event.region().rects():
# print(" - ", rect)
#painter.setPen(Qt.NoPen)
painter.setPen(
QPen(Qt.black, 2, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
titleFont = painter.font()
titleFont.setPointSizeF(14)
titleFont.setBold(True)
painter.setFont(titleFont)
painter.translate(num * width + first_width, 0)
if region.intersects(painter.transform().mapRect(button_box)):
painter.setBrush(states[num].get_color(num == selected))
painter.drawPath(self._last_button_path)
for i in reversed(range(num)):
painter.translate(-width, 0)
if not region.intersects(painter.transform().mapRect(button_box)):
continue
painter.setBrush(states[i].get_color(i == selected))
painter.drawPath(button)
if states[i].state == State.ACTIVE:
painter.save()
painter.setPen(Qt.NoPen)
gw = (width + self._arrow_width) * 2
gradient = QLinearGradient(0, 0, gw, 0)
value = self._working_anim.value
gradient.setColorAt(max(0.0, value - 0.2),
QColor(255, 255, 255, 0))
gradient.setColorAt(value, QColor(255, 255, 255, 180))
gradient.setColorAt(min(1.0, value + 0.2),
QColor(255, 255, 255, 0))
brush = QBrush(gradient)
brush.setTransform(brush.transform().translate(-gw / 4, 0))
gradient_height = int(height * 0.2)
painter.setBrush(brush)
#painter.setClipRect(0, 0, width+self._arrow_width, gradient_height)
#painter.drawPath(button)
#painter.setClipRect(0, height-gradient_height, width+self._arrow_width, gradient_height)
painter.drawPath(button)
self._active_box = painter.transform().mapRect(button_box)
painter.restore()
#if states[i].icon:
# states[i].icon.paint(painter, icon_area)
text = states[i].text
if text:
_, _, short = text.rpartition('-')
painter.drawText(text_box, text_flags, short.capitalize())
if region.intersects(first_box):
painter.resetTransform()
painter.setBrush(State.UNKNOWN.get_color(-1 == selected))
painter.drawPath(self._first_button_path)
if self.is_running:
icon = self.style().standardIcon(QStyle.SP_MediaStop)
else:
icon = self.style().standardIcon(QStyle.SP_MediaPlay)
size = min(self._first_button_width, self.height()) * 0.8
painter.translate(5, (self.height() - size) / 2)
icon.paint(painter, QRect(0, 0, size, size))
_end = perf_counter()
if not self._paint_times:
self._paint_times = times = []
else:
times = self._paint_times
times.append(_end - _start)
if len(times) > 60:
avg = sum(times) / len(times) * 1000000
print("Average render time %.2fns" % (avg, ))
self._paint_times = None
def paint(self, painter):
# use antialiasing for both text and box
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
# get the opacity of the node item, layers with the include.phase parameter have a different opacity
opacity = Constants.itemOpacityInPhase
if not self.__nodeItem.getNodeEditor().isCurrentPhase(
self.__nodeItem.getPhase()):
opacity = Constants.itemOpacityNotInPhase
# draw a outer 'glow' around the node item if the node is selected
if self.__nodeItem.isSelected():
selectedColor = Constants.selectedColor
selectedColor.setAlpha(opacity)
painter.setPen(QPen(selectedColor,
Constants.nodeItemSelectionSize))
painter.drawRect(self.__rectAllSelected)
painter.fillRect(self.__rectAllSelected, QBrush(selectedColor))
# get the type color for the header (name and type)
typeColor = LayerColorDefinitions.getTypeColor(
self.__nodeItem.getType())
typeColor.setRgb(typeColor.red(), typeColor.green(), typeColor.blue(),
opacity)
# get background color
backgroundColor = Constants.itemBackgroundColorLight
backgroundColor.setAlpha(opacity)
# set a linear gradient for the header (type color -> background color)
gradient = QLinearGradient(0, self.__rectHead.top(), 0,
self.__rectHead.bottom())
gradient.setColorAt(0, typeColor)
gradient.setColorAt(0.5, backgroundColor)
# draw background and border for the header
painter.fillRect(self.__rectHead, QBrush(gradient))
# draw background for the blob area
painter.fillRect(self.__rectBlobArea, QBrush(backgroundColor))
borderColor = Constants.itemBorderColor
if self.__nodeItem.getIsInPlace():
borderColor = Constants.itemInPlaceColor
borderColor.setAlpha(opacity)
painter.setPen(QPen(borderColor, Constants.nodeItemBorderSize))
# draw outer border around the node
painter.drawRect(self.__rectAll)
# draw a line to separate header and connectors
borSize = Constants.nodeItemBorderSize
painter.setPen(QPen(borderColor, borSize))
painter.drawLine(self.__rectHead.left() + borSize / 2,
self.__rectHead.bottom() - borSize / 2,
self.__rectHead.right() - borSize / 2,
self.__rectHead.bottom() - borSize / 2)
painter.setPen(QPen(QColor(0, 0, 0, opacity)))
# draw text of header
if len(self.__headRects) > 1:
# align the first head text at the bottom to provide some space at the top
painter.setFont(self.__headRects[0].font)
painter.drawText(self.__headRects[0].rect,
Qt.AlignHCenter | Qt.AlignBottom,
self.__headRects[0].text)
# align other head texts at the center
for i in range(1, len(self.__headRects) - 1):
painter.setFont(self.__headRects[i].font)
painter.drawText(self.__headRects[i].rect, Qt.AlignCenter,
self.__headRects[i].text)
# align the last head text at the top to provide some space at the bottom
painter.setFont(self.__headRects[-1].font)
painter.drawText(self.__headRects[-1].rect,
Qt.AlignHCenter | Qt.AlignTop,
self.__headRects[-1].text)
# there is only one head text, so align it at the center
elif len(self.__headRects) == 1:
painter.setFont(self.__headRects[0].font)
painter.drawText(self.__headRects[0].rect,
Qt.AlignHCenter | Qt.AlignCenter,
self.__headRects[0].text)
# draw blob names
painter.setFont(Constants.nodeItemFontBlob)
for item in self.__blobBottomNameRects:
painter.drawText(item.rect, Qt.AlignVCenter | Qt.AlignLeft,
item.text)
for item in self.__blobTopNameRects:
painter.drawText(item.rect, Qt.AlignVCenter | Qt.AlignRight,
item.text)
def __init__(self, scatter):
super(ScatterDataModifier, self).__init__()
mesh_dir = QFileInfo(__file__).absolutePath() + '/Data/mesh'
self.m_graph = scatter # Q3DScatter 对象实例
self.m_rotationTimer = QTimer()
self.m_fieldLines = 12 # 初始磁场线数量
self.m_arrowsPerLine = 16 # 初始箭头数
self.m_magneticField = QScatter3DSeries() # 磁场线三维散点图
self.m_sun = QScatter3DSeries() # 太阳三维散点图
self.m_angleOffset = 0.0 # 角度偏移
self.m_angleStep = self.doublePi / self.m_arrowsPerLine / self.animationFrames
# 设置阴影质量
self.m_graph.setShadowQuality(QAbstract3DGraph.ShadowQualityNone)
# 设置当前场景中的激活的相机预设值
self.m_graph.scene().activeCamera().setCameraPreset(
Q3DCamera.CameraPresetFront)
# Magnetic field lines use custom narrow arrow.
# 磁力线使用自定义窄箭头。
self.m_magneticField.setItemSize(0.2)
self.m_magneticField.setMesh(QAbstract3DSeries.MeshUserDefined)
self.m_magneticField.setUserDefinedMesh(mesh_dir + '/narrowarrow.obj')
# 设置渐变颜色
fieldGradient = QLinearGradient(0, 0, 16, 1024)
fieldGradient.setColorAt(0.0, Qt.black)
fieldGradient.setColorAt(1.0, Qt.white)
self.m_magneticField.setBaseGradient(fieldGradient)
self.m_magneticField.setColorStyle(Q3DTheme.ColorStyleRangeGradient)
# For 'sun' we use a custom large sphere.
# 使用一个自定义的球体代表太阳
self.m_sun.setItemSize(0.2)
self.m_sun.setName("Sun")
self.m_sun.setItemLabelFormat("@seriesName")
self.m_sun.setMesh(QAbstract3DSeries.MeshUserDefined)
self.m_sun.setUserDefinedMesh(mesh_dir + '/largesphere.obj')
self.m_sun.setBaseColor(QColor(0xff, 0xbb, 0x00))
self.m_sun.dataProxy().addItem(QScatterDataItem(QVector3D()))
self.m_graph.addSeries(self.m_magneticField)
self.m_graph.addSeries(self.m_sun)
# Configure the axes according to the data.
# 设置x轴的范围值
self.m_graph.axisX().setRange(-self.horizontalRange,
self.horizontalRange)
# 设置y轴的范围值
self.m_graph.axisY().setRange(-self.verticalRange, self.verticalRange)
# 设置z轴的范围值
self.m_graph.axisZ().setRange(-self.horizontalRange,
self.horizontalRange)
# x和z轴上的段数
# 这表明绘制了多少标签。要绘制的网格线的数量使用公式计算：segments * subsegments + 1。预设默认值为5。该值不能低于1。
self.m_graph.axisX().setSegmentCount(self.horizontalRange)
self.m_graph.axisZ().setSegmentCount(self.horizontalRange)
self.m_rotationTimer.timeout.connect(self.triggerRotation)
self.toggleRotation()
self.generateData()
def gradientFromColor(color):
gradient = QLinearGradient(0, 0, 0, 1)
gradient.setCoordinateMode(QLinearGradient.ObjectBoundingMode)
gradient.setColorAt(0, color)
gradient.setColorAt(1, color.lighter())
return gradient
def _gradient(height, color1, color2):
grad = QLinearGradient(0, 0, 0, height)
grad.setColorAt(0.0, color1)
grad.setColorAt(1.0, color2)
return grad
def paintEvent(self, event):
self._center = np.array((self.width() / 2.0, self.height() / 2.0))
self._radius = min(self.width(),
self.height()) * self._args.wheel_ratio / 2
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
# color wheel. hue.
wheel_box = get_outer_box(self._center, self._radius)
painter.setPen(
QPen(QColor(*self._args.wheel_ed_color), self._args.wheel_ed_wid))
cgrad = QConicalGradient(*self._center, 0)
cgrad.setColorAt(0.00000, QColor(255, 0, 0))
cgrad.setColorAt(0.16667, QColor(255, 0, 255))
cgrad.setColorAt(0.33333, QColor(0, 0, 255))
cgrad.setColorAt(0.50000, QColor(0, 255, 255))
cgrad.setColorAt(0.66667, QColor(0, 255, 0))
cgrad.setColorAt(0.83333, QColor(255, 255, 0))
cgrad.setColorAt(1.00000, QColor(255, 0, 0))
painter.setBrush(cgrad)
painter.drawEllipse(*wheel_box)
# color wheel. saturation.
rgrad = QRadialGradient(*self._center, self._radius)
rgrad.setColorAt(0.0, Qt.white)
rgrad.setColorAt(1.0, Qt.transparent)
painter.setBrush(rgrad)
painter.drawEllipse(*wheel_box)
# bars.
bar_hsv = self._args.sys_color_set[self._args.sys_activated_idx].hsv
bar_v = bar_hsv[2]
bar_rgb = Color.hsv2rgb((bar_hsv[0], bar_hsv[1], 1.0))
self._v_tag_radius = min(self.width(),
self.height()) * self._args.v_tag_radius / 2
re_wid = self.width() * (
1 - self._args.wheel_ratio) / 2 * self._args.volum_ratio
re_wid = self._v_tag_radius * 3 if self._v_tag_radius * 3 < re_wid else re_wid
bar_1_center = ((self.width() - self._radius * 2) / 4,
self.height() / 2)
self._bar_1_box = (bar_1_center[0] - re_wid / 2, bar_1_center[1] -
self.height() * self._args.volum_ratio / 2, re_wid,
self.height() * self._args.volum_ratio)
painter.setPen(
QPen(QColor(*self._args.wheel_ed_color), self._args.wheel_ed_wid))
lgrad = QLinearGradient(self._bar_1_box[0], self._bar_1_box[1],
self._bar_1_box[0], self._bar_1_box[3])
lgrad.setColorAt(1.0, Qt.white)
lgrad.setColorAt(0.0, Qt.black)
painter.setBrush(lgrad)
painter.drawRect(*self._bar_1_box)
self._cir_1_center = (bar_1_center[0],
self._bar_1_box[1] + self._bar_1_box[3] * bar_v)
cir_1_box = get_outer_box(self._cir_1_center, self._v_tag_radius)
painter.setPen(
QPen(QColor(*self._args.positive_color), self._args.positive_wid))
painter.setBrush(QBrush(Qt.NoBrush))
painter.drawEllipse(*cir_1_box)
bar_2_center = (self.width() - (self.width() - self._radius * 2) / 4,
self.height() / 2)
self._bar_2_box = (bar_2_center[0] - re_wid / 2, bar_2_center[1] -
self.height() * self._args.volum_ratio / 2, re_wid,
self.height() * self._args.volum_ratio)
painter.setPen(
QPen(QColor(*self._args.wheel_ed_color), self._args.wheel_ed_wid))
lgrad = QLinearGradient(self._bar_2_box[0], self._bar_2_box[1],
self._bar_2_box[0], self._bar_2_box[3])
lgrad.setColorAt(1.0, QColor(*bar_rgb))
lgrad.setColorAt(0.0, Qt.black)
painter.setBrush(lgrad)
painter.drawRect(*self._bar_2_box)
self._cir_2_center = (bar_2_center[0],
self._bar_2_box[1] + self._bar_2_box[3] * bar_v)
cir_2_box = get_outer_box(self._cir_2_center, self._v_tag_radius)
painter.setPen(
QPen(QColor(*self._args.positive_color), self._args.positive_wid))
painter.setBrush(QBrush(Qt.NoBrush))
painter.drawEllipse(*cir_2_box)
# color set tags.
self._tag_center = [None] * 5
self._tag_radius = min(self.width(),
self.height()) * self._args.s_tag_radius / 2
self._idx_seq = list(range(5))
self._idx_seq = self._idx_seq[
self._args.sys_activated_idx +
1:] + self._idx_seq[:self._args.sys_activated_idx + 1]
# lines.
for idx in self._idx_seq:
color_center = np.array([
self._args.sys_color_set[idx].s * self._radius, 0
]) + self._center
color_center = rotate_point_center(self._center, color_center,
self._args.sys_color_set[idx].h)
self._tag_center[idx] = color_center
if idx == self._args.sys_activated_idx:
painter.setPen(
QPen(QColor(*self._args.positive_color),
self._args.positive_wid))
else:
painter.setPen(
QPen(QColor(*self._args.negative_color),
self._args.negative_wid))
painter.drawLine(QPoint(*self._center), QPoint(*color_center))
# dot.
dot_box = get_outer_box(self._center, self._args.positive_wid)
painter.setPen(QPen(Qt.NoPen))
painter.setBrush(QBrush(QColor(*self._args.positive_color)))
painter.drawEllipse(*dot_box)
# circles.
for idx in self._idx_seq:
color_box = get_outer_box(self._tag_center[idx], self._tag_radius)
if idx == self._args.sys_activated_idx:
painter.setPen(
QPen(QColor(*self._args.positive_color),
self._args.positive_wid))
else:
painter.setPen(
QPen(QColor(*self._args.negative_color),
self._args.negative_wid))
painter.setBrush(QColor(*self._args.sys_color_set[idx].rgb))
painter.drawEllipse(*color_box)
painter.end()
def initUI(self):
# 生成组件
self.labmap = QLabel() # 背景地图
self.labmap.setFixedSize(1000, 400)
img = QImage(r'resource/map/citymap.png')
result = img.scaled(self.labmap.width(), self.labmap.height(),
Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
self.labmap.setPixmap(QPixmap.fromImage(result))
self.pltfunc = pg.PlotWidget(title='人员状态变化情况') # 绘制函数
self.pltfunc.setStatusTip('函数绘制窗口')
self.pltfunc.showGrid(x=True, y=True)
self.pltfunc.addLegend()
self.pltfunc.setLabel('left', 'Value', units='人数')
self.pltfunc.setLabel('bottom', 'Time', units='天数')
self.pltfunc.setXRange(0, 365)
self.btnstart = QPushButton('开始仿真')
self.btnpause = QPushButton('暂停仿真')
self.cbbdisease = QComboBox() # 选择传染病下拉列表框
self.cbbdisease.addItems(['流行感冒', '痢疾', '肺结核', '艾滋病', '传染性非典型肺炎'])
self.spbday = QSpinBox() # 设置仿真天数
self.spbday.setRange(10, 365)
self.spbday.setValue(30)
# 以下是提示标签组件
self.lab_disease_color = QLabel() # 染病程度颜色标签
labcolorwidth, labcolorheight = 160, 30
self.lab_disease_color.setFixedSize(labcolorwidth, labcolorheight)
pixmap = QPixmap(labcolorwidth, labcolorheight)
painter = QPainter()
painter.begin(pixmap)
linearGradient = QLinearGradient(0, labcolorheight / 2, labcolorwidth,
labcolorheight / 2)
linearGradient.setColorAt(0, Qt.green)
linearGradient.setColorAt(0.34, QColor(255, 255, 0))
linearGradient.setColorAt(0.66, QColor(255, 125, 0))
linearGradient.setColorAt(1, Qt.red)
painter.setPen(Qt.NoPen)
painter.setBrush(linearGradient)
painter.drawRect(0, 0, labcolorwidth, labcolorheight)
painter.end()
self.lab_disease_color.setPixmap(pixmap)
self.labcolor = QLabel()
self.labcolor.setText('地区感染程度')
self.labdisease = QLabel()
self.labdisease.setText('设置传染病')
self.labday = QLabel()
self.labday.setText('设置仿真天数')
# 设置布局
self.widget = QWidget()
self.mainHBox = QHBoxLayout()
self.leftVBox = QVBoxLayout()
self.rightVBox = QVBoxLayout()
self.decriptionGroupBox = QGroupBox("程序说明")
self.decriptionGroupBox.setStyleSheet(
"QGroupBox{font-family:'黑体'; font-size: 15px}")
self.decriptionGBox = QGridLayout()
self.decriptionGBox.setColumnStretch(3, 10)
self.decriptionGBox.setRowStretch(1, 10)
self.settingGroupBox = QGroupBox('参数设置')
self.settingGroupBox.setStyleSheet(
"QGroupBox{font-family:'黑体'; font-size: 15px}")
self.settingGBox = QGridLayout()
self.settingGBox.setColumnStretch(3, 10)
self.settingGBox.setRowStretch(2, 10)
self.ctrlGroupBox = QGroupBox('仿真控制')
self.ctrlGroupBox.setStyleSheet(
"QGroupBox{font-family:'黑体'; font-size: 15px}")
self.ctrlGBox = QGridLayout()
self.ctrlGBox.setColumnStretch(0, 10)
self.ctrlGBox.setColumnStretch(2, 10)
# 布局添加组件
# =================以下添加组件======================
self.decriptionGBox.addWidget(self.labcolor, 0, 0) # 程序说明部分
self.decriptionGBox.addWidget(self.lab_disease_color, 0, 1)
self.settingGBox.addWidget(self.labdisease, 0, 0, 1, 1) # 设置参数部分
self.settingGBox.addWidget(self.cbbdisease, 0, 1, 1, 1)
self.settingGBox.addWidget(self.labday, 1, 0, 1, 1)
self.settingGBox.addWidget(self.spbday, 1, 1, 1, 1)
self.ctrlGBox.addWidget(self.btnstart, 0, 1) # 控制仿真部分
self.ctrlGBox.addWidget(self.btnpause, 1, 1)
# 宏观地图元胞生成
self.citymap = {}
for x in range(0, 20):
for y in range(0, 8):
self.citymap[(x, y)] = Celluar(str((y, x)),
self.labmap) # 地区编号 (行, 列)
self.citymap[(x, y)].setGeometry(50 * x, 50 * y, 50, 50)
# 社区地图生成
w, h = self.labmap.size().width(), self.labmap.size().height()
communitypixmap = QPixmap(w, h)
painter = QPainter()
painter.begin(communitypixmap)
font = QFont()
font.setPixelSize(32)
painter.setFont(font)
painter.setPen(QColor(255, 255, 255))
painter.drawText(20, 100, '开发中......')
painter.end()
self.communitymap = QLabel(self.labmap)
self.communitymap.setGeometry(0, 0, w, h)
self.communitymap.setPixmap(communitypixmap)
self.communitymap.hide()
# ===================================================
self.decriptionGroupBox.setLayout(self.decriptionGBox)
self.settingGroupBox.setLayout(self.settingGBox)
self.ctrlGroupBox.setLayout(self.ctrlGBox)
self.leftVBox.addWidget(self.labmap)
self.leftVBox.addWidget(self.pltfunc)
self.rightVBox.addWidget(self.decriptionGroupBox)
self.rightVBox.addWidget(self.settingGroupBox)
self.rightVBox.addWidget(self.ctrlGroupBox)
self.mainHBox.addLayout(self.leftVBox)
self.mainHBox.addLayout(self.rightVBox)
self.widget.setLayout(self.mainHBox)
self.setCentralWidget(self.widget)
# 生成行动
self.initAction()
# 设置主窗口菜单栏、状态栏
self.mainMenubar = self.menuBar()
self.fileMenu = self.mainMenubar.addMenu('文件(&F)')
self.fileMenu.addAction(self.quitAction)
self.toggleViewMenu = self.mainMenubar.addMenu('切换仿真方式(&T)')
self.toggleViewMenu.addAction(self.toggleCityViewAction)
self.toggleViewMenu.addAction(self.toggleCommunityViewAction)
self.setDeseaseMenu = self.mainMenubar.addMenu('设置传染病参数(&S)')
self.helpMenu = self.mainMenubar.addMenu('帮助(&H)')
self.statusbar = self.statusBar()
# 设置主窗口大小，居中，标题
self.setGeometry(300, 300, 1280, 720)
# self.setMinimumSize(1280, 720)
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
self.setWindowIcon(QIcon('resource/icons/MainWindowIcon.png'))
self.setWindowTitle('传染病仿真程序')
def data(self, index: QModelIndex, role: int = ...):
if not index.isValid():
return QVariant()
node: EncounterNode = index.internalPointer()
p: Entity = self.encounter.entities[node.player]
h = self.headers[index.column()]
if h == self.TXT_CLASS and role == Qt.DecorationRole:
if node.pixmap is None:
try:
#print("was none")
specInfo = self.resourceHandler.getSpecialization(p.elite, p.prof)
p = QPixmap()
p.loadFromData(specInfo[self.resourceHandler.PROFESSION_ICON])
p = p.scaled(QSize(20, 20), Qt.KeepAspectRatio, Qt.SmoothTransformation)
node.pixmap = p
except Exception as e:
return QVariant()
return node.pixmap
if role == Qt.TextAlignmentRole:
if h in [self.TXT_SUBSQUAD, self.TXT_CLASS, self.TXT_DEAD, self.TXT_DOWN, self.TXT_DPS, self.TXT_BOSS_DPS, self.TXT_DMG_BOSS, self.TXT_DMG_TOTAL]:
return Qt.AlignCenter
if role == Qt.DisplayRole:
if h == self.TXT_SUBSQUAD:
return p.subsquad
if h == self.TXT_CHARACTER:
return p.character
if h == self.TXT_ACCOUNT:
return p.account
if h == self.TXT_BOSS_DPS:
return self.encounter.getBossDps(node.player)
if h == self.TXT_DPS:
return self.encounter.getTotalDps(node.player)
if h == self.TXT_DMG_TOTAL:
return p.damage.totalOut
if h == self.TXT_DMG_BOSS:
return self.encounter.getBossDamage(node.player)
if h == self.TXT_DOWN:
return p.downed
if h == self.TXT_DEAD:
return p.dead
return QVariant()
if role == Qt.BackgroundRole:
if not self.encounter.fullComplete:
return QVariant()
rightBound = self.headerWidths[index.column()]/self.totalWidth
leftBound = 0
if index.column() > 0:
leftBound = self.headerWidths[index.column() - 1]/self.totalWidth
# barBound = self.encounter.getTotalDps(node.player)/self.highestRowValue
if self.highestRowValue == 0:
barBound = 0
else:
barBound = self.data(self.createIndex(index.row(), self.sortColumn, node), Qt.DisplayRole)/self.highestRowValue
profColor = QColor(*reference.CLASS_COLORS[p.prof], 60)
if rightBound <= barBound:
return profColor
elif leftBound >= barBound:
return QVariant()
else:
colpercent = rightBound - leftBound
colwidth = 0
if index.column() > 0:
colwidth = self.headerWidths[index.column()] - self.headerWidths[index.column() - 1]
else:
colwidth = self.headerWidths[index.column()]
toFill = barBound-leftBound
gradient = QLinearGradient(0, 0, colwidth, 0)
gradient.setColorAt(toFill/colpercent, profColor)
gradient.setColorAt((toFill/colpercent) + .000001, QColor('white'))
brush = QBrush(gradient)
return brush
def paint(self, painter, option, widget):
painter.save()
painter.setRenderHint(QPainter.Antialiasing,
bool(options.antialiasing == ANTIALIASING_FULL))
rect = QRectF(0, 0, self.p_width, self.p_height)
# Draw rectangle
pen = QPen(canvas.theme.box_pen_sel if self.isSelected() else canvas.
theme.box_pen)
pen.setWidthF(pen.widthF() + 0.00001)
painter.setPen(pen)
lineHinting = pen.widthF() / 2
if canvas.theme.box_bg_type == Theme.THEME_BG_GRADIENT:
box_gradient = QLinearGradient(0, 0, 0, self.p_height)
box_gradient.setColorAt(0, canvas.theme.box_bg_1)
box_gradient.setColorAt(1, canvas.theme.box_bg_2)
painter.setBrush(box_gradient)
else:
painter.setBrush(canvas.theme.box_bg_1)
rect.adjust(lineHinting, lineHinting, -lineHinting, -lineHinting)
painter.drawRect(rect)
# Draw plugin inline display if supported
self.paintInlineDisplay(painter)
# Draw pixmap header
rect.setHeight(canvas.theme.box_header_height)
if canvas.theme.box_header_pixmap:
painter.setPen(Qt.NoPen)
painter.setBrush(canvas.theme.box_bg_2)
# outline
rect.adjust(lineHinting, lineHinting, -lineHinting, -lineHinting)
painter.drawRect(rect)
rect.adjust(1, 1, -1, 0)
painter.drawTiledPixmap(rect, canvas.theme.box_header_pixmap,
rect.topLeft())
# Draw text
painter.setFont(self.m_font_name)
if self.isSelected():
painter.setPen(canvas.theme.box_text_sel)
else:
painter.setPen(canvas.theme.box_text)
if canvas.theme.box_use_icon:
textPos = QPointF(25, canvas.theme.box_text_ypos)
else:
appNameSize = fontHorizontalAdvance(self.m_font_name,
self.m_group_name)
rem = self.p_width - appNameSize
textPos = QPointF(rem / 2, canvas.theme.box_text_ypos)
painter.drawText(textPos, self.m_group_name)
self.repaintLines()
painter.restore()
def paintEvent(self, event):
# Initializing QPainter
qp = QPainter()
qp.begin(self)
qp.setRenderHint(QPainter.Antialiasing)
button_rect = self.geometry()
# Check if hovered or pressed
color_outline = self.color_outline_normal
color_border = self.color_border_normal
color_shadow = self.color_shadow_normal
color_glass = self.color_glass_normal
if self.isEnabled():
if self.hovered:
color_outline = self.color_outline_highlight
color_border = self.color_border_highlight
color_shadow = self.color_shadow_highlight
color_glass = self.color_glass_highlight
if self.pressed:
color_outline = self.color_outline_pressed
color_border = self.color_border_pressed
color_shadow = self.color_shadow_pressed
color_glass = self.color_glass_pressed
else:
color_border = QColor(50, 50, 50)
color_shadow = QColor(50, 50, 50)
color_glass = QColor(0, 0, 0, 0)
# Button outline
qp.setPen(QPen(QBrush(color_outline), 2.0))
outline = QPainterPath()
outline.addRoundedRect(0, 0, button_rect.width(
), button_rect.height(), self.roundness, self.roundness)
qp.setOpacity(self.opacity)
qp.drawPath(outline)
# Gradient
gradient = QLinearGradient(0, 0, 0, button_rect.height())
gradient.setColorAt(0.0, color_border)
gradient.setColorAt(0.4, color_shadow)
gradient.setColorAt(0.6, color_shadow)
gradient.setColorAt(1.0, color_border)
qp.setBrush(QBrush(gradient))
qp.setPen(QPen(QBrush(color_border), 2.0))
# Main button
qppath = QPainterPath()
qppath.addRoundedRect(1, 1, button_rect.width(
) - 2, button_rect.height() - 2, self.roundness, self.roundness)
qp.setClipPath(qppath)
qp.setOpacity(self.opacity)
qp.drawRoundedRect(1, 1, button_rect.width(
) - 2, button_rect.height() - 2, self.roundness, self.roundness)
# Glass highlight
qp.setBrush(QBrush(color_glass))
qp.setPen(QPen(QBrush(color_glass), 0.01))
qp.setOpacity(1)
qp.drawRect(1, 1, button_rect.width() - 2,
(button_rect.height() / 2) - 2)
# Text
if self.text():
qp.setFont(self.font())
qp.setPen(self.color_text)
qp.setOpacity(1.0)
qp.drawText(QRect(0, 0, button_rect.width(),
button_rect.height()), self.textAlign, self.text())
# Icon
if self.icon():
qp.setOpacity(1.0)
qp.drawPixmap(self.iconPosition(), QPixmap(
self.icon().pixmap(self.iconSize())))
qp.end()
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
redrawRect = event.rect()
beginRow = redrawRect.top() // self.squareSize
endRow = redrawRect.bottom() // self.squareSize
# XXX: do we need to maintain self._column when we have (endColumn -
# beginColumn)?
beginColumn = redrawRect.left() // self.squareSize
endColumn = redrawRect.right() // self.squareSize
gradient = QLinearGradient(0, 0, 0, GlyphCellHeaderHeight)
gradient.setColorAt(0.0, cellHeaderBaseColor)
gradient.setColorAt(1.0, cellHeaderLineColor)
dirtyGradient = QLinearGradient(0, 0, 0, GlyphCellHeaderHeight)
dirtyGradient.setColorAt(0.0, cellHeaderBaseColor.darker(125))
dirtyGradient.setColorAt(1.0, cellHeaderLineColor.darker(125))
markGradient = QLinearGradient(0, 0, 0,
self.squareSize - GlyphCellHeaderHeight)
voidFont.setPointSize(.425 * self.squareSize)
for row in range(beginRow, endRow + 1):
for column in range(beginColumn, endColumn + 1):
key = row * self._columns + column
if key >= len(self._glyphs):
break
glyph = self._glyphs[key]
painter.save()
painter.translate(column * self.squareSize,
row * self.squareSize)
painter.fillRect(0, 0, self.squareSize, self.squareSize,
Qt.white)
# prepare header colors
brushColor = gradient
linesColor = cellHeaderHighlightLineColor
# mark color
if not glyph.template and glyph.markColor is not None:
markColor = QColor.fromRgbF(*tuple(glyph.markColor))
markGradient.setColorAt(1.0, markColor)
markGradient.setColorAt(0.0, markColor.lighter(125))
painter.fillRect(0, GlyphCellHeaderHeight, self.squareSize,
self.squareSize - GlyphCellHeaderHeight,
QBrush(markGradient))
if not glyph.template and glyph.dirty:
brushColor = dirtyGradient
linesColor = cellHeaderHighlightLineColor.darker(110)
# header gradient
painter.fillRect(0, 0, self.squareSize, GlyphCellHeaderHeight,
QBrush(brushColor))
# header lines
painter.setPen(linesColor)
minOffset = painter.pen().width()
# disable antialiasing to avoid lines bleeding over background
painter.setRenderHint(QPainter.Antialiasing, False)
painter.drawLine(0, 0, 0, GlyphCellHeaderHeight - 1)
painter.drawLine(self.squareSize - 2, 0, self.squareSize - 2,
GlyphCellHeaderHeight - 1)
painter.setPen(QColor(170, 170, 170))
painter.drawLine(0, GlyphCellHeaderHeight, self.squareSize,
GlyphCellHeaderHeight)
painter.setRenderHint(QPainter.Antialiasing)
# header text
painter.setFont(headerFont)
painter.setPen(QColor(80, 80, 80))
name = metrics.elidedText(glyph.name, Qt.ElideRight,
self.squareSize - 2)
painter.drawText(1, 0, self.squareSize - 2,
GlyphCellHeaderHeight - minOffset,
Qt.TextSingleLine | Qt.AlignCenter, name)
painter.restore()
painter.setPen(cellGridColor)
rightEdgeX = column * self.squareSize + self.squareSize
bottomEdgeY = row * self.squareSize + self.squareSize
painter.drawLine(rightEdgeX, row * self.squareSize + 1,
rightEdgeX, bottomEdgeY)
painter.drawLine(rightEdgeX, bottomEdgeY,
column * self.squareSize + 1, bottomEdgeY)
if self._currentDropIndex is not None:
painter.setPen(Qt.green)
if self._currentDropIndex == key:
painter.drawLine(column * self.squareSize,
row * self.squareSize,
column * self.squareSize, bottomEdgeY)
# special-case the end-column
elif (column == endColumn
and self._currentDropIndex == key + 1):
yPos = self.mapFromGlobal(QCursor.pos()).y()
if row == yPos // self.squareSize:
painter.drawLine(rightEdgeX - 1,
row * self.squareSize,
rightEdgeX - 1, bottomEdgeY)
# selection code
if key in self._selection:
painter.setRenderHint(QPainter.Antialiasing, False)
painter.fillRect(column * self.squareSize + 1,
row * self.squareSize + 1,
self.squareSize - 3, self.squareSize - 3,
cellSelectionColor)
painter.setRenderHint(QPainter.Antialiasing)
if not glyph.template:
font = glyph.getParent()
outline = glyph.getRepresentation("defconQt.QPainterPath")
uPM = font.info.unitsPerEm
if uPM is None or not uPM > 0:
uPM = 1000
descender = font.info.descender
if descender is None or not descender < 0:
descender = -250
factor = (self.squareSize - GlyphCellHeaderHeight) / \
(uPM * (1 + 2 * GlyphCellBufferHeight))
x_offset = (self.squareSize - glyph.width * factor) / 2
# If the glyph overflows horizontally we need to adjust the
# scaling factor
if x_offset < 0:
factor *= 1 + 2 * x_offset / (glyph.width * factor)
x_offset = 0
# TODO: the * 1.8 below is somewhat artificial
y_offset = descender * factor * 1.8
painter.save()
painter.setClipRect(
column * self.squareSize,
row * self.squareSize + GlyphCellHeaderHeight,
self.squareSize,
self.squareSize - GlyphCellHeaderHeight)
painter.translate(
column * self.squareSize + x_offset,
row * self.squareSize + self.squareSize + y_offset)
painter.scale(factor, -factor)
painter.fillPath(outline, Qt.black)
painter.restore()
else:
painter.save()
painter.setFont(voidFont)
painter.setPen(QPen(Qt.lightGray))
rect = QRectF(
column * self.squareSize,
row * self.squareSize + GlyphCellHeaderHeight,
self.squareSize,
self.squareSize - GlyphCellHeaderHeight)
if glyph.unicode is not None:
text = chr(glyph.unicode)
else:
text = "✌"
painter.drawText(rect, Qt.AlignCenter, text)
painter.restore()
def paintEvent(self, event=None):
LogicalSize = 100.0
def logicalFromPhysical(length, side):
return (length / side) * LogicalSize
fm = QFontMetricsF(self.font())
ymargin = (
(LogicalSize / 30.0) +
logicalFromPhysical(self.leftSpinBox.height(), self.height()))
ymax = (LogicalSize -
logicalFromPhysical(fm.height() * 2, self.height()))
width = LogicalSize / 4.0
cx, cy = LogicalSize / 2.0, LogicalSize / 3.0
ax, ay = cx - (2 * width), ymargin
bx, by = cx - width, ay
dx, dy = cx + width, ay
ex, ey = cx + (2 * width), ymargin
fx, fy = cx + (width / 2), cx + (LogicalSize / 24.0)
gx, gy = fx, ymax
hx, hy = cx - (width / 2), ymax
ix, iy = hx, fy
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
side = min(self.width(), self.height())
painter.setViewport((self.width() - side) / 2,
(self.height() - side) / 2, side, side)
painter.setWindow(0, 0, LogicalSize, LogicalSize)
painter.setPen(Qt.NoPen) # 因为不需要显示所有线条，因此最后进行绘制，这里写NoPen
gradient = QLinearGradient(QPointF(0, 0), QPointF(0, 100))
gradient.setColorAt(0, Qt.white)
a = self.leftSpinBox.value()
gradient.setColorAt(1, (Qt.red if a != 0 else Qt.white))
painter.setBrush(QBrush(gradient)) # 其可以接受一个QColor对象，也可以接受一个QBrush实例。
# QBrush可以接受QColor、QGlobalColor、QImage、gradient对象
# painter.setBrush(Qt.red)
painter.drawPolygon(
QPolygonF([
QPointF(ax, ay),
QPointF(bx, by),
QPointF(cx, cy),
QPointF(ix, iy)
]))
gradient = QLinearGradient(QPointF(0, 0), QPointF(0, 100))
# The QLinearGradient class is used in combination with QBrush to specify a linear gradient brush.
# args(QPointF,QPointF): Constructs a linear gradient with interpolation area between the given start point and finalStop.
gradient.setColorAt(0, Qt.white)
# Creates a stop point at the given position with the given color. The given position must be in the range 0 to 1.
b = self.rightSpinBox.value()
gradient.setColorAt(1, (Qt.blue if b != 0 else Qt.white))
painter.setBrush(QBrush(gradient))
painter.drawPolygon(
QPolygonF([
QPointF(cx, cy),
QPointF(dx, dy),
QPointF(ex, ey),
QPointF(fx, fy)
]))
if (a + b) == 0:
color = QColor(Qt.white)
else:
ashare = (a / (a + b)) * 255.0
bshare = 255.0 - ashare
color = QColor(ashare, 0, bshare)
gradient = QLinearGradient(QPointF(0, 0), QPointF(0, 100))
gradient.setColorAt(0, Qt.white)
gradient.setColorAt(1, color)
painter.setBrush(QBrush(gradient))
painter.drawPolygon(
QPolygonF([
QPointF(cx, cy),
QPointF(fx, fy),
QPointF(gx, gy),
QPointF(hx, hy),
QPointF(ix, iy)
]))
painter.setPen(Qt.black)
painter.drawPolyline(
QPolygonF([QPointF(ax, ay),
QPointF(ix, iy),
QPointF(hx, hy)]))
painter.drawPolyline(
QPolygonF([QPointF(gx, gy),
QPointF(fx, fy),
QPointF(ex, ey)]))
painter.drawPolyline(
QPolygonF([QPointF(bx, by),
QPointF(cx, cy),
QPointF(dx, dy)]))
def paintGraph(self, graph, painter):
brush = QBrush(Qt.SolidPattern)
pen=QPen()
brush.setColor(Qt.white)
for i,edge in enumerate(graph.edges):
if("color" in edge.kwargs.keys()):
pen.setColor(QColor(edge.kwargs["color"]))
else:
pen.setColor(QColor("black"))
if("width" in edge.kwargs.keys()):
pen.setWidth(int(edge.kwargs["width"]))
else:
pen.setWidth(1)
painter.setPen(pen)
painter.setBrush(brush)
if(edge.source.parent_graph !=graph and not self.show_subgraphs):
gspos = edge.source.parent_graph.global_pos
else:
gspos = edge.source.global_pos
if(edge.dest.parent_graph !=graph and not self.show_subgraphs):
gspos = edge.dest.parent_graph.global_pos
else:
gdpos = edge.dest.global_pos
nb_next=0
for j in range(i, len(graph.edges)):
if(graph.edges[j].source==edge.source and graph.edges[j].dest==edge.dest):
nb_next+=1
offset=[0,0]
if(nb_next%2==1):
offset[0]=20*(nb_next/2)
else:
offset[0]=-20*(nb_next/2)
path = QPainterPath()
path.moveTo(gspos[0],gspos[1])
path.cubicTo(gspos[0],gspos[1],offset[0]+(gspos[0]+gdpos[0])/2,(gspos[1]+gdpos[1])/2,gdpos[0],gdpos[1])
painter.strokePath(path, pen)
"""
painter.drawLine(gspos[0],gspos[1],
gdpos[0],
gdpos[1])
"""
if(self.show_subgraphs):
for node in graph.nodes:
if type(node)==Graph:
subgraph = node
self.paintSubgraph(subgraph, painter, pen, brush)
# TODO : add more painting parameters
for node in graph.nodes:
if type(node)!=Graph:
if("color" in node.kwargs.keys()):
pen.setColor(QColor(node.kwargs["color"]))
else:
pen.setColor(QColor("black"))
if("fillcolor" in node.kwargs.keys()):
if(":" in node.kwargs["fillcolor"]):
gradient=QLinearGradient(node.pos[0]-node.size[0]/2, node.pos[1], node.pos[0]+node.size[0]/2, node.pos[1])
c=node.kwargs["fillcolor"].split(":")
for i, col in enumerate(c):
stop = i/(len(c)-1)
gradient.setColorAt(stop, QColor(col))
brush = QBrush(gradient)
else:
brush=QBrush(QColor(node.kwargs["fillcolor"]))
else:
brush=QBrush(QColor("white"))
if("width" in node.kwargs.keys()):
pen.setWidth(int(node.kwargs["width"]))
else:
pen.setWidth(1)
gpos = node.global_pos
painter.setPen(pen)
painter.setBrush(brush)
if("shape" in node.kwargs.keys()):
if(node.kwargs["shape"]=="box"):
painter.drawRect(
gpos[0]-node.size[0]/2,
gpos[1]-node.size[1]/2,
node.size[0], node.size[1])
elif(node.kwargs["shape"]=="circle"):
painter.drawEllipse(
gpos[0]-node.size[0]/2,
gpos[1]-node.size[1]/2,
node.size[0], node.size[1])
elif(node.kwargs["shape"]=="triangle"):
rect = QRect(gpos[0]-node.size[0]/2, gpos[1]-2*node.size[1]/3, node.size[0], node.size[1])
path = QPainterPath()
path.moveTo(rect.left() + (rect.width() / 2), rect.top())
path.lineTo(rect.bottomLeft())
path.lineTo(rect.bottomRight())
path.lineTo(rect.left() + (rect.width() / 2), rect.top())
painter.fillPath(path, brush)
painter.drawPath(path)
elif(node.kwargs["shape"]=="polygon"):
rect = QRect(gpos[0]-node.size[0]/2, gpos[1]-node.size[1]/2, node.size[0], node.size[1])
path = QPainterPath()
path.moveTo(rect.left() + (rect.width() / 4), rect.top())
path.lineTo(rect.left() + 3*rect.width()/4, rect.top())
path.lineTo(rect.left() + rect.width(), rect.top() + rect.height()/2)
path.lineTo(rect.left() + 3*rect.width()/4, rect.top() + rect.height())
path.lineTo(rect.left() + rect.width()/4, rect.top() + rect.height())
path.lineTo(rect.left(), rect.top() + rect.height()/2)
path.lineTo(rect.left() + (rect.width() / 4), rect.top())
painter.fillPath(path, brush)
painter.drawPath(path)
elif(node.kwargs["shape"]=="diamond"):
rect = QRect(gpos[0]-node.size[0]/2, gpos[1]-node.size[1]/2, node.size[0], node.size[1])
path = QPainterPath()
path.moveTo(rect.left() + (rect.width() / 2), rect.top())
path.lineTo(rect.left() + rect.width(), rect.top() + rect.height()/2)
path.lineTo(rect.left() + rect.width()/2, rect.top() + rect.height())
path.lineTo(rect.left(), rect.top() + rect.height()/2)
path.lineTo(rect.left() + (rect.width() / 2), rect.top())
painter.fillPath(path, brush)
painter.drawPath(path)
else: # assuming this is an image
# this parameter can be either direct image path
# or a relative path (relative to the file path)
# It can contain the format path,width,height
# or simple path in which case the image file size will be used
image = None
width = 0
height = 0
if("," in node.kwargs["shape"]): # if there is a , in the shape, the first part is the path, then width, then height
img_params = node.kwargs["shape"].split(",")
if len(img_params)==3:# img:width:height
img_path = img_params[0]
width = int(img_params[1])
height = int(img_params[2])
img_path2 = os.path.join(os.path.dirname(self.engine.current_path),img_path)
if(os.path.isfile(img_path)):
image = QImage(img_path)
elif(os.path.isfile(img_path2)):
image = QImage(img_path2)
else:
img_path = node.kwargs["shape"]
img_path2 = os.path.join(os.path.dirname(self.engine.current_path),img_path)
if(os.path.isfile(img_path)):
image = QImage(img_path)
width = image.size().width()
height = image.size().height()
elif(os.path.isfile(img_path2)):
image = QImage(img_path2)
width = image.size().width()
height = image.size().height()
if width==0:
width=100
if height==0:
height=100
if image is not None:
node.size[0] = width if width>node.size[0] else node.size[0]
node.size[1] = height if height>node.size[1] else node.size[1]
painter.drawImage(
QRect(
gpos[0]-node.size[0]/2,
gpos[1]-node.size[1]/2,
node.size[0],
node.size[1]),
image)
else:
painter.drawEllipse(
gpos[0]-node.size[0]/2,
gpos[1]-node.size[1]/2,
node.size[0], node.size[1])
if("label" in node.kwargs.keys()):
txt = node.kwargs["label"].split("\n")
width = 0
height = 0
for t in txt:
if(t==""):
t="A"
rect = self.engine.fm.boundingRect(t)
width=rect.width() if rect.width()>width else width
height+=rect.height()
width+=self.engine.margins[0]
height+self.engine.margins[1]
painter.drawText(
gpos[0]-width/2,
gpos[1]-height/2,
width, height,
Qt.AlignCenter|Qt.AlignTop,node.kwargs["label"])
else:
if(self.show_subgraphs):
self.paintGraph(subgraph, painter)
else:
subgraph = node
self.paintSubgraph(subgraph, painter, pen, brush)
def createCurveIcons(self):
pix = QPixmap(self.m_iconSize)
painter = QPainter()
gradient = QLinearGradient(0, 0, 0, self.m_iconSize.height())
gradient.setColorAt(0.0, QColor(240, 240, 240))
gradient.setColorAt(1.0, QColor(224, 224, 224))
brush = QBrush(gradient)
# The original C++ code uses undocumented calls to get the names of the
# different curve types. We do the Python equivalant (but without
# cheating).
curve_types = [
(n, c) for n, c in QEasingCurve.__dict__.items()
if isinstance(c, QEasingCurve.Type) and c != QEasingCurve.Custom
]
curve_types.sort(key=lambda ct: ct[1])
painter.begin(pix)
for curve_name, curve_type in curve_types:
painter.fillRect(QRect(QPoint(0, 0), self.m_iconSize), brush)
curve = QEasingCurve(curve_type)
if curve_type == QEasingCurve.BezierSpline:
curve.addCubicBezierSegment(QPointF(0.4,
0.1), QPointF(0.6, 0.9),
QPointF(1.0, 1.0))
elif curve_type == QEasingCurve.TCBSpline:
curve.addTCBSegment(QPointF(0.0, 0.0), 0, 0, 0)
curve.addTCBSegment(QPointF(0.3, 0.4), 0.2, 1, -0.2)
curve.addTCBSegment(QPointF(0.7, 0.6), -0.2, 1, 0.2)
curve.addTCBSegment(QPointF(1.0, 1.0), 0, 0, 0)
painter.setPen(QColor(0, 0, 255, 64))
xAxis = self.m_iconSize.height() / 1.5
yAxis = self.m_iconSize.width() / 3.0
painter.drawLine(0, xAxis, self.m_iconSize.width(), xAxis)
painter.drawLine(yAxis, 0, yAxis, self.m_iconSize.height())
curveScale = self.m_iconSize.height() / 2.0
painter.setPen(Qt.NoPen)
# Start point.
painter.setBrush(Qt.red)
start = QPoint(yAxis,
xAxis - curveScale * curve.valueForProgress(0))
painter.drawRect(start.x() - 1, start.y() - 1, 3, 3)
# End point.
painter.setBrush(Qt.blue)
end = QPoint(yAxis + curveScale,
xAxis - curveScale * curve.valueForProgress(1))
painter.drawRect(end.x() - 1, end.y() - 1, 3, 3)
curvePath = QPainterPath()
curvePath.moveTo(QPointF(start))
t = 0.0
while t <= 1.0:
to = QPointF(yAxis + curveScale * t,
xAxis - curveScale * curve.valueForProgress(t))
curvePath.lineTo(to)
t += 1.0 / curveScale
painter.setRenderHint(QPainter.Antialiasing, True)
painter.strokePath(curvePath, QColor(32, 32, 32))
painter.setRenderHint(QPainter.Antialiasing, False)
item = QListWidgetItem()
item.setIcon(QIcon(pix))
item.setText(curve_name)
self.m_ui.easingCurvePicker.addItem(item)
painter.end()
def paint(self, painter, option, index):
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
# Get data model and selection
model = get_app().window.propertyTableView.clip_properties_model.model
row = model.itemFromIndex(index).row()
selected_label = model.item(row, 0)
selected_value = model.item(row, 1)
cur_property = selected_label.data()
# Get min/max values for this property
property_type = cur_property[1]["type"]
property_max = cur_property[1]["max"]
property_min = cur_property[1]["min"]
readonly = cur_property[1]["readonly"]
points = cur_property[1]["points"]
interpolation = cur_property[1]["interpolation"]
# Calculate percentage value
if property_type in ["float", "int"]:
# Get the current value
current_value = QLocale().system().toDouble(selected_value.text())[0]
# Shift my range to be positive
if property_min < 0.0:
property_shift = 0.0 - property_min
property_min += property_shift
property_max += property_shift
current_value += property_shift
# Calculate current value as % of min/max range
min_max_range = float(property_max) - float(property_min)
value_percent = current_value / min_max_range
else:
value_percent = 0.0
# set background color
painter.setPen(QPen(Qt.NoPen))
if property_type == "color":
# Color keyframe
red = cur_property[1]["red"]["value"]
green = cur_property[1]["green"]["value"]
blue = cur_property[1]["blue"]["value"]
painter.setBrush(QBrush(QColor(QColor(red, green, blue))))
else:
# Normal Keyframe
if option.state & QStyle.State_Selected:
painter.setBrush(QBrush(QColor("#575757")))
else:
painter.setBrush(QBrush(QColor("#3e3e3e")))
if readonly:
# Set text color for read only fields
painter.setPen(QPen(get_app().window.palette().color(QPalette.Disabled, QPalette.Text)))
else:
path = QPainterPath()
path.addRoundedRect(QRectF(option.rect), 15, 15)
painter.fillPath(path, QColor("#3e3e3e"))
painter.drawPath(path)
# Render mask rectangle
painter.setBrush(QBrush(QColor("#000000")))
mask_rect = QRectF(option.rect)
mask_rect.setWidth(option.rect.width() * value_percent)
painter.setClipRect(mask_rect, Qt.IntersectClip)
# gradient for value box
gradient = QLinearGradient(option.rect.topLeft(), option.rect.topRight())
gradient.setColorAt(0, QColor("#828282"))
gradient.setColorAt(1, QColor("#828282"))
# Render progress
painter.setBrush(gradient)
path = QPainterPath()
value_rect = QRectF(option.rect)
path.addRoundedRect(value_rect, 15, 15)
painter.fillPath(path, gradient)
painter.drawPath(path)
painter.setClipping(False)
if points > 1:
# Draw interpolation icon on top
painter.drawPixmap(option.rect.x() + option.rect.width() - 30.0, option.rect.y() + 4, self.curve_pixmaps[interpolation])
# Set text color
painter.setPen(QPen(Qt.white))
value = index.data(Qt.DisplayRole)
if value:
painter.drawText(option.rect, Qt.AlignCenter, value)
painter.restore()
def drawControl(self, element, opt, painter, widget):
"""elif element == QStyle.CE_PushButtonBevel:
# States
is_down = (opt.state & STATE_SUNKEN) | (opt.state & STATE_ON)
hovered = opt.state & STATE_ENABLED and opt.state & STATE_MOUSEOVER
has_focus = opt.state & STATE_HASFOCUS
rect = opt.rect
btn_color = opt.palette.button().color()
painter.setPen(btn_color)
painter.setRenderHint(QPainter.Antialiasing)
path = QPainterPath()
path.addRoundedRect(QRectF(rect), 3, 3)
if is_down:
painter.setBrush(btn_color.darker(115))
elif has_focus:
painter.setBrush(btn_color.lighter(130))
elif hovered:
grad = QLinearGradient(rect.topLeft(), rect.bottomLeft())
grad.setColorAt(0.6, btn_color)
grad.setColorAt(1, btn_color.lighter(120))
painter.setBrush(grad)
else:
painter.setBrush(btn_color)
painter.drawPath(path)"""
if element == QStyle.CE_ComboBoxLabel:
cb = opt
painter.save()
edit_rect = self.subControlRect(QStyle.CC_ComboBox, cb,
QStyle.SC_ComboBoxEditField,
widget)
# Draw icon
if not cb.currentIcon.isNull():
if cb.state & STATE_ENABLED:
mode = QIcon.Normal
else:
mode = QIcon.Disabled
pixmap = cb.currentIcon.pixmap(cb.iconSize, mode)
icon_rect = QRect(cb.rect)
icon_rect.setWidth(cb.iconSize.width() + 4)
# icon_rect = self.alignedRect(opt.direction,
# Qt.AlignLeft | Qt.AlignVCenter,
# icon_rect.size(), edit_rect)
self.drawItemPixmap(painter, icon_rect, Qt.AlignCenter, pixmap)
# Space between text
if cb.direction == Qt.RightToLeft:
edit_rect.translate(-4, -cb.iconSize.width(), 0)
else:
edit_rect.translate(cb.iconSize.width() + 4, 0)
edit_rect.adjusted(0, 0, -13, 0)
# Draw text
elide_width = edit_rect.width() - opt.fontMetrics.width('**')
text = opt.fontMetrics.elidedText(cb.currentText, Qt.ElideRight,
elide_width)
# FIXME: states
painter.setPen(_COLORS['ComboBoxTextColor'])
painter.drawText(edit_rect.adjusted(1, 0, -1, 0),
Qt.AlignLeft | Qt.AlignVCenter, text)
painter.restore()
# TODO: tab with flat style
# elif element == QStyle.CE_TabBarTabShape:
# pass
elif element == QStyle.CE_ToolBar:
rect = opt.rect
color = _COLORS['ToolButtonColor']
if widget.property('gradient'):
base = QColor(_PALETTE['Window'])
color = QLinearGradient(opt.rect.topRight(),
opt.rect.bottomRight())
color.setColorAt(0.2, base.lighter(150))
color.setColorAt(0.9, base.darker(135))
# print(widget.property("border"), widget)
painter.fillRect(rect, color)
if widget.property("border"):
# painter.setPen(opt.palette.light().color().lighter(150))
painter.setPen(_COLORS['Border'])
painter.drawLine(rect.topRight(), rect.bottomRight())
# painter.setPen(_COLORS['Border'])
# painter.drawLine(opt.rect.topRight(), opt.rect.bottomRight())
elif element == QStyle.CE_MenuItem:
painter.save()
enabled = opt.state & STATE_ENABLED
item = opt
item.rect = opt.rect
pal = opt.palette
if enabled:
color = _COLORS['MenuItemEnabled']
else:
color = _COLORS['MenuItemDisabled']
item.palette = pal
pal.setBrush(QPalette.Text, color)
QProxyStyle.drawControl(self, element, opt, painter, widget)
painter.restore()
elif element == QStyle.CE_MenuBarEmptyArea:
painter.fillRect(opt.rect, _COLORS['MenuBar'])
# Draw border
painter.save()
# FIXME: color from theme
painter.setPen(_COLORS['MenuBarBorderColor'])
painter.drawLine(opt.rect.bottomLeft() + QPointF(.5, .5),
opt.rect.bottomRight() + QPointF(.5, .5))
painter.restore()
# elif element == QStyle.CE_PushButtonBevel:
# painter.setPen(Qt.red)
# painter.fillRect(opt.rect, QColor("red"))
elif element == QStyle.CE_MenuBarItem:
painter.save()
act = opt.state & (STATE_SUNKEN | QStyle.State_Selected)
dis = not (opt.state & STATE_ENABLED)
painter.fillRect(opt.rect, _COLORS['MenuBar'])
pal = opt.palette
item = opt
item.rect = opt.rect
if dis:
color = _COLORS['MenuBarItemDisabled']
else:
color = _COLORS['MenuBarItemEnabled']
pal.setBrush(QPalette.ButtonText, color)
item.palette = pal
QCommonStyle.drawControl(self, element, item, painter, widget)
if act:
pal = opt.palette
color = _COLORS['MenuBarHover']
painter.fillRect(opt.rect, color)
align = (Qt.AlignCenter | Qt.TextShowMnemonic | Qt.TextDontClip
| Qt.TextSingleLine)
if not self.styleHint(QStyle.SH_UnderlineShortcut, opt,
widget):
align |= Qt.TextHideMnemonic
# FIXME:
if dis:
co = _COLORS['IconDisabledColor']
else:
co = _COLORS['MenuBarTextHover']
painter.setPen(Qt.NoPen)
pal.setBrush(QPalette.Text, co)
self.drawItemText(painter, item.rect, align, pal, not dis,
opt.text, QPalette.Text)
painter.restore()
else:
QProxyStyle.drawControl(self, element, opt, painter, widget)
def createArrowBackground(self, transform):
scaledRect = transform.mapRect(
QRect(0, 0, self.logicalSize.width(), self.logicalSize.height()))
image = QImage(scaledRect.width(), scaledRect.height(),
QImage.Format_ARGB32_Premultiplied)
image.fill(QColor(0, 0, 0, 0).rgba())
painter = QPainter(image)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(Qt.NoPen)
if Colors.useEightBitPalette:
painter.setPen(QColor(120, 120, 120))
if self.pressed:
painter.setBrush(QColor(60, 60, 60))
elif self.highlighted:
painter.setBrush(QColor(100, 100, 100))
else:
painter.setBrush(QColor(80, 80, 80))
else:
outlinebrush = QLinearGradient(0, 0, 0, scaledRect.height())
brush = QLinearGradient(0, 0, 0, scaledRect.height())
brush.setSpread(QLinearGradient.PadSpread)
highlight = QColor(255, 255, 255, 70)
shadow = QColor(0, 0, 0, 70)
sunken = QColor(220, 220, 220, 30)
normal1 = QColor(200, 170, 160, 50)
normal2 = QColor(50, 10, 0, 50)
if self.pressed:
outlinebrush.setColorAt(0, shadow)
outlinebrush.setColorAt(1, highlight)
brush.setColorAt(0, sunken)
painter.setPen(Qt.NoPen)
else:
outlinebrush.setColorAt(1, shadow)
outlinebrush.setColorAt(0, highlight)
brush.setColorAt(0, normal1)
if not self.highlighted:
brush.setColorAt(1, normal2)
painter.setPen(QPen(outlinebrush, 1))
painter.setBrush(brush)
painter.drawRect(0, 0, scaledRect.width(), scaledRect.height())
xOff = scaledRect.width() / 2
yOff = scaledRect.height() / 2
sizex = 3.0 * transform.m11()
sizey = 1.5 * transform.m22()
if self.type == TextButton.UP:
sizey *= -1
path = QPainterPath()
path.moveTo(xOff, yOff + (5 * sizey))
path.lineTo(xOff - (4 * sizex), yOff - (3 * sizey))
path.lineTo(xOff + (4 * sizex), yOff - (3 * sizey))
path.lineTo(xOff, yOff + (5 * sizey))
painter.drawPath(path)
return image
def paint(self, painter, option, widget):
if canvas.scene.loading_items:
return
painter.save()
painter.setRenderHint(QPainter.Antialiasing,
bool(options.antialiasing == ANTIALIASING_FULL))
selected = self.isSelected()
theme = canvas.theme
if self.m_port_type == PORT_TYPE_AUDIO_JACK:
if self.m_is_alternate:
poly_color = theme.port_cv_jack_bg_sel if selected else theme.port_cv_jack_bg
poly_pen = theme.port_cv_jack_pen_sel if selected else theme.port_cv_jack_pen
else:
poly_color = theme.port_audio_jack_bg_sel if selected else theme.port_audio_jack_bg
poly_pen = theme.port_audio_jack_pen_sel if selected else theme.port_audio_jack_pen
text_pen = theme.port_audio_jack_text_sel if selected else theme.port_audio_jack_text
conn_pen = QPen(theme.port_audio_jack_pen_sel)
elif self.m_port_type == PORT_TYPE_MIDI_JACK:
poly_color = theme.port_midi_jack_bg_sel if selected else theme.port_midi_jack_bg
poly_pen = theme.port_midi_jack_pen_sel if selected else theme.port_midi_jack_pen
text_pen = theme.port_midi_jack_text_sel if selected else theme.port_midi_jack_text
conn_pen = QPen(theme.port_midi_jack_pen_sel)
elif self.m_port_type == PORT_TYPE_MIDI_ALSA:
poly_color = theme.port_midi_alsa_bg_sel if selected else theme.port_midi_alsa_bg
poly_pen = theme.port_midi_alsa_pen_sel if selected else theme.port_midi_alsa_pen
text_pen = theme.port_midi_alsa_text_sel if selected else theme.port_midi_alsa_text
conn_pen = QPen(theme.port_midi_alsa_pen_sel)
elif self.m_port_type == PORT_TYPE_PARAMETER:
poly_color = theme.port_parameter_bg_sel if selected else theme.port_parameter_bg
poly_pen = theme.port_parameter_pen_sel if selected else theme.port_parameter_pen
text_pen = theme.port_parameter_text_sel if selected else theme.port_parameter_text
conn_pen = QPen(theme.port_parameter_pen_sel)
else:
qCritical(
"PatchCanvas::CanvasPort.paint() - invalid port type '%s'" %
port_type2str(self.m_port_type))
return
# To prevent quality worsening
poly_pen = QPen(poly_pen)
poly_pen.setWidthF(poly_pen.widthF() + 0.00001)
lineHinting = poly_pen.widthF() / 2
poly_locx = [0, 0, 0, 0, 0, 0]
poly_corner_xhinting = ((float(canvas.theme.port_height) / 2) %
floor(float(canvas.theme.port_height) / 2))
if poly_corner_xhinting == 0:
poly_corner_xhinting = 0.5 * (
1 - 7 / (float(canvas.theme.port_height) / 2))
is_cv_port = bool(self.m_port_type == PORT_TYPE_AUDIO_JACK
and self.m_is_alternate)
if self.m_port_mode == PORT_MODE_INPUT:
text_pos = QPointF(3, canvas.theme.port_text_ypos)
if canvas.theme.port_mode == Theme.THEME_PORT_POLYGON and not is_cv_port:
poly_locx[0] = lineHinting
poly_locx[1] = self.m_port_width + 5 - lineHinting
poly_locx[2] = self.m_port_width + 12 - poly_corner_xhinting
poly_locx[3] = self.m_port_width + 5 - lineHinting
poly_locx[4] = lineHinting
poly_locx[5] = self.m_port_width
elif canvas.theme.port_mode == Theme.THEME_PORT_SQUARE or is_cv_port:
poly_locx[0] = lineHinting
poly_locx[1] = self.m_port_width + 5 - lineHinting
poly_locx[2] = self.m_port_width + 5 - lineHinting
poly_locx[3] = self.m_port_width + 5 - lineHinting
poly_locx[4] = lineHinting
poly_locx[5] = self.m_port_width
else:
qCritical(
"PatchCanvas::CanvasPort.paint() - invalid theme port mode '%s'"
% canvas.theme.port_mode)
return
elif self.m_port_mode == PORT_MODE_OUTPUT:
text_pos = QPointF(9, canvas.theme.port_text_ypos)
if canvas.theme.port_mode == Theme.THEME_PORT_POLYGON and not is_cv_port:
poly_locx[0] = self.m_port_width + 12 - lineHinting
poly_locx[1] = 7 + lineHinting
poly_locx[2] = 0 + poly_corner_xhinting
poly_locx[3] = 7 + lineHinting
poly_locx[4] = self.m_port_width + 12 - lineHinting
poly_locx[5] = 12 - lineHinting
elif canvas.theme.port_mode == Theme.THEME_PORT_SQUARE or is_cv_port:
poly_locx[0] = self.m_port_width + 12 - lineHinting
poly_locx[1] = 5 + lineHinting
poly_locx[2] = 5 + lineHinting
poly_locx[3] = 5 + lineHinting
poly_locx[4] = self.m_port_width + 12 - lineHinting
poly_locx[5] = 12 - lineHinting
else:
qCritical(
"PatchCanvas::CanvasPort.paint() - invalid theme port mode '%s'"
% canvas.theme.port_mode)
return
else:
qCritical(
"PatchCanvas::CanvasPort.paint() - invalid port mode '%s'" %
port_mode2str(self.m_port_mode))
return
polygon = QPolygonF()
if self.m_portgrp_id:
first_of_portgrp = False
last_of_portgrp = False
# look in portgroup if port is the first,
# the last, or not.
for portgrp in canvas.portgrp_list:
if portgrp.portgrp_id == self.m_portgrp_id:
if self.m_port_id == portgrp.port_id_list[0]:
first_of_portgrp = True
if self.m_port_id == portgrp.port_id_list[-1]:
last_of_portgrp = True
break
if first_of_portgrp:
polygon += QPointF(poly_locx[0], lineHinting)
polygon += QPointF(poly_locx[5], lineHinting)
else:
polygon += QPointF(poly_locx[0], 0)
polygon += QPointF(poly_locx[5], 0)
if last_of_portgrp:
polygon += QPointF(poly_locx[5],
canvas.theme.port_height - lineHinting)
polygon += QPointF(poly_locx[0],
canvas.theme.port_height - lineHinting)
else:
polygon += QPointF(poly_locx[5], canvas.theme.port_height)
polygon += QPointF(poly_locx[0], canvas.theme.port_height)
else:
polygon += QPointF(poly_locx[0], lineHinting)
polygon += QPointF(poly_locx[1], lineHinting)
polygon += QPointF(poly_locx[2],
float(canvas.theme.port_height) / 2)
polygon += QPointF(poly_locx[3],
canvas.theme.port_height - lineHinting)
polygon += QPointF(poly_locx[4],
canvas.theme.port_height - lineHinting)
polygon += QPointF(poly_locx[0], lineHinting)
if canvas.theme.port_bg_pixmap:
portRect = polygon.boundingRect().adjusted(-lineHinting + 1,
-lineHinting + 1,
lineHinting - 1,
lineHinting - 1)
portPos = portRect.topLeft()
painter.drawTiledPixmap(portRect, canvas.theme.port_bg_pixmap,
portPos)
else:
port_gradient = QLinearGradient(0, 0, 0, self.m_port_height)
dark_color = poly_color.darker(112)
light_color = poly_color.lighter(111)
if poly_color.lightness() > 127:
port_gradient.setColorAt(0, dark_color)
port_gradient.setColorAt(0.5, light_color)
port_gradient.setColorAt(1, dark_color)
else:
port_gradient.setColorAt(0, light_color)
port_gradient.setColorAt(0.5, dark_color)
port_gradient.setColorAt(1, light_color)
painter.setBrush(port_gradient)
painter.setPen(poly_pen)
painter.drawPolygon(polygon)
if self.m_is_alternate and not self.m_portgrp_id:
if is_cv_port:
poly_pen.setWidthF(2.000001)
painter.setPen(poly_pen)
y_line = canvas.theme.port_height / 2.0
if self.m_port_mode == PORT_MODE_OUTPUT:
painter.drawLine(QPointF(0.0, y_line),
QPointF(float(poly_locx[1]), y_line))
elif self.m_port_mode == PORT_MODE_INPUT:
painter.drawLine(QPointF(self.m_port_width + 5.0, y_line),
QPointF(self.m_port_width + 12.0, y_line))
else:
# draw the little circle for a2j (or MidiBridge) port
poly_pen.setWidthF(1.000001)
painter.setBrush(canvas.theme.box_bg_1)
ellipse_x = poly_locx[1]
if self.m_port_mode == PORT_MODE_OUTPUT:
ellipse_x -= 2
elif self.m_port_mode == PORT_MODE_INPUT:
ellipse_x += 2
painter.drawEllipse(
QPointF(ellipse_x, canvas.theme.port_height / 2.0), 2, 2)
painter.setPen(text_pen)
painter.setFont(self.m_port_font)
sizer = QFontMetrics(self.m_port_font)
sep_width = sizer.width(self.m_trunck_sep)
if self.m_portgrp_id:
print_name_size = self.get_text_width()
if self.m_port_mode == PORT_MODE_OUTPUT:
text_pos = QPointF(self.m_port_width + 9 - print_name_size,
canvas.theme.port_text_ypos)
if print_name_size > (self.m_port_width - 4):
painter.setPen(QPen(port_gradient, 3))
painter.drawLine(
QPointF(float(poly_locx[5]), 3.0),
QPointF(float(poly_locx[5]),
canvas.theme.port_height - 3.0))
painter.setPen(text_pen)
painter.setFont(self.m_port_font)
painter.drawText(text_pos, self.m_print_name)
if self.m_name_truncked:
sep_x = text_pos.x() + sizer.width(self.m_print_name)
painter.drawText(QPointF(sep_x + sep_width, text_pos.y()),
self.m_print_name_right)
painter.setPen(poly_pen)
painter.drawText(QPointF(sep_x,
text_pos.y() + 1), self.m_trunck_sep)
if canvas.theme.idx == Theme.THEME_OOSTUDIO and canvas.theme.port_bg_pixmap:
painter.setPen(Qt.NoPen)
painter.setBrush(conn_pen.brush())
if self.m_port_mode == PORT_MODE_INPUT:
connRect = QRectF(portRect.topLeft(),
QSizeF(2, portRect.height()))
else:
connRect = QRectF(
QPointF(portRect.right() - 2, portRect.top()),
QSizeF(2, portRect.height()))
painter.drawRect(connRect)
painter.restore()
def paintEvent(self, event):
option = QStyleOption()
option.initFrom(self)
contents_rect = self.style().subElementRect(
QStyle.SE_FrameContents, option, self
) or self.contentsRect(
) # the SE_FrameContents rect is Null unless the stylesheet defines decorations
if self.graphStyle == self.BarStyle:
graph_width = self.__dict__['graph_width'] = int(
ceil(
float(contents_rect.width()) /
self.horizontalPixelsPerUnit))
else:
graph_width = self.__dict__['graph_width'] = int(
ceil(
float(contents_rect.width() - 1) /
self.horizontalPixelsPerUnit) + 1)
max_value = self.__dict__['max_value'] = max(
chain([0],
*(islice(reversed(graph.data), graph_width)
for graph in self.graphs if graph.enabled)))
if self.graphHeight == self.AutomaticHeight or self.graphHeight < 0:
graph_height = self.__dict__['graph_height'] = max(
self.scaler.get_height(max_value), self.minHeight)
else:
graph_height = self.__dict__['graph_height'] = max(
self.graphHeight, self.minHeight)
if self.graphStyle == self.BarStyle:
height_scaling = float(contents_rect.height()) / graph_height
else:
height_scaling = float(contents_rect.height() -
self.lineThickness) / graph_height
painter = QStylePainter(self)
painter.drawPrimitive(QStyle.PE_Widget, option)
painter.setClipRect(contents_rect)
painter.save()
painter.translate(contents_rect.x() + contents_rect.width() - 1,
contents_rect.y() + contents_rect.height() - 1)
painter.scale(-1, -1)
painter.setRenderHint(QStylePainter.Antialiasing,
self.graphStyle != self.BarStyle)
for graph in (graph for graph in self.graphs
if graph.enabled and graph.data):
if self.boundary is not None and 0 < self.boundary < graph_height:
boundary_width = min(5.0 / height_scaling, self.boundary - 0,
graph_height - self.boundary)
pen_color = QLinearGradient(
0, (self.boundary - boundary_width) * height_scaling, 0,
(self.boundary + boundary_width) * height_scaling)
pen_color.setColorAt(0, graph.color)
pen_color.setColorAt(1, graph.over_boundary_color)
brush_color = QLinearGradient(
0, (self.boundary - boundary_width) * height_scaling, 0,
(self.boundary + boundary_width) * height_scaling)
brush_color.setColorAt(
0, self.color_with_alpha(graph.color,
self.fillTransparency))
brush_color.setColorAt(
1,
self.color_with_alpha(graph.over_boundary_color,
self.fillTransparency))
else:
pen_color = graph.color
brush_color = self.color_with_alpha(graph.color,
self.fillTransparency)
dataset = islice(reversed(graph.data), graph_width)
if self.graphStyle == self.BarStyle:
lines = [
QLineF(x * self.horizontalPixelsPerUnit, 0,
x * self.horizontalPixelsPerUnit,
y * height_scaling) for x, y in enumerate(dataset)
]
painter.setPen(QPen(pen_color, self.lineThickness))
painter.drawLines(lines)
else:
painter.translate(0, +self.lineThickness / 2 - 1)
if self.smoothEnvelope and self.smoothFactor > 0:
min_value = 0
max_value = graph_height * height_scaling
cx_offset = self.horizontalPixelsPerUnit / 3.0
smoothness = self.smoothFactor
last_values = deque(
3 * [next(dataset) * height_scaling], maxlen=3
) # last 3 values: 0 last, 1 previous, 2 previous previous
envelope = QPainterPath()
envelope.moveTo(0, last_values[0])
for x, y in enumerate(dataset, 1):
x = x * self.horizontalPixelsPerUnit
y = y * height_scaling * (
1 - smoothness) + last_values[0] * smoothness
last_values.appendleft(y)
c1x = x - cx_offset * 2
c2x = x - cx_offset
c1y = limit(
(1 + smoothness) * last_values[1] -
smoothness * last_values[2], min_value, max_value
) # same gradient as previous previous value to previous value
c2y = limit(
(1 - smoothness) * last_values[0] +
smoothness * last_values[1], min_value, max_value
) # same gradient as previous value to last value
envelope.cubicTo(c1x, c1y, c2x, c2y, x, y)
else:
envelope = QPainterPath()
envelope.addPolygon(
QPolygonF([
QPointF(x * self.horizontalPixelsPerUnit,
y * height_scaling)
for x, y in enumerate(dataset)
]))
if self.fillEnvelope or graph.fill_envelope:
first_element = envelope.elementAt(0)
last_element = envelope.elementAt(envelope.elementCount() -
1)
fill_path = QPainterPath()
fill_path.moveTo(last_element.x, last_element.y)
fill_path.lineTo(last_element.x + 1, last_element.y)
fill_path.lineTo(last_element.x + 1, -self.lineThickness)
fill_path.lineTo(-self.lineThickness, -self.lineThickness)
fill_path.lineTo(-self.lineThickness, first_element.y)
fill_path.connectPath(envelope)
painter.fillPath(fill_path, brush_color)
painter.strokePath(
envelope,
QPen(pen_color, self.lineThickness, join=Qt.RoundJoin))
painter.translate(0, -self.lineThickness / 2 + 1)
if self.boundary is not None and self.boundaryColor:
painter.setRenderHint(QStylePainter.Antialiasing, False)
painter.setPen(QPen(self.boundaryColor, 1.0))
painter.drawLine(0, self.boundary * height_scaling,
contents_rect.width(),
self.boundary * height_scaling)
painter.restore()
# queue the 'updated' signal to be emitted after returning to the main loop
QMetaObject.invokeMethod(self, 'updated', Qt.QueuedConnection)
def create_gradient(color, darker=300):
gradient = QLinearGradient(0, 0, 0, 100)
gradient.setColorAt(0.0, color)
gradient.setColorAt(1.0, color.darker(darker))
return gradient
axisMinSliderZ = QSlider(Qt.Horizontal, minimum=0, tickInterval=1)
axisMaxSliderZ = QSlider(Qt.Horizontal, minimum=1, tickInterval=1)
themeList = QComboBox()
themeList.addItem("Qt")
themeList.addItem("Primary Colors")
themeList.addItem("Digia")
themeList.addItem("Stone Moss")
themeList.addItem("Army Blue")
themeList.addItem("Retro")
themeList.addItem("Ebony")
themeList.addItem("Isabelle")
colorGroupBox = QGroupBox("Custom gradient")
grBtoY = QLinearGradient(0, 0, 1, 100)
grBtoY.setColorAt(1.0, Qt.black)
grBtoY.setColorAt(0.67, Qt.blue)
grBtoY.setColorAt(0.33, Qt.red)
grBtoY.setColorAt(0.0, Qt.yellow)
pm = QPixmap(24, 100)
pmp = QPainter(pm)
pmp.setBrush(QBrush(grBtoY))
pmp.setPen(Qt.NoPen)
pmp.drawRect(0, 0, 24, 100)
gradientBtoYPB = QPushButton()
gradientBtoYPB.setIcon(QIcon(pm))
gradientBtoYPB.setIconSize(QSize(24, 100))
grGtoR = QLinearGradient(0, 0, 1, 100)
grGtoR.setColorAt(1.0, Qt.darkGreen)
def createImage(self, transform):
original = QImage(self.image)
if original.isNull():
return original
size = transform.map(QPoint(self.maxWidth, self.maxHeight))
w = size.x()
h = size.y()
# Optimization: if image is smaller than maximum allowed size, just
# return the loaded image.
if original.size().height() <= h and original.size().width(
) <= w and not self.adjustSize and self.scale == 1:
return original
# Calculate what the size of the final image will be.
w = min(w, float(original.size().width()) * self.scale)
h = min(h, float(original.size().height()) * self.scale)
adjustx = 1.0
adjusty = 1.0
if self.adjustSize:
adjustx = min(transform.m11(), transform.m22())
adjusty = max(transform.m22(), adjustx)
w *= adjustx
h *= adjusty
# Create a new image with correct size, and draw original on it.
image = QImage(int(w + 2), int(h + 2),
QImage.Format_ARGB32_Premultiplied)
image.fill(QColor(0, 0, 0, 0).rgba())
painter = QPainter(image)
painter.setRenderHints(QPainter.Antialiasing
| QPainter.SmoothPixmapTransform)
if self.adjustSize:
painter.scale(adjustx, adjusty)
if self.scale != 1:
painter.scale(self.scale, self.scale)
painter.drawImage(0, 0, original)
if not self.adjustSize:
# Blur out edges.
blur = 30
if h < original.height():
brush1 = QLinearGradient(0, h - blur, 0, h)
brush1.setSpread(QLinearGradient.PadSpread)
brush1.setColorAt(0.0, QColor(0, 0, 0, 0))
brush1.setColorAt(1.0, Colors.sceneBg1)
painter.fillRect(0,
int(h) - blur, original.width(), int(h),
brush1)
if w < original.width():
brush2 = QLinearGradient(w - blur, 0, w, 0)
brush2.setSpread(QLinearGradient.PadSpread)
brush2.setColorAt(0.0, QColor(0, 0, 0, 0))
brush2.setColorAt(1.0, Colors.sceneBg1)
painter.fillRect(
int(w) - blur, 0, int(w), original.height(), brush2)
return image
@site: https://pyqt5.com https://github.com/892768447 @email: [email protected] @file: Test.TestGradientUtils @description: """ from PyQt5.QtCore import Qt from PyQt5.QtGui import QLinearGradient, QRadialGradient, QConicalGradient,\ QColor from Utils.GradientUtils import GradientUtils __Author__ = 'Irony' __Copyright__ = 'Copyright (c) 2019' # 线性渐变 linearGradient = QLinearGradient(0, 0, 1, 1) linearGradient.setColorAt(0.0, Qt.green) linearGradient.setColorAt(0.2, Qt.white) linearGradient.setColorAt(0.4, Qt.blue) linearGradient.setColorAt(0.6, Qt.red) linearGradient.setColorAt(1.0, Qt.yellow) print(GradientUtils.styleSheetCode(linearGradient)) # 辐射渐变 radialGradient = QRadialGradient(0, 0, 1, 1, 110) radialGradient.setColorAt(0, Qt.green) radialGradient.setColorAt(0.4, Qt.blue) radialGradient.setColorAt(1.0, Qt.yellow) print(GradientUtils.styleSheetCode(radialGradient))
def drawAIGlobalFeatures(self, painter, mainArea, paintArea):
painter.resetTransform()
painter.translate(mainArea.center())
pitchPixels = self.pitchAngleToTranslation(mainArea.height(),
self.pitch)
gradientEnd = self.pitchAngleToTranslation(mainArea.height(), 60)
if math.isnan(self.roll) == False: # check for NaN
painter.rotate(-self.roll)
painter.translate(0, pitchPixels)
# Calculate the radius of area we need to paint to cover all.
rtx = painter.transform().inverted()[0]
topLeft = rtx.map(paintArea.topLeft())
topRight = rtx.map(paintArea.topRight())
bottomLeft = rtx.map(paintArea.bottomLeft())
bottomRight = rtx.map(paintArea.bottomRight())
# Just KISS... make a rectangluar basis.
minx = self.min4(topLeft.x(), topRight.x(), bottomLeft.x(),
bottomRight.x())
maxx = self.max4(topLeft.x(), topRight.x(), bottomLeft.x(),
bottomRight.x())
miny = self.min4(topLeft.y(), topRight.y(), bottomLeft.y(),
bottomRight.y())
maxy = self.max4(topLeft.y(), topRight.y(), bottomLeft.y(),
bottomRight.y())
hzonLeft = QPoint(minx, 0)
hzonRight = QPoint(maxx, 0)
skyPath = QPainterPath(hzonLeft)
skyPath.lineTo(QPointF(minx, miny))
skyPath.lineTo(QPointF(maxx, miny))
skyPath.lineTo(hzonRight)
skyPath.closeSubpath()
# TODO: The gradient is wrong now.
skyGradient = QLinearGradient(0, -gradientEnd, 0, 0)
skyGradient.setColorAt(0, QColor.fromHsvF(0.6, 1.0, 0.7))
skyGradient.setColorAt(1, QColor.fromHsvF(0.6, 0.25, 0.9))
skyBrush = QBrush(skyGradient)
painter.fillPath(skyPath, skyBrush)
groundPath = QPainterPath(hzonRight)
groundPath.lineTo(maxx, maxy)
groundPath.lineTo(minx, maxy)
groundPath.lineTo(hzonLeft)
groundPath.closeSubpath()
groundGradient = QLinearGradient(0, gradientEnd, 0, 0)
groundGradient.setColorAt(0, QColor.fromHsvF(0.25, 1, 0.5))
groundGradient.setColorAt(1, QColor.fromHsvF(0.25, 0.25, 0.5))
groundBrush = QBrush(groundGradient)
painter.fillPath(groundPath, groundBrush)
pen = QPen()
pen.setWidthF(self.lineWidth)
pen.setColor(QColor(0, 255, 0))
painter.setPen(pen)
start = QPointF(-mainArea.width(), 0)
end = QPoint(mainArea.width(), 0)
painter.drawLine(start, end)
def drawWidget(self, qp):
# color settings:
cWhite = QColor(255, 255, 255)
cBlack = QColor(0, 0, 0)
cDarkGreen = QColor(119, 177, 80)
cOrangeYellow = QColor(255, 208, 98)
cLightGrey = QColor(155, 155, 155)
cBackGroundNorm = cWhite # Normal Widget Background
cBackGroundOutOfRange = QColor(
255, 230, 230) # Widget Background if parameter is at bound
cAxis = QColor(215, 215, 215) # Axis and Scale bars
cBoundInterval = cBlack # axis interval bewtween bounds
cPrefValueMarker = QColor(31, 78, 121) # preferred Value Marker
cPrefValueRange = QColor(95, 157, 214) # prior information range
cCurrentValueMarker = QColor(216, 108, 0)
cPosteriorValueRange = cOrangeYellow
cValueMarkerOutOfRange = QColor(255, 38, 0)
cDevInterval = QColor(255, 50, 50)
# shape settings
yAxisWidth = 1
yDrawAreaHeight = 15
xHorizontalMargin = 10
xMarkerCurrentWidth = 1
yMarkerCurrentHeight = 7
yPosteriorHeight = 7
xMarkerPrefWidth = 1
yMarkerPrefHeight = 3
yPriorHeight = 3
yBracketHeight = 3
yDevBarHeight = 5
# important locations:
actualWidgetSize = self.size()
w = actualWidgetSize.width()
h = actualWidgetSize.height()
xDrawAreaWidth = w - 2 * xHorizontalMargin
xLeft = xHorizontalMargin
xRight = actualWidgetSize.width() - xHorizontalMargin
xCenter = int((xLeft + xRight) / 2)
yCenter = int(h / 2)
yHigh = yCenter - (yDrawAreaHeight - 1) / 2
yLow = yCenter + (yDrawAreaHeight - 1) / 2
# some pointers for better readability:
parval = self.parval
prefval = self.prefval
axmin = self.minAxis
axmax = self.maxAxis
parlbnd = self.parlbnd
parubnd = self.parubnd
prior = self.priorStdev
posterior = self.posteriorStdev
# check if value is out of range
if self.parval <= self.parlbnd or self.parval >= self.parubnd:
cBackground = cBackGroundOutOfRange
else:
cBackground = cBackGroundNorm
# paint background:
rectBackground = QRect(0, 0, w - 1, h - 1) # left, top, height, width
qp.setPen(cWhite)
qp.setBrush(cBackground)
qp.drawRect(rectBackground)
# paint posterior parameter range
center = xHorizontalMargin + xDrawAreaWidth * (parval -
axmin) / (axmax - axmin)
width = int(posterior * xDrawAreaWidth / (axmax - axmin) * 6)
left = int(center - width / 2)
top = yCenter - yPosteriorHeight
height = yPosteriorHeight
rectPosteriorRange = QRect(left, top, width, height)
gradient = QLinearGradient(QPointF(left, top),
QPointF(left + width / 2, top + height))
gradient.setSpread(1)
gradient.setStops([(0, cBackground), (0.66, cPosteriorValueRange),
(1, cPosteriorValueRange)])
qp.setBrush(gradient)
qp.setPen(Qt.NoPen)
if self.PostCalRangeVisible:
qp.drawRect(rectPosteriorRange)
# draw scale
scalebars = [self.scaleBase]
while scalebars[0] > axmin:
scalebars.insert(0, scalebars[0] - self.scaleInterval)
while scalebars[-1] < axmax:
scalebars.append(scalebars[-1] + self.scaleInterval)
for sb in scalebars:
sbx = xHorizontalMargin + (xDrawAreaWidth * (sb - axmin) /
(axmax - axmin))
LineSb = QLine(sbx, yCenter - 1, sbx, yCenter + 2)
qp.setPen(cAxis)
qp.drawLine(LineSb)
# paint current parameter marker
xCurrentMCenter = xHorizontalMargin + xDrawAreaWidth * (
parval - axmin) / (axmax - axmin)
left = xCurrentMCenter - (xMarkerCurrentWidth - 1) / 2
rectCurrentParvalue = QRect(left, yCenter - yMarkerCurrentHeight,
xMarkerCurrentWidth, yMarkerCurrentHeight)
if self.parval <= self.parlbnd or self.parval >= self.parubnd:
qp.setBrush(cValueMarkerOutOfRange)
qp.setPen(cValueMarkerOutOfRange)
else:
qp.setBrush(cCurrentValueMarker)
qp.setPen(cCurrentValueMarker)
qp.drawRect(rectCurrentParvalue)
# paint prior parameter range
center = xHorizontalMargin + xDrawAreaWidth * (prefval -
axmin) / (axmax - axmin)
width = int(prior * xDrawAreaWidth / (axmax - axmin) * 6)
left = int(center - width / 2)
top = int(h / 2) + 1
height = yPriorHeight
rectPriorRange = QRect(left, yCenter + 1, width, yPriorHeight)
gradient = QLinearGradient(QPointF(left, top),
QPointF(left + width / 2, top + height))
gradient.setSpread(1)
gradient.setStops([(0, cBackground), (0.66, cPrefValueRange),
(1, cPrefValueRange)])
qp.setBrush(gradient)
qp.setPen(Qt.NoPen)
if self.PreCalRangeVisible:
qp.drawRect(rectPriorRange)
# paint preferred parameter marker
xPrefMCenter = xHorizontalMargin + xDrawAreaWidth * (
prefval - axmin) / (axmax - axmin)
left = xPrefMCenter - (xMarkerPrefWidth - 1) / 2
rectPrefParvalue = QRect(left, yCenter + 1, xMarkerPrefWidth,
yMarkerPrefHeight)
qp.setBrush(cPrefValueMarker)
qp.setPen(cPrefValueMarker)
qp.drawRect(rectPrefParvalue)
# draw parameter axis
lineAxis = QLine(xLeft, yCenter, xRight, yCenter)
# qp.setPen(Qt.DotLine)
qp.setPen(cAxis)
qp.drawLine(lineAxis)
# draw bound bracket
xUbound = xHorizontalMargin + (xDrawAreaWidth * (parubnd - axmin) /
(axmax - axmin))
xLbound = xHorizontalMargin + (xDrawAreaWidth * (parlbnd - axmin) /
(axmax - axmin))
LineUbound = QLine(xUbound, yCenter - yBracketHeight, xUbound, yCenter)
LineLbound = QLine(xLbound, yCenter, xLbound, yCenter - yBracketHeight)
LineBoundInterval = QLine(xLbound, yCenter, xUbound, yCenter)
qp.setPen(cBoundInterval)
if self.BoundBracketVisible:
qp.drawLine(LineUbound)
qp.drawLine(LineBoundInterval)
qp.drawLine(LineLbound)
# draw deviation bracket
"""
LineCbound = QLine(xCurrentMCenter, yCenter - yBracketHeight, xCurrentMCenter, yCenter)
LinePbound = QLine(xPrefMCenter, yCenter, xPrefMCenter, yCenter + yBracketHeight)
LineDevInterval = QLine(xCurrentMCenter, yCenter, xPrefMCenter, yCenter)
qp.setPen(cDevInterval)
qp.drawLine(LineCbound)
qp.drawLine(LinePbound)
qp.drawLine(LineDevInterval)
"""
# draw deviation bar
center = xHorizontalMargin + xDrawAreaWidth * (prefval -
axmin) / (axmax - axmin)
width = xUbound - xLbound
left = xLbound
top = yCenter - yDevBarHeight / 2
height = yDevBarHeight
rect1stdev = QRect(center, top, xCurrentMCenter - xPrefMCenter, height)
gradient = QLinearGradient(QPointF(left, top),
QPointF(left + width / 2, top + height))
gradient.setSpread(1)
gradient.setStops([(1.00, cDarkGreen), (0.67, cDarkGreen),
(0.65, cOrangeYellow), (0.34, cOrangeYellow),
(0.32, cValueMarkerOutOfRange),
(0.00, cValueMarkerOutOfRange)])
qp.setPen(Qt.NoPen)
qp.setBrush(gradient)
if self.DevBarVisible:
qp.drawRect(rect1stdev)
def drawPrimitive(self, element, opt, painter, widget):
if not self.__panel_widget(widget):
return QProxyStyle.drawPrimitive(self, element, opt, painter,
widget)
if element == QStyle.PE_PanelButtonTool:
flat = theme.flag("FlatComboBox")
pressed = (opt.state & STATE_SUNKEN or opt.state & STATE_ON)
hovered = opt.state & STATE_ENABLED and opt.state & STATE_MOUSEOVER
button_color = theme.get_color('ToolButtonColor')
if not flat and widget.property("gradient"):
base = QColor(theme.get_color('Window'))
button_color = QLinearGradient(opt.rect.topRight(),
opt.rect.bottomRight())
button_color.setColorAt(0.2, base.lighter(150))
button_color.setColorAt(0.9, base.darker(135))
if pressed:
button_color = theme.get_color('ToolButtonSelected')
elif hovered:
if not flat and widget.property("gradient"):
button_color.setColorAt(0.2, base.lighter(160))
button_color.setColorAt(0.9, base.darker(100))
else:
button_color = theme.get_color('ToolButtonHover')
if widget.property("border_bottom"):
painter.setPen(theme.get_color('Border'))
painter.drawLine(opt.rect.bottomLeft(), opt.rect.bottomRight())
painter.fillRect(opt.rect.adjusted(1, 1, -1, -1), button_color)
# elif not opt.state & STATE_ENABLED:
# color = _PALETTE['ButtonDisabled']
# painter.fillRect(opt.rect, color)
# TODO: keyboard focus change state
# elif element == QStyle.PE_PanelButtonCommand:
# Draw a flat push button
# is_down = opt.state & STATE_SUNKEN or opt.state & STATE_ON
# is_enabled = opt.state & STATE_ENABLED
# is_hover = is_enabled and opt.state & STATE_MOUSEOVER
# FIXME: has_focus state
# FIXME: from theme
# color = QColor("#444a58")
# if is_down:
# color = color.darker(130)
# elif is_hover:
# color = color.lighter(110)
# painter.fillRect(opt.rect, color)
elif element == QStyle.PE_PanelLineEdit:
painter.save()
# Fill background
rect = opt.rect
enabled = False
if opt.state & STATE_ENABLED:
enabled = True
if not enabled:
painter.setOpacity(0.55)
painter.fillRect(rect, theme.get_color('LineEditBackground'))
has_focus = False
if opt.state & QStyle.State_HasFocus:
has_focus = True
if enabled and (has_focus or opt.state & STATE_MOUSEOVER):
# FIXME: color from theme
# hover = QColor("#6a6ea9")
# if has_focus:
# alpha = 200
# else:
# alpha = 55
# hover.setAlpha(alpha)
# painter.setPen(QPen(hover, 2, Qt.SolidLine,
# Qt.SquareCap, Qt.RoundJoin))
# painter.drawRect(rect.adjusted(0, 0, 0, 0))
pass
painter.restore()
elif element == QStyle.PE_IndicatorToolBarSeparator:
rect = opt.rect
painter.setPen(theme.get_color('SeparatorColor'))
border_rect = QRectF(rect).adjusted(0.5, 0.5, -0.5, -0.5)
if opt.state & QStyle.State_Horizontal:
border_rect.setWidth(1)
painter.drawLine(border_rect.topRight() + QPointF(0, 3),
border_rect.bottomRight() - QPointF(0, 3))
else:
border_rect.setHeight(1)
painter.drawLine(border_rect.topLeft() + QPointF(3, 0),
border_rect.topRight() - QPointF(3, 0))
elif element == QStyle.PE_IndicatorToolBarHandle:
# FIXME: draw a fancy handler
QProxyStyle.drawPrimitive(self, element, opt, painter, widget)
else:
QProxyStyle.drawPrimitive(self, element, opt, painter, widget)
def __init__(self, parent, index=0):
QDial.__init__(self, parent)
self.fDialMode = self.MODE_LINEAR
self.fMinimum = 0.0
self.fMaximum = 1.0
self.fRealValue = 0.0
self.fPrecision = 10000
self.fIsInteger = False
self.fIsHovered = False
self.fIsPressed = False
self.fHoverStep = self.HOVER_MIN
self.fLastDragPos = None
self.fLastDragValue = 0.0
self.fIndex = index
self.fPixmap = QPixmap(":/bitmaps/dial_01d.png")
self.fPixmapNum = "01"
if self.fPixmap.width() > self.fPixmap.height():
self.fPixmapOrientation = self.HORIZONTAL
else:
self.fPixmapOrientation = self.VERTICAL
self.fLabel = ""
self.fLabelPos = QPointF(0.0, 0.0)
self.fLabelFont = QFont(self.font())
self.fLabelFont.setPixelSize(8)
self.fLabelWidth = 0
self.fLabelHeight = 0
if self.palette().window().color().lightness() > 100:
# Light background
c = self.palette().dark().color()
self.fLabelGradientColor1 = c
self.fLabelGradientColor2 = QColor(c.red(), c.green(), c.blue(), 0)
self.fLabelGradientColorT = [
self.palette().buttonText().color(),
self.palette().mid().color()
]
else:
# Dark background
self.fLabelGradientColor1 = QColor(0, 0, 0, 255)
self.fLabelGradientColor2 = QColor(0, 0, 0, 0)
self.fLabelGradientColorT = [Qt.white, Qt.darkGray]
self.fLabelGradient = QLinearGradient(0, 0, 0, 1)
self.fLabelGradient.setColorAt(0.0, self.fLabelGradientColor1)
self.fLabelGradient.setColorAt(0.6, self.fLabelGradientColor1)
self.fLabelGradient.setColorAt(1.0, self.fLabelGradientColor2)
self.fLabelGradientRect = QRectF(0.0, 0.0, 0.0, 0.0)
self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_NULL
self.fCustomPaintColor = QColor(0xff, 0xff, 0xff)
self.updateSizes()
# Fake internal value, custom precision
QDial.setMinimum(self, 0)
QDial.setMaximum(self, self.fPrecision)
QDial.setValue(self, 0)
self.valueChanged.connect(self.slot_valueChanged)