def updateLineGradient(self):
pos_top = self.boundingRect().top()
pos_bot = self.boundingRect().bottom()
if self.item2.scenePos().y() >= self.item1.scenePos().y():
pos1 = 0
pos2 = 1
else:
pos1 = 1
pos2 = 0
port_type1 = self.item1.getPortType()
port_type2 = self.item2.getPortType()
port_gradient = QLinearGradient(0, pos_top, 0, pos_bot)
#if port_type1 == PORT_TYPE_AUDIO_JACK:
#port_gradient.setColorAt(pos1, canvas.theme.line_audio_jack_sel if self.m_lineSelected else canvas.theme.line_audio_jack)
#elif port_type1 == PORT_TYPE_MIDI_JACK:
#port_gradient.setColorAt(pos1, canvas.theme.line_midi_jack_sel if self.m_lineSelected else canvas.theme.line_midi_jack)
#elif port_type1 == PORT_TYPE_MIDI_ALSA:
#port_gradient.setColorAt(pos1, canvas.theme.line_midi_alsa_sel if self.m_lineSelected else canvas.theme.line_midi_alsa)
#elif port_type1 == PORT_TYPE_PARAMETER:
#port_gradient.setColorAt(pos1, canvas.theme.line_parameter_sel if self.m_lineSelected else canvas.theme.line_parameter)
#if port_type2 == PORT_TYPE_AUDIO_JACK:
#port_gradient.setColorAt(pos2, canvas.theme.line_audio_jack_sel if self.m_lineSelected else canvas.theme.line_audio_jack)
#elif port_type2 == PORT_TYPE_MIDI_JACK:
#port_gradient.setColorAt(pos2, canvas.theme.line_midi_jack_sel if self.m_lineSelected else canvas.theme.line_midi_jack)
#elif port_type2 == PORT_TYPE_MIDI_ALSA:
#port_gradient.setColorAt(pos2, canvas.theme.line_midi_alsa_sel if self.m_lineSelected else canvas.theme.line_midi_alsa)
#elif port_type2 == PORT_TYPE_PARAMETER:
#port_gradient.setColorAt(pos2, canvas.theme.line_parameter_sel if self.m_lineSelected else canvas.theme.line_parameter)
base_color = canvas.theme.line_audio_jack
if self.m_lineSelected:
base_color = canvas.theme.line_audio_jack_sel
if port_type1 == PORT_TYPE_MIDI_JACK:
base_color = canvas.theme.port_midi_jack_bg
if self.m_lineSelected:
base_color = canvas.theme.port_midi_jack_bg_sel
if self.m_is_semi_hidden:
base_color = QColor(
int(base_color.red() * canvas.semi_hide_opacity + 0.5),
int(base_color.green() * canvas.semi_hide_opacity + 0.5),
int(base_color.blue() * canvas.semi_hide_opacity + 0.5))
if self.m_ready_to_disc:
port_gradient.setColorAt(pos1, QColor(34, 34, 34))
port_gradient.setColorAt(pos2, QColor(34, 34, 34))
self.setPen(QPen(port_gradient, 2, Qt.DotLine))
else:
port_gradient.setColorAt(0, base_color.lighter(130))
port_gradient.setColorAt(0.5, base_color.darker(130))
port_gradient.setColorAt(1, base_color.lighter(130))
self.setPen(QPen(port_gradient, 1.750001, Qt.SolidLine, Qt.FlatCap))
def highlightCurrentLine(self):
extraSelections = []
if not self.isReadOnly():
selection = QTextEdit.ExtraSelection()
lineColor = QColor()
lineColor.setNamedColor('#102020')
lineColor.lighter(500)
selection.format.setBackground(lineColor)
selection.format.setProperty(QTextFormat.FullWidthSelection, True)
selection.cursor = self.textCursor()
selection.cursor.clearSelection()
extraSelections.append(selection)
self.setExtraSelections(extraSelections)
def drawSquare(self, painter, x, y, shape):
colorTable = {
0: 0xcccccc,
2: 0xfccff0,
4: 0xCC6666,
8: 0x66CC66,
16: 0x06eC66,
32: 0xCCCC66,
64: 0xCC66CC,
128: 0x66CCCC,
256: 0xDAAA00,
512: 0x00CC66,
1024: 0x0000CC,
2048: 0x66CCCC,
}
color = QColor(colorTable[shape])
# 画出格子
painter.fillRect(x + 5, y + 5, self.squareWidth() - 10,
self.squareHeight() - 10, color)
# 画数字，0不用画
if shape != 0:
painter.setPen(color.lighter())
painter.setFont(QFont('Decorative', 20))
painter.drawText(x + 5, y-5,
self.squareHeight(), self.squareWidth(), Qt.AlignCenter, str(shape))
def addBreakdownSeries(self, series, color):
# Add breakdown series as a slice to center pie.
slice = self.mainSeries.append(series.name(), series.sum())
# Customize the slice.
slice.setBrush(color)
slice.setLabelVisible()
slice.setLabelColor(Qt.white)
slice.setLabelPosition(QPieSlice.LabelInsideHorizontal)
# Position and customize the breakdown series.
series.setPieSize(0.8)
series.setHoleSize(0.7)
series.setLabelsVisible()
color = QColor(color)
for slice in series.slices():
color = color.lighter(115)
slice.setBrush(color)
slice.setLabelFont(QFont("Arial", 8))
# Add the series to the chart.
self.addSeries(series)
# Recalculate breakdown donut segments.
self.recalculateAngles()
def labelLines(self, img: Optional[QPixmap], toSrc: bool):
if not img or not self.lines:
return None
painter = QPainter()
painter.begin(img)
painter.setRenderHint(QPainter.Antialiasing, True)
pen = QPen()
pen.setCapStyle(Qt.RoundCap)
font = QFont('Consolas')
if toSrc:
pen.setWidthF(config.lineWidth * self.ratioToSrc)
font.setPointSizeF(config.fontSize * self.ratioToSrc)
else:
pen.setWidthF(config.lineWidth)
font.setPointSizeF(config.fontSize)
painter.setFont(font)
for (indexA, indexB), color in self.lines.items():
isHighlight = indexA in self.highlightPoints and indexB in self.highlightPoints \
and (self.mode == LabelMode.AngleMode or self.mode == LabelMode.VerticalMode)
pen.setColor(QColor.lighter(color) if isHighlight else color)
painter.setPen(pen)
A = self.points[indexA][0]
B = self.points[indexB][0]
srcA = self.getSrcPoint(A)
srcB = self.getSrcPoint(B)
labelPoint: QPointF
if toSrc:
painter.drawLine(srcA, srcB)
labelPoint = static.getMidpoint(srcA, srcB)
else:
painter.drawLine(A, B)
labelPoint = static.getMidpoint(A, B)
painter.drawText(static.getDistanceShift(A, B, labelPoint), str(round(static.getDistance(srcA, srcB), 2)))
painter.end()
def draw_storey(self, painter, x, y, storey_state):
color_table = [Qt.black, Qt.yellow, Qt.blue]
color = QColor(color_table[storey_state])
painter.fillRect(x + 1, y + 1,
self.square_width() - 2,
self.square_height() - 2, color)
painter.setPen(color.lighter())
painter.drawLine(x, y + self.square_height() - 1, x, y)
painter.drawLine(x, y, x + self.square_width() - 1, y)
painter.setPen(color.darker())
painter.drawLine(x + 1, y + self.square_height() - 1,
x + self.square_width() - 1,
y + self.square_height() - 1)
painter.drawLine(x + self.square_width() - 1,
y + self.square_height() - 1,
x + self.square_width() - 1, y + 1)
if storey_state != StoreyState.EMPTY:
if not self.current_state.is_open:
painter.setBrush(QBrush(Qt.DiagCrossPattern))
painter.drawRect(x + 1, y + 1,
self.square_width() - 2,
self.square_height() - 2)
if self.current_state.weight > 0:
painter.setPen(Qt.red)
painter.drawText(
QRect(x + 1, y + 1,
self.square_width() - 2,
self.square_height() - 2), Qt.AlignCenter,
str(self.current_state.weight))
def draw_square(self, left, top, sq_type):
""" отрисовка квадратика """
w = left * self.scale_width()
h = top * self.scale_height()
painter = QPainter(self)
if sq_type == config.FIELD_TYPE_NONE:
painter.fillRect(w, h, self.scale_width(), self.scale_height(), QColor(config.Colors[sq_type]))
return
elif sq_type == config.FIELD_TYPE_BODY:
color = QColor(self.body_gradient[self.engine.body_index(top, left)].get_hex())
else:
color = QColor(config.Colors[sq_type])
painter.fillRect(w + 1, h + 1, self.scale_width() - 2, self.scale_height() - 2, color)
painter.setPen(color.lighter())
painter.drawLine(w, h + self.scale_height() - 1, w, h)
painter.drawLine(w, h, w + self.scale_width() - 1, h)
painter.setPen(color.darker(150))
painter.drawLine(w + 1, h + self.scale_height() - 1, w + self.scale_width() - 1, h + self.scale_height() - 1)
painter.drawLine(w + self.scale_width() - 1, h + self.scale_height() - 1, w + self.scale_width() - 1, h + 1)
def draw(self, painter, x, y, shape):
painter.drawRect(self.game_top_left[0], self.game_top_left[1],
self.game_width, self.game_height)
painter.drawRect(self.score_top_left[0], self.score_top_left[1],
self.score_width, self.score_height)
painter.drawRect(self.predict_top_left[0], self.predict_top_left[1],
self.predict_width, self.predict_height)
# for i in range(self.square_height_num):
# for j in range(self.square_width_num):
# painter.drawRect(self.game_top_left[0] + j * self.square_width, self.game_top_left[1] + i * self.square_height,self.square_width,self.square_height)
# 加个网格看得清
colorTable = [
0x000000, 0xCC6666, 0x66CC66, 0x6666CC, 0xCCCC66, 0xCC66CC,
0x66CCCC, 0xDAAA00
]
color = QColor(colorTable[shape])
painter.fillRect(x + 1, y + 1, self.square_width - 2,
self.square_height - 2, color)
painter.setPen(color.lighter())
painter.drawLine(x, y + self.square_height - 1, x, y)
painter.drawLine(x, y, x + self.square_width - 1, y)
painter.setPen(color.darker())
painter.drawLine(x + 1, y + self.square_height - 1,
x + self.square_width - 1, y + self.square_height - 1)
painter.drawLine(x + self.square_width - 1, y + self.square_height - 1,
x + self.square_width - 1, y + 1)
def drawSquare(self, painter, x, y, shape):
"""绘制方块图形"""
colorTable = [
0x000000, 0xCC6666, 0x66CC66, 0x6666CC, 0xCCCC66, 0xCC66CC,
0x66CCCC, 0xDAAA00
]
color = QColor(colorTable[shape])
painter.fillRect(x + 1, y + 1,
self.squareWidth() - 2,
self.squareHeight() - 2, color)
painter.setPen(color.lighter())
painter.drawLine(x, y + self.squareHeight() - 1, x, y)
painter.drawLine(x, y, x + self.squareWidth() - 1, y)
painter.setPen(color.darker())
painter.drawLine(x + 1, y + self.squareHeight() - 1,
x + self.squareWidth() - 1,
y + self.squareHeight() - 1)
painter.drawLine(x + self.squareWidth() - 1,
y + self.squareHeight() - 1,
x + self.squareWidth() - 1, y + 1)
def labelPoints(self, img: Optional[QPixmap], toSrc: bool):
if not img or not self.points:
return None
painter = QPainter()
painter.begin(img)
painter.setRenderHint(QPainter.Antialiasing, True)
pen = QPen()
pen.setCapStyle(Qt.RoundCap)
font = QFont('Consolas')
if toSrc:
pen.setWidthF(config.pointWidth * self.ratioToSrc)
font.setPointSizeF(config.fontSize * self.ratioToSrc)
else:
pen.setWidthF(config.pointWidth)
font.setPointSizeF(config.fontSize)
painter.setFont(font)
for index, (point, color) in self.points.items():
labelPoint: QPointF
if toSrc:
pen.setColor(color)
labelPoint = self.getSrcPoint(point)
else:
pen.setColor(
color if index != self.highlightMoveIndex and index not in self.highlightPoints
else QColor.lighter(color)
)
labelPoint = point
painter.setPen(pen)
painter.drawPoint(labelPoint)
painter.drawText(static.getIndexShift(labelPoint), str(index))
painter.end()
def drawSquare(self, painter, x, y, shape):
colorTable = [
0x000000, 0xCC6666, 0x66CC66, 0x6666CC, 0xCCCC66, 0xCC66CC,
0x66CCCC, 0xDAAA00
]
color = QColor(colorTable[shape])
painter.fillRect(x + 1, y + 1,
self.squareWidth() - 2,
self.squareHeight() - 2, color)
painter.setPen(color.lighter())
painter.drawLine(x, y + self.squareHeight() - 1, x, y)
painter.drawLine(x, y, x + self.squareWidth() - 1, y)
painter.drawLine(x + 1, y + self.squareHeight() - 1,
x + self.squareWidth() - 1,
y + self.squareHeight() - 1)
painter.drawLine(x + self.squareWidth() - 1,
y + self.squareHeight() - 1,
x + self.squareWidth() - 1, y + 1)
pen = QPen(Qt.black, 5, Qt.SolidLine)
painter.setPen(pen)
painter.drawLine(0, 0, 0, 720)
painter.drawLine(0, 720, 720, 720)
painter.drawLine(720, 720, 720, 0)
painter.drawLine(720, 0, 0, 0)
def paint(self, painter, option, index):
hasValue = True
if (self.m_editorPrivate):
property = self.m_editorPrivate.indexToProperty(index)
if (property):
hasValue = property.hasValue()
opt = QStyleOptionViewItem(option)
if ((self.m_editorPrivate and index.column() == 0) or not hasValue):
property = self.m_editorPrivate.indexToProperty(index)
if (property and property.isModified()):
opt.font.setBold(True)
opt.fontMetrics = QFontMetrics(opt.font)
c = QColor()
if (not hasValue
and self.m_editorPrivate.markPropertiesWithoutValue()):
c = opt.palette.color(QPalette.Dark)
opt.palette.setColor(QPalette.Text,
opt.palette.color(QPalette.BrightText))
else:
c = self.m_editorPrivate.calculatedBackgroundColor(
self.m_editorPrivate.indexToBrowserItem(index))
if (c.isValid()
and (opt.features & QStyleOptionViewItem.Alternate)):
c = c.lighter(112)
if (c.isValid()):
painter.fillRect(option.rect, c)
opt.state &= ~QStyle.State_HasFocus
if (index.column() == 1):
item = self.m_editorPrivate.indexToItem(index)
if (self.m_editedItem and (self.m_editedItem == item)):
self.m_disablePainting = True
super(QtPropertyEditorDelegate, self).paint(painter, opt, index)
if (option.type):
self.m_disablePainting = False
opt.palette.setCurrentColorGroup(QPalette.Active)
color = QApplication.style().styleHint(QStyle.SH_Table_GridLineColor,
opt)
painter.save()
painter.setPen(QPen(color))
if (not self.m_editorPrivate
or (not self.m_editorPrivate.lastColumn(index.column())
and hasValue)):
if option.direction == Qt.LeftToRight:
right = option.rect.right()
else:
right = option.rect.left()
painter.drawLine(right, option.rect.y(), right,
option.rect.bottom())
painter.restore()
def draw_square(painter, x, y, val, s):
if val != 0:
color = QColor(Drawing.color_table[val])
painter.fillRect(x+1, y+1, s-2, s-2, color)
painter.setPen(color.lighter())
painter.drawLine(x, y + s - 1, x, y)
painter.drawLine(x, y, x + s - 1, y)
painter.setPen(color.darker())
painter.drawLine(x + 1, y + s - 1, x + s - 1, y + s - 1)
painter.drawLine(x + s - 1, y + s - 1, x + s - 1, y + 1)
def drawRect(self, qp):
# 创建红色，宽度为4像素的画笔
pen = QPen()
pen.setWidth(4)
pen.setColor(Qt.red)
pen.setStyle(Qt.SolidLine)
pen.setCapStyle(Qt.FlatCap)
pen.setJoinStyle(Qt.BevelJoin)
qp.setPen(pen)
qp.setRenderHint(QPainter.Antialiasing)
qp.setRenderHint(QPainter.TextAntialiasing)
brush = QBrush()
qc = QColor()
qc.lighter()
brush.setColor(qc.lighter(1))
brush.setStyle(Qt.SolidPattern)
qp.setBrush(brush)
qp.drawRect(*self.rect)
def drawLine(self, painter, x, y):
w = self.size
h = self.size
x = x * self.size + self.offset
y = y * self.size + self.offset
color = QColor(self.color)
painter.setPen(color.lighter())
painter.drawLine(x, y + h, x, y)
painter.drawLine(x, y, x + w, y)
painter.drawLine(x, y + h, x + w, y + h)
painter.drawLine(x + w, y + h, x + w, y)
def drawPawn(self, painter, x, y, colorIndex, isKing=False):
colorTable = [0xC1442E, 0xF6CD37]
color = QColor(colorTable[colorIndex])
painter.setBrush(color)
painter.drawEllipse(x, y, self.squareWidth(), self.squareHeight())
painter.setBrush(Qt.green)
if isKing == True:
painter.setPen(color.lighter())
painter.drawEllipse(x, y,
self.squareWidth() / 2,
self.squareHeight() / 2)
def drawCell(painter, x, y, shape, grid_size): colors = [0x000000, 0xCC6666, 0x66CC66, 0x6666CC, 0xCCCC66, 0xCC66CC, 0x66CCCC, 0xDAAA00] if shape == 0: return color = QColor(colors[shape]) painter.fillRect(x+1, y+1, grid_size-2, grid_size-2, color) painter.setPen(color.lighter()) painter.drawLine(x, y+grid_size-1, x, y) painter.drawLine(x, y, x+grid_size-1, y) painter.setPen(color.darker()) painter.drawLine(x+1, y+grid_size-1, x+grid_size-1, y+grid_size-1) painter.drawLine(x+grid_size-1, y+grid_size-1, x+grid_size-1, y+1)
def draw_cube(self, qp, x, y, color):
color = QColor(color)
width = self.board_cube_width()
height = self.board_cube_height()
x *= width
y *= height
qp.fillRect(x + 1, y + 1, width - 2, height - 2, color)
qp.setPen(color.lighter())
qp.setPen(color.darker())
def draw_item(self, qp, x, y, m, n):
# x 10, y 10, z 25, w: 25
color = QColor(0xCCCC66)
qp.fillRect(x + 1, y + 1, m - 2, n - 2, color)
qp.setPen(color.lighter())
qp.drawLine(x, y + n - 1, x, y)
qp.drawLine(x, y, x + m - 1, y)
qp.setPen(color.darker())
qp.drawLine(x + 1, y + n - 1, x + m - 1, y + n - 1)
qp.drawLine(x + n - 1, y + n - 1, x + m - 1, y + 1)
def drawLine(self, painter):
if self.border == None:
return
w = self.size * 4
h = self.size * 4
x = self.offsetX + self.size * self.pointX
y = self.offsetY + self.size * self.pointY
color = QColor(self.border)
painter.setPen(color.lighter())
painter.drawLine(x, y, x + w, y)
painter.drawLine(x, y + h, x, y)
painter.drawLine(x, y + h, x + w, y + h)
painter.drawLine(x + w, y + h, x + w, y)
def getColorObj(hex_string, alpha=None, lighter=None):
"""Checks internal cache for specified color. If not in the cache, add it.
Args:
hex_string (str): hexadecimal color code in the form: #RRGGBB
alpha (int): 0–255
lighter (int): see `QColor.lighter <http://doc.qt.io/qt-5/qcolor.html#lighter>`_.
Returns:
color (QColor)
"""
global color_cache
if alpha is not None:
hex_string = '#%0.2x%s' % (alpha, hex_string[1:])
key = (hex_string, lighter)
color = color_cache.get(key)
if color is None:
color = QColor(hex_string)
if lighter is not None:
color.lighter(lighter)
color_cache[key] = color
return color
def getColorObj(hex_string, alpha=None, lighter=None):
"""Checks internal cache for specified color. If not in the cache, add it.
Args:
hex_string (str): hexadecimal color code in the form: #RRGGBB
alpha (int): 0–255
lighter (int): see `QColor.lighter <http://doc.qt.io/qt-5/qcolor.html#lighter>`_.
Returns:
color (QColor)
"""
global color_cache
if alpha is not None:
hex_string = '#%0.2x%s' % (alpha, hex_string[1:])
key = (hex_string, lighter)
color = color_cache.get(key)
if color is None:
color = QColor(hex_string)
if lighter is not None:
color.lighter(lighter)
color_cache[key] = color
return color
def draw_square(self, x, y, size, color):
width, height = size
color = QColor(color)
painter = self.painter
painter.fillRect(x + 1, y + 1, width - 2, height - 2, color)
painter.setPen(color.lighter())
painter.drawLine(x, y + height - 1, x, y)
painter.drawLine(x, y, x + width - 1, y)
painter.setPen(color.darker())
painter.drawLine(x + 1, y + height - 1, x + width - 1, y + height - 1)
painter.drawLine(x + width - 1, y + height - 1, x + width - 1, y + 1)
def brush(self, option: QStyleOptionToolButton):
over = option.state & QStyle.State_MouseOver
pressed = option.state & QStyle.State_Sunken
g1 = QColor(219, 217, 215)
g2 = QColor(205, 202, 199)
g3 = QColor(187, 183, 180)
if pressed:
g1 = g1.darker(120)
g2 = g2.darker(120)
g3 = g3.darker(120)
elif over:
g1 = g1.lighter(110)
g2 = g2.lighter(110)
g3 = g3.lighter(110)
gradient = QLinearGradient(0, 0, 0, self.height())
gradient.setColorAt(0.0, g1)
gradient.setColorAt(0.40, g2)
gradient.setColorAt(1.0, g3)
return QBrush(gradient)
def draw_square(painter, x, y, size, color):
"""draws a square of a shape"""
color = QColor(color)
painter.fillRect(x + 1, y + 1, size[1] - 2,
size[0] - 2, color)
painter.setPen(color.lighter())
painter.drawLine(x, y + size[0] - 1, x, y)
painter.drawLine(x, y, x + size[1] - 1, y)
painter.setPen(color.darker())
painter.drawLine(x + 1, y + size[0] - 1,
x + size[1] - 1, y + size[0] - 1)
painter.drawLine(x + size[1] - 1,
y + size[0] - 1, x + size[1] - 1, y + 1)
def drawBlock(self, painter, x, y, c):
w = self.size
h = self.size
x = self.size * x + self.offset
y = self.size * y + self.offset
color = QColor(c)
painter.fillRect(x + 1, y + 1, w - 2, h - 2, color)
painter.setPen(color.lighter())
painter.drawLine(x, y + h - 1, x, y)
painter.drawLine(x, y, x + w - 1, y)
painter.setPen(color.darker())
painter.drawLine(x + 1, y + h - 1, x + w - 1, y + h - 1)
painter.drawLine(x + w - 1, y + h - 1, x + w - 1, y + 1)
def format(color, style='', darker=100, lighter=100):
"""Return a QTextCharFormat with the given attributes.
"""
_color = QColor(color)
_color = _color.darker(darker)
_color = _color.lighter(lighter)
_format = QTextCharFormat()
_format.setForeground(_color)
if 'bold' in style:
_format.setFontWeight(QFont.Bold)
if 'italic' in style:
_format.setFontItalic(True)
return _format
def paint(self, painter, option, index):
hasValue = True
if (self.m_editorPrivate):
property = self.m_editorPrivate.indexToProperty(index)
if (property):
hasValue = property.hasValue()
opt = QStyleOptionViewItem(option)
if ((self.m_editorPrivate and index.column() == 0) or not hasValue):
property = self.m_editorPrivate.indexToProperty(index)
if (property and property.isModified()):
opt.font.setBold(True)
opt.fontMetrics = QFontMetrics(opt.font)
c = QColor()
if (not hasValue and self.m_editorPrivate.markPropertiesWithoutValue()):
c = opt.palette.color(QPalette.Dark)
opt.palette.setColor(QPalette.Text, opt.palette.color(QPalette.BrightText))
else:
c = self.m_editorPrivate.calculatedBackgroundColor(self.m_editorPrivate.indexToBrowserItem(index))
if (c.isValid() and (opt.features & QStyleOptionViewItem.Alternate)):
c = c.lighter(112)
if (c.isValid()):
painter.fillRect(option.rect, c)
opt.state &= ~QStyle.State_HasFocus
if (index.column() == 1):
item = self.m_editorPrivate.indexToItem(index)
if (self.m_editedItem and (self.m_editedItem == item)):
self.m_disablePainting = True
super(QtPropertyEditorDelegate, self).paint(painter, opt, index)
if (option.type):
self.m_disablePainting = False
opt.palette.setCurrentColorGroup(QPalette.Active)
color = QApplication.style().styleHint(QStyle.SH_Table_GridLineColor, opt)
painter.save()
painter.setPen(QPen(color))
if (not self.m_editorPrivate or (not self.m_editorPrivate.lastColumn(index.column()) and hasValue)):
if option.direction == Qt.LeftToRight:
right = option.rect.right()
else:
right = option.rect.left()
painter.drawLine(right, option.rect.y(), right, option.rect.bottom())
painter.restore()
def painter_square(self, qp, x, y, width, height, shape_type):
# 根据长宽和起始地点画框
x *= self.every_square_per_width()
y *= self.every_square_per_height()
width *= self.every_square_per_width()
height *= self.every_square_per_height()
color = QColor(ShapeType.Shape_Colors[shape_type])
qp.fillRect(x + 1, y + 1, width - 1, height - 2, color)
qp.setPen(color.lighter())
qp.drawLine(x, y, x + width - 1, y)
qp.drawLine(x, y, x, y + height - 1)
qp.setPen(color.darker())
qp.drawLine(x + width - 1, y + 1, x + width - 1, y + height - 1)
qp.drawLine(x + 1, y + height - 1, x + width - 1, y + height - 1)
def drawSquare(painter, x, y, val, s):
colorTable = [0x000000, 0xCC6666, 0x66CC66, 0x6666CC,
0xCCCC66, 0xCC66CC, 0x66CCCC, 0xDAAA00, 0xFFFFFF]
if val == 0:
return
color = QColor(colorTable[val])
painter.fillRect(x + 1, y + 1, s - 2, s - 2, color)
painter.setPen(color.lighter())
painter.drawLine(x, y + s - 1, x, y)
painter.drawLine(x, y, x + s - 1, y)
painter.setPen(color.darker())
painter.drawLine(x + 1, y + s - 1, x + s - 1, y + s - 1)
painter.drawLine(x + s - 1, y + s - 1, x + s - 1, y + 1)
class NodeUIScene(QGraphicsScene):
def __init__(self, parent=None):
QGraphicsScene.__init__(self, parent)
self._backgroundColor = QColor(50, 55, 60)
self._gridPen = QPen(self._backgroundColor.lighter(120))
self._gridPen.setWidth(1)
self._zoom = 1.0
self.setItemIndexMethod(
QGraphicsScene.NoIndex) # fixes bug with scene.removeItem()
self.setBackgroundBrush(self._backgroundColor)
self.setStickyFocus(True)
def zoom(self):
return self._zoom
def setZoom(self, zoom):
self._zoom = zoom
def helpEvent(self, event):
QGraphicsScene.helpEvent(self, event)
def mouseReleaseEvent(self, event):
QGraphicsScene.mouseReleaseEvent(self, event)
def drawBackground(self, painter, rect):
if not isinstance(painter, QPainter):
return
QGraphicsScene.drawBackground(self, painter, rect)
painter.setPen(self._gridPen)
grid_size = 50
left = int(rect.left()) - (int(rect.left()) % grid_size)
top = int(rect.top()) - (int(rect.top()) % grid_size)
x = left
while x < rect.right():
painter.drawLine(x, rect.top(), x, rect.bottom())
x += grid_size
y = top
while y < rect.bottom():
painter.drawLine(rect.left(), y, rect.right(), y)
y += grid_size
def _refresh_colors(self):
"""
Refresh elements in the node
"""
# color around ellipse
outline_color = QColor('grey')
outline_style = Qt.SolidLine
outline_width = 1
if self.status_wallet:
outline_width = 2
if not self.status_member:
outline_color = QColor('red')
if self.status_sentry:
outline_color = QColor('black')
outline_width = 3
self.setPen(QPen(outline_color, outline_width, outline_style))
if self.highlighted:
text_color = QColor('grey')
else:
text_color = QColor('black')
if self.status_wallet == NodeStatus.HIGHLIGHTED:
text_color = QColor('grey')
if self.text_item:
self.text_item.setBrush(QBrush(text_color))
# create gradient inside the ellipse
gradient = QRadialGradient(
QPointF(0,
self.boundingRect().height() / 4),
self.boundingRect().width())
color = QColor()
color.setHsv(120 - 60 / self.steps_max * self.steps,
180 + 50 / self.steps_max * self.steps,
60 + 170 / self.steps_max * self.steps)
if self.highlighted:
color = color.darker(200)
color = color.lighter(
math.fabs(math.sin(self.loading_counter / 100 * math.pi) * 100) +
100)
gradient.setColorAt(0, color)
gradient.setColorAt(1, color.darker(150))
self.setBrush(QBrush(gradient))
def drawSquare(painter, x, y, val, s):
colorTable = [0x000000, 0xCC6666, 0x66CC66, 0x6666CC,
0xCCCC66, 0xCC66CC, 0x66CCCC, 0xDAAA00]
if val == 0:
return
color = QColor(colorTable[val])
painter.fillRect(x + 1, y + 1, s - 2, s - 2, color)
painter.setPen(color.lighter())
painter.drawLine(x, y + s - 1, x, y)
painter.drawLine(x, y, x + s - 1, y)
painter.setPen(color.darker())
painter.drawLine(x + 1, y + s - 1, x + s - 1, y + s - 1)
painter.drawLine(x + s - 1, y + s - 1, x + s - 1, y + 1)
def drawSquare(self, painter, x, y, shape):
colorTable = [0x000000, 0xCC6666, 0x66CC66, 0x6666CC,
0xCCCC66, 0xCC66CC, 0x66CCCC, 0xDAAA00]
color = QColor(colorTable[shape])
painter.fillRect(x + 1, y + 1, self.squareWidth() - 2,
self.squareHeight() - 2, color)
painter.setPen(color.lighter())
painter.drawLine(x, y + self.squareHeight() - 1, x, y)
painter.drawLine(x, y, x + self.squareWidth() - 1, y)
painter.setPen(color.darker())
painter.drawLine(x + 1, y + self.squareHeight() - 1,
x + self.squareWidth() - 1, y + self.squareHeight() - 1)
painter.drawLine(x + self.squareWidth() - 1,
y + self.squareHeight() - 1, x + self.squareWidth() - 1, y + 1)
def updateColor(self, item):
pixmap = QPixmap(16, 16)
color = QColor()
if item:
color = item.backgroundColor()
if not color.isValid():
color = self.palette().base().color()
painter = QPainter(pixmap)
painter.fillRect(0, 0, 16, 16, color)
lighter = color.lighter()
painter.setPen(lighter)
# light frame
painter.drawPolyline(QPoint(0, 15), QPoint(0, 0), QPoint(15, 0))
painter.setPen(color.darker())
# dark frame
painter.drawPolyline(QPoint(1, 15), QPoint(15, 15), QPoint(15, 1))
painter.end()
self.colorAction.setIcon(QIcon(pixmap))
def make_labels(self, target):
""" Create labels for the web nodes in 'source'; if not defined,
find all visible anchor nodes first
TODO pass a color? for 'title' tags
NAV11 DOM01
"""
if target == "links":
source = self.__find_visible(navigables=True)
self.attr.clear('find_titles')
elif target == "titles":
source = self.__find_visible(navigables=False)
self.attr.insert('find_titles')
self.map_tags = dict(zip(ALL_TAGS, source))
for tag, node in self.map_tags.items():
label = QLabel(tag, parent=self)
self.__labels.append(label)
palette = QToolTip.palette()
color = QColor(Qt.yellow)
color = color.lighter(160)
color.setAlpha(196)
palette.setColor(QPalette.Window, color)
label.setPalette(palette)
label.setAutoFillBackground(True)
label.setFrameStyle(QFrame.Box | QFrame.Plain)
point = QPoint(
node.geometry().left(),
node.geometry().center().y())
point -= self.page().mainFrame().scrollPosition()
label.move(point)
label.show()
label.move(label.x(), label.y() + label.height() // 4)
def __init__(self, parent=None):
super(NotifyLabel, self).__init__(parent)
print("NOTIFYLABEL", self, parent)
palette = QToolTip.palette()
color = QColor(Qt.blue)
color = color.lighter(170)
color.setAlpha(128)
palette.setColor(QPalette.Window, color)
self.setPalette(palette)
self.setAutoFillBackground(True)
self.setFrameStyle(QFrame.Box | QFrame.Plain)
self.setFont(QFont(None, 20, QFont.Bold))
self.hide()
self.content = deque(maxlen=4)
def _refresh_colors(self):
"""
Refresh elements in the node
"""
# color around ellipse
outline_color = QColor('black')
outline_style = Qt.SolidLine
outline_width = 1
if self.status_wallet:
outline_color = QColor('grey')
outline_width = 2
if not self.status_member:
outline_color = QColor('red')
outline_style = Qt.SolidLine
self.setPen(QPen(outline_color, outline_width, outline_style))
if self.highlighted:
text_color = QColor('grey')
else:
text_color = QColor('black')
if self.status_wallet == NodeStatus.HIGHLIGHTED:
text_color = QColor('grey')
self.text_item.setBrush(QBrush(text_color))
# create gradient inside the ellipse
gradient = QRadialGradient(QPointF(0, self.boundingRect().height() / 4), self.boundingRect().width())
color = QColor()
color.setHsv(120 - 60 / self.steps_max * self.steps,
180 + 50 / self.steps_max * self.steps,
60 + 170 / self.steps_max * self.steps)
if self.highlighted:
color = color.darker(200)
color = color.lighter(math.fabs(math.sin(self.loading_counter / 100 * math.pi) * 100) + 100)
gradient.setColorAt(0, color)
gradient.setColorAt(1, color.darker(150))
self.setBrush(QBrush(gradient))
def mouseMoveEvent(self, event):
"""When normal selection, update power spectrum with current selection.
Otherwise, show the range of the new marker.
"""
if not self.scene:
return
if self.idx_sel in self.scene.items():
self.scene.removeItem(self.idx_sel)
self.idx_sel = None
chk_marker = self.parent.notes.action['new_bookmark'].isChecked()
chk_event = self.parent.notes.action['new_event'].isChecked()
if chk_marker or chk_event:
xy_scene = self.mapToScene(event.pos())
y_distance = self.parent.value('y_distance')
pos = QRectF(self.sel_xy[0],
0,
xy_scene.x() - self.sel_xy[0],
len(self.idx_label) * y_distance)
item = QGraphicsRectItem(pos.normalized())
item.setPen(NoPen)
if chk_marker:
color = QColor(self.parent.value('annot_bookmark_color'))
elif chk_event:
eventtype = self.parent.notes.idx_eventtype.currentText()
color = convert_name_to_color(eventtype)
item.setBrush(QBrush(color.lighter(115)))
item.setZValue(-10)
self.scene.addItem(item)
self.idx_sel = item
return
xy_scene = self.mapToScene(event.pos())
pos = QRectF(self.sel_xy[0], self.sel_xy[1],
xy_scene.x() - self.sel_xy[0],
xy_scene.y() - self.sel_xy[1])
self.idx_sel = QGraphicsRectItem(pos.normalized())
self.idx_sel.setPen(QPen(QColor(LINE_COLOR), LINE_WIDTH))
self.scene.addItem(self.idx_sel)
if self.idx_info in self.scene.items():
self.scene.removeItem(self.idx_info)
duration = '{0:0.2f}s'.format(abs(xy_scene.x() - self.sel_xy[0]))
# get y-size, based on scaling too
y = abs(xy_scene.y() - self.sel_xy[1])
scale = self.parent.value('y_scale') * self.chan_scale[self.sel_chan]
height = '{0:0.3f}uV'.format(y / scale)
item = TextItem_with_BG()
item.setText(duration + ' ' + height)
item.setPos(self.sel_xy[0], self.sel_xy[1])
self.scene.addItem(item)
self.idx_info = item
trial = 0
time = self.parent.traces.data.axis['time'][trial]
beg_win = min((self.sel_xy[0], xy_scene.x()))
end_win = max((self.sel_xy[0], xy_scene.x()))
time_of_interest = time[(time >= beg_win) & (time < end_win)]
if len(time_of_interest) > MINIMUM_N_SAMPLES:
data = self.parent.traces.data(trial=trial,
chan=self.chan[self.sel_chan],
time=time_of_interest)
n_data = len(data)
n_pad = (power(2, ceil(log2(n_data))) - n_data) / 2
data = pad(data, (int(ceil(n_pad)), int(floor(n_pad))), 'constant')
self.parent.spectrum.display(data)
class PixmapDial(QDial):
# enum CustomPaintMode
CUSTOM_PAINT_MODE_NULL = 0 # default (NOTE: only this mode has label gradient)
CUSTOM_PAINT_MODE_CARLA_WET = 1 # color blue-green gradient (reserved #3)
CUSTOM_PAINT_MODE_CARLA_VOL = 2 # color blue (reserved #3)
CUSTOM_PAINT_MODE_CARLA_L = 3 # color yellow (reserved #4)
CUSTOM_PAINT_MODE_CARLA_R = 4 # color yellow (reserved #4)
CUSTOM_PAINT_MODE_CARLA_PAN = 5 # color yellow (reserved #3)
CUSTOM_PAINT_MODE_COLOR = 6 # color, selectable (reserved #3)
CUSTOM_PAINT_MODE_ZITA = 7 # custom zita knob (reserved #6)
CUSTOM_PAINT_MODE_NO_GRADIENT = 8 # skip label gradient
# enum Orientation
HORIZONTAL = 0
VERTICAL = 1
HOVER_MIN = 0
HOVER_MAX = 9
MODE_DEFAULT = 0
MODE_LINEAR = 1
# signals
realValueChanged = pyqtSignal(float)
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)
def getIndex(self):
return self.fIndex
def getBaseSize(self):
return self.fPixmapBaseSize
def forceWhiteLabelGradientText(self):
self.fLabelGradientColor1 = QColor(0, 0, 0, 255)
self.fLabelGradientColor2 = QColor(0, 0, 0, 0)
self.fLabelGradientColorT = [Qt.white, Qt.darkGray]
def setLabelColor(self, enabled, disabled):
self.fLabelGradientColor1 = QColor(0, 0, 0, 255)
self.fLabelGradientColor2 = QColor(0, 0, 0, 0)
self.fLabelGradientColorT = [enabled, disabled]
def updateSizes(self):
self.fPixmapWidth = self.fPixmap.width()
self.fPixmapHeight = self.fPixmap.height()
if self.fPixmapWidth < 1:
self.fPixmapWidth = 1
if self.fPixmapHeight < 1:
self.fPixmapHeight = 1
if self.fPixmapOrientation == self.HORIZONTAL:
self.fPixmapBaseSize = self.fPixmapHeight
self.fPixmapLayersCount = self.fPixmapWidth / self.fPixmapHeight
else:
self.fPixmapBaseSize = self.fPixmapWidth
self.fPixmapLayersCount = self.fPixmapHeight / self.fPixmapWidth
self.setMinimumSize(self.fPixmapBaseSize, self.fPixmapBaseSize + self.fLabelHeight + 5)
self.setMaximumSize(self.fPixmapBaseSize, self.fPixmapBaseSize + self.fLabelHeight + 5)
if not self.fLabel:
self.fLabelHeight = 0
self.fLabelWidth = 0
return
self.fLabelWidth = QFontMetrics(self.fLabelFont).width(self.fLabel)
self.fLabelHeight = QFontMetrics(self.fLabelFont).height()
self.fLabelPos.setX(float(self.fPixmapBaseSize)/2.0 - float(self.fLabelWidth)/2.0)
if self.fPixmapNum in ("01", "02", "07", "08", "09", "10"):
self.fLabelPos.setY(self.fPixmapBaseSize + self.fLabelHeight)
elif self.fPixmapNum in ("11",):
self.fLabelPos.setY(self.fPixmapBaseSize + self.fLabelHeight*2/3)
else:
self.fLabelPos.setY(self.fPixmapBaseSize + self.fLabelHeight/2)
self.fLabelGradient.setStart(0, float(self.fPixmapBaseSize)/2.0)
self.fLabelGradient.setFinalStop(0, self.fPixmapBaseSize + self.fLabelHeight + 5)
self.fLabelGradientRect = QRectF(float(self.fPixmapBaseSize)/8.0, float(self.fPixmapBaseSize)/2.0, float(self.fPixmapBaseSize*3)/4.0, self.fPixmapBaseSize+self.fLabelHeight+5)
def setCustomPaintMode(self, paintMode):
if self.fCustomPaintMode == paintMode:
return
self.fCustomPaintMode = paintMode
self.update()
def setCustomPaintColor(self, color):
if self.fCustomPaintColor == color:
return
self.fCustomPaintColor = color
self.update()
def setLabel(self, label):
if self.fLabel == label:
return
self.fLabel = label
self.updateSizes()
self.update()
def setIndex(self, index):
self.fIndex = index
def setPixmap(self, pixmapId):
self.fPixmapNum = "%02i" % pixmapId
self.fPixmap.load(":/bitmaps/dial_%s%s.png" % (self.fPixmapNum, "" if self.isEnabled() else "d"))
if self.fPixmap.width() > self.fPixmap.height():
self.fPixmapOrientation = self.HORIZONTAL
else:
self.fPixmapOrientation = self.VERTICAL
# special pixmaps
if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_NULL:
# reserved for carla-wet, carla-vol, carla-pan and color
if self.fPixmapNum == "03":
self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_COLOR
# reserved for carla-L and carla-R
elif self.fPixmapNum == "04":
self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_CARLA_L
# reserved for zita
elif self.fPixmapNum == "06":
self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_ZITA
self.updateSizes()
self.update()
def setPrecision(self, value, isInteger):
self.fPrecision = value
self.fIsInteger = isInteger
QDial.setMaximum(self, value)
def setMinimum(self, value):
self.fMinimum = value
def setMaximum(self, value):
self.fMaximum = value
def setValue(self, value, emitSignal=False):
if self.fRealValue == value:
return
if value <= self.fMinimum:
qtValue = 0
self.fRealValue = self.fMinimum
elif value >= self.fMaximum:
qtValue = self.fPrecision
self.fRealValue = self.fMaximum
else:
qtValue = round(float(value - self.fMinimum) / float(self.fMaximum - self.fMinimum) * self.fPrecision)
self.fRealValue = value
# Block change signal, we'll handle it ourselves
self.blockSignals(True)
QDial.setValue(self, qtValue)
self.blockSignals(False)
if emitSignal:
self.realValueChanged.emit(self.fRealValue)
@pyqtSlot(int)
def slot_valueChanged(self, value):
self.fRealValue = float(value)/self.fPrecision * (self.fMaximum - self.fMinimum) + self.fMinimum
self.realValueChanged.emit(self.fRealValue)
@pyqtSlot()
def slot_updatePixmap(self):
self.setPixmap(int(self.fPixmapNum))
def minimumSizeHint(self):
return QSize(self.fPixmapBaseSize, self.fPixmapBaseSize)
def sizeHint(self):
return QSize(self.fPixmapBaseSize, self.fPixmapBaseSize)
def changeEvent(self, event):
QDial.changeEvent(self, event)
# Force pixmap update if enabled state changes
if event.type() == QEvent.EnabledChange:
self.setPixmap(int(self.fPixmapNum))
def enterEvent(self, event):
self.fIsHovered = True
if self.fHoverStep == self.HOVER_MIN:
self.fHoverStep = self.HOVER_MIN + 1
QDial.enterEvent(self, event)
def leaveEvent(self, event):
self.fIsHovered = False
if self.fHoverStep == self.HOVER_MAX:
self.fHoverStep = self.HOVER_MAX - 1
QDial.leaveEvent(self, event)
def mousePressEvent(self, event):
if self.fDialMode == self.MODE_DEFAULT:
return QDial.mousePressEvent(self, event)
if event.button() == Qt.LeftButton:
self.fIsPressed = True
self.fLastDragPos = event.pos()
self.fLastDragValue = self.fRealValue
def mouseMoveEvent(self, event):
if self.fDialMode == self.MODE_DEFAULT:
return QDial.mouseMoveEvent(self, event)
if not self.fIsPressed:
return
range = (self.fMaximum - self.fMinimum) / 4.0
pos = event.pos()
dx = range * float(pos.x() - self.fLastDragPos.x()) / self.width()
dy = range * float(pos.y() - self.fLastDragPos.y()) / self.height()
value = self.fLastDragValue + dx - dy
if value < self.fMinimum:
value = self.fMinimum
elif value > self.fMaximum:
value = self.fMaximum
elif self.fIsInteger:
value = float(round(value))
self.setValue(value, True)
def mouseReleaseEvent(self, event):
if self.fDialMode == self.MODE_DEFAULT:
return QDial.mouseReleaseEvent(self, event)
if self.fIsPressed:
self.fIsPressed = False
def paintEvent(self, event):
painter = QPainter(self)
event.accept()
painter.save()
painter.setRenderHint(QPainter.Antialiasing, True)
if self.fLabel:
if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_NULL:
painter.setPen(self.fLabelGradientColor2)
painter.setBrush(self.fLabelGradient)
painter.drawRect(self.fLabelGradientRect)
painter.setFont(self.fLabelFont)
painter.setPen(self.fLabelGradientColorT[0 if self.isEnabled() else 1])
painter.drawText(self.fLabelPos, self.fLabel)
if self.isEnabled():
normValue = float(self.fRealValue - self.fMinimum) / float(self.fMaximum - self.fMinimum)
target = QRectF(0.0, 0.0, self.fPixmapBaseSize, self.fPixmapBaseSize)
curLayer = int((self.fPixmapLayersCount - 1) * normValue)
if self.fPixmapOrientation == self.HORIZONTAL:
xpos = self.fPixmapBaseSize * curLayer
ypos = 0.0
else:
xpos = 0.0
ypos = self.fPixmapBaseSize * curLayer
source = QRectF(xpos, ypos, self.fPixmapBaseSize, self.fPixmapBaseSize)
painter.drawPixmap(target, self.fPixmap, source)
# Custom knobs (Dry/Wet and Volume)
if self.fCustomPaintMode in (self.CUSTOM_PAINT_MODE_CARLA_WET, self.CUSTOM_PAINT_MODE_CARLA_VOL):
# knob color
colorGreen = QColor(0x5D, 0xE7, 0x3D).lighter(100 + self.fHoverStep*6)
colorBlue = QColor(0x3E, 0xB8, 0xBE).lighter(100 + self.fHoverStep*6)
# draw small circle
ballRect = QRectF(8.0, 8.0, 15.0, 15.0)
ballPath = QPainterPath()
ballPath.addEllipse(ballRect)
#painter.drawRect(ballRect)
tmpValue = (0.375 + 0.75*normValue)
ballValue = tmpValue - floor(tmpValue)
ballPoint = ballPath.pointAtPercent(ballValue)
# draw arc
startAngle = 216*16
spanAngle = -252*16*normValue
if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_CARLA_WET:
painter.setBrush(colorBlue)
painter.setPen(QPen(colorBlue, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))
gradient = QConicalGradient(15.5, 15.5, -45)
gradient.setColorAt(0.0, colorBlue)
gradient.setColorAt(0.125, colorBlue)
gradient.setColorAt(0.625, colorGreen)
gradient.setColorAt(0.75, colorGreen)
gradient.setColorAt(0.76, colorGreen)
gradient.setColorAt(1.0, colorGreen)
painter.setBrush(gradient)
painter.setPen(QPen(gradient, 3))
else:
painter.setBrush(colorBlue)
painter.setPen(QPen(colorBlue, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))
painter.setBrush(colorBlue)
painter.setPen(QPen(colorBlue, 3))
painter.drawArc(4.0, 4.0, 26.0, 26.0, startAngle, spanAngle)
# Custom knobs (L and R)
elif self.fCustomPaintMode in (self.CUSTOM_PAINT_MODE_CARLA_L, self.CUSTOM_PAINT_MODE_CARLA_R):
# knob color
color = QColor(0xAD, 0xD5, 0x48).lighter(100 + self.fHoverStep*6)
# draw small circle
ballRect = QRectF(7.0, 8.0, 11.0, 12.0)
ballPath = QPainterPath()
ballPath.addEllipse(ballRect)
#painter.drawRect(ballRect)
tmpValue = (0.375 + 0.75*normValue)
ballValue = tmpValue - floor(tmpValue)
ballPoint = ballPath.pointAtPercent(ballValue)
painter.setBrush(color)
painter.setPen(QPen(color, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.0, 2.0))
# draw arc
if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_CARLA_L:
startAngle = 216*16
spanAngle = -252.0*16*normValue
else:
startAngle = 324.0*16
spanAngle = 252.0*16*(1.0-normValue)
painter.setPen(QPen(color, 2))
painter.drawArc(3.5, 4.5, 22.0, 22.0, startAngle, spanAngle)
# Custom knobs (Color)
elif self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_COLOR:
# knob color
color = self.fCustomPaintColor.lighter(100 + self.fHoverStep*6)
# draw small circle
ballRect = QRectF(8.0, 8.0, 15.0, 15.0)
ballPath = QPainterPath()
ballPath.addEllipse(ballRect)
tmpValue = (0.375 + 0.75*normValue)
ballValue = tmpValue - floor(tmpValue)
ballPoint = ballPath.pointAtPercent(ballValue)
# draw arc
startAngle = 216*16
spanAngle = -252*16*normValue
painter.setBrush(color)
painter.setPen(QPen(color, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))
painter.setBrush(color)
painter.setPen(QPen(color, 3))
painter.drawArc(4.0, 4.0, 26.0, 26.0, startAngle, spanAngle)
# Custom knobs (Zita)
elif self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_ZITA:
a = normValue * pi * 1.5 - 2.35
r = 10.0
x = 10.5
y = 10.5
x += r * sin(a)
y -= r * cos(a)
painter.setBrush(Qt.black)
painter.setPen(QPen(Qt.black, 2))
painter.drawLine(QPointF(11.0, 11.0), QPointF(x, y))
# Custom knobs
else:
painter.restore()
return
if self.HOVER_MIN < self.fHoverStep < self.HOVER_MAX:
self.fHoverStep += 1 if self.fIsHovered else -1
QTimer.singleShot(20, self.update)
else: # isEnabled()
target = QRectF(0.0, 0.0, self.fPixmapBaseSize, self.fPixmapBaseSize)
painter.drawPixmap(target, self.fPixmap, target)
painter.restore()
def resizeEvent(self, event):
QDial.resizeEvent(self, event)
self.updateSizes()
class NGL_SeekBar(NGL_Base):
"""NGL_SeekBar(NGL_Base)
Provides a embedded NGL library widget.
"""
# order for NGL library page struct pointers order
ngl_order = 4
def __init__(self, parent=None):
super(NGL_SeekBar, self).__init__(parent)
self._max = 100
self._min = 0
self._level = 50
self._orientation = Qt.Horizontal
self._show_progress = True
self._slider_size = QSize(8,8)
self._slider_color = QColor(Qt.blue)
self._eventsEnabled = True
self.setGeometry(50, 50, 150, 15)
self.setStyleSheet('color: rgb(64, 128, 64);')
self.update()
def paintEvent(self, event):
p = QPainter()
color = QStyleParser.getColor(self.styleSheet(), 'color: rgb')
rect = self.geometry()
# calc and draw respect orientation
fullscale = self._max - self._min
slider_size = self._slider_size
p.begin(self)
# calc slider respect orientation
if self._orientation == Qt.Horizontal:
posX = self._level * (rect.width() / fullscale)
posY = rect.height() / 2
else:
posX = rect.width() / 2
posY = rect.height() - ((self._level * rect.height()) / fullscale)
# calc coordinates respect orientation
rect_0, rect_1, color_0, color_1 = self._calcCoordinates(posX, posY, slider_size)
# draw seekbar
p.fillRect(rect_0, color_0)
p.setPen(color_0)
p.drawRect(rect_0)
p.fillRect(rect_1, color_1)
p.setPen(color_1)
p.drawRect(rect_1)
# draw slider
for i in range(min(slider_size.width(), slider_size.height())):
p.setPen(self._slider_color.lighter(100 + (i * 10)))
p.drawRect(posX - (slider_size.width() - i) // 2,
posY - (slider_size.height() - i) // 2,
slider_size.width() - i,
slider_size.height() - i)
p.end()
def _calcCoordinates(self, posX, posY, slider_size):
rect = self.geometry()
color = QStyleParser.getColor(self.styleSheet(), 'color: rgb')
color_0 = color.lighter(125)
color_1 = color.lighter(125)
if self._orientation == Qt.Horizontal:
x0 = 0
y0 = (rect.height() // 2) - 2
w0 = (posX - slider_size.width() // 2) - 1
h0 = 4
x1 = (posX + slider_size.width() // 2) + 1
y1 = y0
w1 = rect.width() - x1
h1 = 4
if self._show_progress:
color_0 = color.lighter(175)
else:
x0 = (rect.width() // 2) - 2
y0 = 0
w0 = 4
h0 = (posY - slider_size.height() // 2) - 1
x1 = x0
y1 = (posY + slider_size.height() // 2) + 1
w1 = 4
h1 = rect.height() - y1
if self._show_progress:
color_1 = color.lighter(175)
rect0 = QRect(x0, y0, w0, h0)
rect1 = QRect(x1, y1, w1, h1)
return (rect0, rect1, color_0, color_1)
# Provide getter and setter methods for the property
@pyqtProperty(int)
def level(self):
return self._level
@level.setter
def level(self, level):
self._level = level
self.update()
# Provide getter and setter methods for the property.
@pyqtProperty(int)
def maximum(self):
return self._max
@maximum.setter
def maximum(self, max):
self._max = max
self.update()
# Provide getter and setter methods for the property.
@pyqtProperty(int)
def minimum(self):
return self._min
@minimum.setter
def minimum(self, min):
self._min = min
self.update()
# Provide getter and setter methods for the property.
@pyqtProperty(Qt.Orientation)
def orientation(self):
return self._orientation
@orientation.setter
def orientation(self, _orientation):
self._orientation = _orientation
self.update()
# Provide getter and setter methods for the property.
@pyqtProperty(bool)
def show_progress(self):
return self._show_progress
@show_progress.setter
def show_progress(self, state):
self._show_progress = state
self.update()
# Provide getter and setter methods for the property.
@pyqtProperty(QSize)
def slidersize(self):
return self._slider_size
@slidersize.setter
def slidersize(self, size):
if self.orientation == Qt.Horizontal:
_size = QSize( size.width(), min( self.size().height(), size.height() ) )
else:
_size = QSize( min( self.size().width(), size.width() ), size.height() )
self._slider_size = _size
self.update()
# Provide getter and setter methods for the property.
@pyqtProperty(QColor)
def slidercolor(self):
return self._slider_color
@slidercolor.setter
def slidercolor(self, newcolor):
self._slider_color = newcolor
self.update()
def doNGLCode(self, **kwargs):
import pkg_resources
res_path = pkg_resources.resource_filename('ngl_utils', 'templates/seekbar.ntp')
with open(res_path, 'rt') as f:
template = f.read()
# convert coordinates
g = self._ngl_geometry()
# orientation
ori = {1: 'NGL_Horizontal', 2: 'NGL_Vertical'}
# slider
if self.orientation == Qt.Horizontal:
slider_size = self._slider_size.width()
else:
slider_size = self._slider_size.height()
return template.format(
pageName = self._ngl_parent_obj_name(),
itemName = self.objectName(),
x0 = g.x(),
y0 = g.y(),
x1 = g.x() + g.width() - 1,
y1 = g.y() + g.height() - 1,
slider_size = slider_size,
old_posX = '(uint16_t)(65535)',
old_posY = '(uint16_t)(65535)',
VertHoriz = ori[self.orientation],
Level_MIN = self.minimum,
Level_MAX = self.maximum,
Level = self.level,
ShowProgress = self._show_progress,
Color = self._ngl_color('color: rgb'),
SliderColor = hex(NGL_Colors.fromQColor(self._slider_color)),
p_event = self.clickEventName)
@staticmethod
def ngl_draw(**kwargs):
s = 'NGL_GUI_DrawSeekBar({objects}[{index}]);'
return s.format(
objects = kwargs['name'],
index = kwargs['index'])
def data(self, index, role):
row = index.row()
col = index.column()
if not index.isValid():
return QVariant()
source_data = self.transfers_data[row][col]
txhash_data = self.transfers_data[row][HistoryTableModel.columns_types.index('txhash')]
state_data = self.transfers_data[row][HistoryTableModel.columns_types.index('state')]
block_data = self.transfers_data[row][HistoryTableModel.columns_types.index('block_number')]
if state_data == Transaction.VALIDATED and block_data:
current_confirmations = self.blockchain_processor.current_buid(self.app.currency).number - block_data
else:
current_confirmations = 0
if role == Qt.DisplayRole:
if col == HistoryTableModel.columns_types.index('pubkey'):
return "<p>" + source_data.replace('\n', "<br>") + "</p>"
if col == HistoryTableModel.columns_types.index('date'):
if txhash_data == STOPLINE_HASH:
return ""
else:
ts = self.blockchain_processor.adjusted_ts(self.connection.currency, source_data)
return QLocale.toString(
QLocale(),
QDateTime.fromTime_t(ts).date(),
QLocale.dateFormat(QLocale(), QLocale.ShortFormat)
) + " BAT"
if col == HistoryTableModel.columns_types.index('amount'):
if txhash_data == STOPLINE_HASH:
return ""
else:
amount = self.app.current_ref.instance(source_data, self.connection.currency,
self.app, block_data).diff_localized(False, False)
return amount
return source_data
if role == Qt.FontRole:
font = QFont()
if txhash_data == STOPLINE_HASH:
font.setItalic(True)
else:
if state_data == Transaction.AWAITING or \
(state_data == Transaction.VALIDATED and current_confirmations < MAX_CONFIRMATIONS):
font.setItalic(True)
elif state_data == Transaction.REFUSED:
font.setItalic(True)
elif state_data == Transaction.TO_SEND:
font.setBold(True)
else:
font.setItalic(False)
return font
if role == Qt.ForegroundRole:
color = None
if state_data == Transaction.REFUSED:
color = QColor(Qt.darkGray)
elif state_data == Transaction.TO_SEND:
color = QColor(Qt.blue)
if col == HistoryTableModel.columns_types.index('amount'):
if source_data < 0:
color = QColor(Qt.darkRed)
elif state_data == HistoryTableModel.DIVIDEND:
color = QColor(Qt.darkBlue)
if state_data == Transaction.AWAITING or \
(state_data == Transaction.VALIDATED and current_confirmations == 0):
color = QColor("#ffb000")
if color:
if self.app.parameters.dark_theme:
return color.lighter(300)
else:
return color
if role == Qt.TextAlignmentRole:
if HistoryTableModel.columns_types.index('amount'):
return Qt.AlignRight | Qt.AlignVCenter
if col == HistoryTableModel.columns_types.index('date'):
return Qt.AlignCenter
if role == Qt.ToolTipRole:
if col == HistoryTableModel.columns_types.index('date'):
ts = self.blockchain_processor.adjusted_ts(self.connection.currency, source_data)
return QDateTime.fromTime_t(ts).toString(Qt.SystemLocaleLongDate)
if state_data == Transaction.VALIDATED or state_data == Transaction.AWAITING:
if current_confirmations >= MAX_CONFIRMATIONS:
return None
elif self.app.parameters.expert_mode:
return self.tr("{0} / {1} confirmations").format(current_confirmations, MAX_CONFIRMATIONS)
else:
confirmation = current_confirmations / MAX_CONFIRMATIONS * 100
confirmation = 100 if confirmation > 100 else confirmation
return self.tr("Confirming... {0} %").format(QLocale().toString(float(confirmation), 'f', 0))
def lighter(self, color: QColor) -> QColor:
return color.lighter(110)
