def __init__(self, parent=None, associatedWidget=None, orientation=Qt.Horizontal):
""" Constructor
"""
logging.debug("%s: Constructor" % self.__class__.__name__)
self._cursorEntered = False
self._menuEntryTextFields = []
self._menuEntrySlots = []
self._hoverEntry = None
self._spacer = TextField()
VispaWidget.__init__(self, parent)
self.hide()
self._associatedWidget = associatedWidget
self.setMouseTracking(True)
self.setDragable(False)
#self._hoverBrush = QBrush(self.HOVER_COLOR1)
self._hoverGradient = QRadialGradient()
self._hoverGradient.setColorAt(0, self.HOVER_COLOR1)
self._hoverGradient.setColorAt(1, self.HOVER_COLOR2)
#self._hoverBrush = QBrush(self.HOVER_COLOR1)
self._spacer.setFontSizeRange(self.TEXTFIELD_FONTSIZE_MIN, self.TEXTFIELD_FONTSIZE_MAX)
#self._textField.setDefaultWidth(self.getDistance('textFieldWidth', 1, True))
#entry.setDefaultHeight(self.getDistance('textFieldHeight', 1, True))
self._spacer.setDefaultFontSize(self.TEXTFIELD_FONTSIZE)
self._spacer.setAutosizeFont(self.TEXTFIELD_AUTOSIZE_FONT_FLAG)
self._spacer.setAutotruncate(self.TEXTFIELD_AUTOTRUNCATE_TEXT_FLAG)
self._spacer.setAutoscale(True, False)
self._spacer.setPenColor(self.TITLE_COLOR)
self._spacer.setFont(self.font())
self._spacer.setText(" | ")
self._spacer.calculateDimensions()
def __init__(self):
super(DialNotch, self).__init__()
self.setAcceptHoverEvents(True)
# Colors
self.color = QColor(125, 125, 125, 255)
self.normalBorderColor = QColor( 255, 255, 255, 30 )
self.selectedBorderColor = QColor( 255, 191, 0, 102 )
self.textColor = QColor( 30, 30, 30, 255 )
self.shadowColor = QColor(0, 0, 0, 75)
self.selectedShadowColor = QColor( 100, 100, 100, 255 )
# Settings
self.width, self.height = 12, 12
self.highlighted = False
# Painter Definitions
self.pen = QPen()
self.pen.setWidth(1)
self.pen.setColor(self.normalBorderColor)
gradient = QRadialGradient(self.boundingRect().center() + QPointF(0, 1), self.width / 2.0)
gradient.setColorAt(0, self.color)
gradient.setColorAt(0.5, self.color)
gradient.setColorAt(1, self.color.darker(120))
self.brush = QBrush(gradient)
gradient = QRadialGradient(self.boundingRect().center() + QPointF(0, 1), self.width / 2.0)
gradient.setColorAt(0, self.color.lighter(110))
gradient.setColorAt(0.5, self.color.lighter(110))
gradient.setColorAt(1, self.color.darker(120).lighter(110))
self.highlightBrush = QBrush(gradient)
# Other
self.tracking = False
self.angle = None
class QToolBadgeButton (QToolButton):
def __init__(self, parent=None):
QToolButton.__init__(self, parent)
self.badge_counter = 0
self.badge_size = 5
self.redGradient = QRadialGradient(
0.0, 0.0, 17.0, self.badge_size - 3, self.badge_size - 3)
self.redGradient.setColorAt(0.0, QColor(0xe0, 0x84, 0x9b))
self.redGradient.setColorAt(0.5, QColor(0xe9, 0x34, 0x43))
self.redGradient.setColorAt(1.0, QColor(0xdc, 0x0c, 0x00))
def setSize(self, size):
self.badge_size = size
def setCounter(self, counter):
self.badge_counter = counter
def paintEvent(self, event):
QToolButton.paintEvent(self, event)
p = QPainter(self)
p.setRenderHint(QPainter.TextAntialiasing)
p.setRenderHint(QPainter.Antialiasing)
if self.badge_counter > 0:
point = self.rect().topRight()
self.drawBadge(p, point.x() - self.badge_size, point.y(),
self.badge_size, str(self.badge_counter), QBrush(self.redGradient))
def fillEllipse(self, painter, x, y, size, brush):
path = QPainterPath()
path.addEllipse(x, y, size, size)
painter.fillPath(path, brush)
def drawBadge(self, painter, x, y, size, text, brush):
painter.setFont(QFont(painter.font().family(), 11, QFont.Bold))
while ((size - painter.fontMetrics().width(text)) < 10):
pointSize = painter.font().pointSize() - 1
weight = QFont.Normal if (pointSize < 8) else QFont.Bold
painter.setFont(
QFont(painter.font().family(), painter.font().pointSize() - 1, weight))
shadowColor = QColor(0, 0, 0, size)
self.fillEllipse(painter, x + 1, y, size, shadowColor)
self.fillEllipse(painter, x - 1, y, size, shadowColor)
self.fillEllipse(painter, x, y + 1, size, shadowColor)
self.fillEllipse(painter, x, y - 1, size, shadowColor)
painter.setPen(QPen(Qt.white, 2))
self.fillEllipse(painter, x, y, size - 3, brush)
painter.drawEllipse(x, y, size - 2, size - 2)
painter.setPen(QPen(Qt.white, 1))
painter.drawText(x, y, size - 2, size - 2, Qt.AlignCenter, text)
def paint(self, painter, option, widget):
gradient = QRadialGradient(-3, -3, 10)
if option.state & QStyle.State_Sunken:
gradient.setCenter(3, 3)
gradient.setFocalPoint(3, 3)
gradient.setColorAt(0, QColor(Qt.yellow).light(120))
else:
gradient.setColorAt(0, QColor(Qt.yellow).light(120))
painter.setBrush(gradient)
painter.setPen(QPen(Qt.black, 0))
painter.drawRoundedRect(self.boundingRect(), 3, 3)
def paint(self, painter, option, widget):
gradient = QRadialGradient(-3, -3, 10)
if option.state & QStyle.State_Sunken:
gradient.setCenter(3, 3)
gradient.setFocalPoint(3, 3)
gradient.setColorAt(0, QColor(Qt.yellow).light(120))
else:
gradient.setColorAt(0, QColor(Qt.yellow).light(120))
painter.setBrush(gradient)
painter.setPen(QPen(Qt.black, 0))
painter.drawRoundedRect(self.boundingRect(), 3, 3)
def kresliPolozku(self, painter, size, angle, nazov, color): col1 = QColor(color) col2 = QColor(color) col3 = QColor(color) col1 = col1.lighter(105) col2 = col1.darker(140) col3 = col3.darker() gradient = QRadialGradient(QPointF(size.width() / 2, size.height() / 2), size.width() / 2 - 20) gradient.setColorAt(0.0, col1) gradient.setColorAt(0.6, col2) gradient.setColorAt(1.0, col3) painter.setPen(Qt.NoPen) painter.setBrush(gradient) painter.drawPie(QRect(20, 20, size.width() - 40, size.height() - 40), self.__startAngle, angle) self.__startAngle = self.__startAngle + angle
def gradient_darker(grad, factor):
"""Return a copy of the QGradient darkened by factor.
.. note:: Only QLinearGradeint and QRadialGradient are supported.
"""
if type(grad) is QGradient:
if grad.type() == QGradient.LinearGradient:
grad = sip.cast(grad, QLinearGradient)
elif grad.type() == QGradient.RadialGradient:
grad = sip.cast(grad, QRadialGradient)
if isinstance(grad, QLinearGradient):
new_grad = QLinearGradient(grad.start(), grad.finalStop())
elif isinstance(grad, QRadialGradient):
new_grad = QRadialGradient(grad.center(), grad.radius(),
grad.focalPoint())
else:
raise TypeError
new_grad.setCoordinateMode(grad.coordinateMode())
for pos, color in grad.stops():
new_grad.setColorAt(pos, color.darker(factor))
return new_grad
def __init__(self):
super(Dial, self).__init__()
self.angle = 0
# Colors
self.color = QColor(120, 120, 120, 255)
self.notchColor = QColor(115, 115, 115, 255)
self.normalBorderColor = QColor( 255, 255, 255, 30 )
self.selectedBorderColor = QColor( 255, 191, 0, 102 )
self.textColor = QColor( 30, 30, 30, 255 )
self.shadowColor = QColor(0, 0, 0, 75)
self.selectedShadowColor = QColor( 100, 100, 100, 255 )
# Settings
self.width, self.height = 75, 75
# Drop Shadow
self.shadowBlurRadius = 8
self.shadow = QGraphicsDropShadowEffect()
self.shadow.setBlurRadius(self.shadowBlurRadius)
self.shadow.setOffset(0, 0.5)
self.shadow.setColor(self.shadowColor)
self.setGraphicsEffect(self.shadow)
# Painter Definitions
self.pen = QPen()
gradient = QRadialGradient(self.boundingRect().center() + QPointF(0, -20), 80)
gradient.setColorAt(0, self.color.lighter(117))
gradient.setColorAt(1, self.color)
self.brush = QBrush(gradient)
self.font = QFont()
self.pen.setWidth(1)
self.pen.setColor(self.normalBorderColor)
self.brush.setColor(self.color)
self.font.setPointSize(10)
# Nodegraph Definitions
self.dragPoint = None
self.dragAngle = 0
self.dragFactor = 0
# Notch Specifications
self.notch = DialNotch()
self.notch.setParentItem(self)
self.updateNotch()
def __init__(self, parent=None):
QToolButton.__init__(self, parent)
self.badge_counter = 0
self.badge_size = 5
self.redGradient = QRadialGradient(
0.0, 0.0, 17.0, self.badge_size - 3, self.badge_size - 3)
self.redGradient.setColorAt(0.0, QColor(0xe0, 0x84, 0x9b))
self.redGradient.setColorAt(0.5, QColor(0xe9, 0x34, 0x43))
self.redGradient.setColorAt(1.0, QColor(0xdc, 0x0c, 0x00))
def __init__(self, icon=None, text=None, parent=None):
if icon:
QPushButton.__init__(self, icon, text, parent)
elif text:
QPushButton.__init__(self, text, parent)
else:
QPushButton.__init__(self, parent)
self.badge_counter = 0
self.badge_size = 25
self.redGradient = QRadialGradient(
0.0, 0.0, 17.0, self.badge_size - 3, self.badge_size - 3)
self.redGradient.setColorAt(0.0, QColor(0xe0, 0x84, 0x9b))
self.redGradient.setColorAt(0.5, QColor(0xe9, 0x34, 0x43))
self.redGradient.setColorAt(1.0, QColor(0xdc, 0x0c, 0x00))
def radial_gradient(color, color_light=50):
"""
radial_gradient(QColor, QColor)
radial_gradient(QColor, int)
Return a radial gradient. `color_light` can be a QColor or an int.
In the later case the light color is derived from `color` using
`saturated(color, color_light)`.
"""
if not isinstance(color_light, QColor):
color_light = saturated(color, color_light)
gradient = QRadialGradient(0.5, 0.5, 0.5)
gradient.setColorAt(0.0, color_light)
gradient.setColorAt(0.5, color_light)
gradient.setColorAt(1.0, color)
gradient.setCoordinateMode(QRadialGradient.ObjectBoundingMode)
return gradient
def radial_gradient(color, color_light=50):
"""
radial_gradient(QColor, QColor)
radial_gradient(QColor, int)
Return a radial gradient. `color_light` can be a QColor or an int.
In the later case the light color is derived from `color` using
`saturated(color, color_light)`.
"""
if not isinstance(color_light, QColor):
color_light = saturated(color, color_light)
gradient = QRadialGradient(0.5, 0.5, 0.5)
gradient.setColorAt(0.0, color_light)
gradient.setColorAt(0.5, color_light)
gradient.setColorAt(1.0, color)
gradient.setCoordinateMode(QRadialGradient.ObjectBoundingMode)
return gradient
def drawData(self, painter, size, angle, dataname, color):
"""
Draw data
@param painter:
@type painter:
@param size:
@type size:
@param angle:
@type angle:
@param dataname:
@type dataname:
@param color:
@type color:
"""
col1 = QColor(color)
col2 = QColor(color)
col3 = QColor(color)
col1 = col1.lighter(105)
col2 = col1.darker(140)
col3 = col3.darker()
gradient = QRadialGradient(
QPointF(size.width() / 2,
size.height() / 2),
size.width() / 2 - 20)
gradient.setColorAt(0.0, col1)
gradient.setColorAt(0.6, col2)
gradient.setColorAt(1.0, col3)
painter.setPen(Qt.NoPen)
painter.setBrush(gradient)
painter.drawPie(QRect(20, 20,
size.width() - 40,
size.height() - 40), self.__startAngle, angle)
self.__startAngle = self.__startAngle + angle
def paintEvent(self, event):
w = self.width()
h = self.height()
s = min(w, h)
key = self._generateKey()
pixmap = QPixmapCache.find(key)
if not pixmap:
pixmap = QPixmap(w, h)
pixmap.fill(self, QPoint(0,
0)) # Fill pixmap with widget background
pixPainter = QPainter(pixmap)
pixPainter.setRenderHint(QPainter.Antialiasing)
# Offsets for centering
ox = int(0.5 * (w - s))
oy = int(0.5 * (h - s))
insideColor = self._color
if not self._value:
insideColor = insideColor.darker(250)
gradient = QRadialGradient(ox + 0.5 * s, oy + 0.5 * s, 0.5 * s)
gradient.setColorAt(0.27, insideColor)
gradient.setColorAt(0.6, insideColor.darker(120))
gradient.setColorAt(1.0, insideColor.darker(160))
pixPainter.setBrush(gradient)
pixPainter.setPen(QPen(Qt.black, 2))
pixPainter.drawEllipse(1 + ox, 1 + oy, s - 2, s - 2)
pixPainter.end()
QPixmapCache.insert(key, pixmap)
p = QPainter()
p.begin(self)
p.drawPixmap(QPoint(0, 0), pixmap)
p.end()
class MenuWidget(VispaWidget):
# inherited properties
HEIGHT = 30
BACKGROUND_SHAPE = 'ROUNDRECT'
ROUNDRECT_RADIUS = 10
PEN_COLOR = QColor(242, 230, 242)
FILL_COLOR1 = QColor(59, 59, 59, 200)
#FILL_COLOR2 = QColor(242, 230, 242)
TITLE_COLOR = QColor(Qt.white)
AUTOSIZE = True
AUTOSIZE_KEEP_ASPECT_RATIO = False
SELECTABLE_FLAG = False
USE_BACKGROUND_GRADIENT_FLAG = False
# new properties
HOVER_COLOR1 = QColor(0, 0, 240)
HOVER_COLOR2 = QColor(0, 0, 200)
def __init__(self, parent=None, associatedWidget=None, orientation=Qt.Horizontal):
""" Constructor
"""
logging.debug("%s: Constructor" % self.__class__.__name__)
self._cursorEntered = False
self._menuEntryTextFields = []
self._menuEntrySlots = []
self._hoverEntry = None
self._spacer = TextField()
VispaWidget.__init__(self, parent)
self.hide()
self._associatedWidget = associatedWidget
self.setMouseTracking(True)
self.setDragable(False)
#self._hoverBrush = QBrush(self.HOVER_COLOR1)
self._hoverGradient = QRadialGradient()
self._hoverGradient.setColorAt(0, self.HOVER_COLOR1)
self._hoverGradient.setColorAt(1, self.HOVER_COLOR2)
#self._hoverBrush = QBrush(self.HOVER_COLOR1)
self._spacer.setFontSizeRange(self.TEXTFIELD_FONTSIZE_MIN, self.TEXTFIELD_FONTSIZE_MAX)
#self._textField.setDefaultWidth(self.getDistance('textFieldWidth', 1, True))
#entry.setDefaultHeight(self.getDistance('textFieldHeight', 1, True))
self._spacer.setDefaultFontSize(self.TEXTFIELD_FONTSIZE)
self._spacer.setAutosizeFont(self.TEXTFIELD_AUTOSIZE_FONT_FLAG)
self._spacer.setAutotruncate(self.TEXTFIELD_AUTOTRUNCATE_TEXT_FLAG)
self._spacer.setAutoscale(True, False)
self._spacer.setPenColor(self.TITLE_COLOR)
self._spacer.setFont(self.font())
self._spacer.setText(" | ")
self._spacer.calculateDimensions()
def addEntry(self, name, slot=None):
entry = TextField()
entry.setFontSizeRange(self.TEXTFIELD_FONTSIZE_MIN, self.TEXTFIELD_FONTSIZE_MAX)
#self._textField.setDefaultWidth(self.getDistance('textFieldWidth', 1, True))
#entry.setDefaultHeight(self.getDistance('textFieldHeight', 1, True))
entry.setDefaultFontSize(self.TEXTFIELD_FONTSIZE)
entry.setAutosizeFont(self.TEXTFIELD_AUTOSIZE_FONT_FLAG)
entry.setAutotruncate(self.TEXTFIELD_AUTOTRUNCATE_TEXT_FLAG)
entry.setAutoscale(True, False)
entry.setPenColor(self.TITLE_COLOR)
entry.setFont(self.font())
entry.setText(name)
entry.calculateDimensions()
self._menuEntryTextFields.append(entry)
self._menuEntrySlots.append(slot)
self.scheduleRearangeContent()
return entry
def removeEntry(self, entry):
if entry in self._menuEntryTextFields:
index = self._menuEntryTextFields.index(entry)
self._menuEntryTextFields.remove(entry)
self._menuEntrySlots.pop(index)
def setEntryText(self, entry, text):
if entry in self._menuEntryTextFields:
entry.setText(text)
entry.calculateDimensions()
self.scheduleRearangeContent()
def len(self):
return len(self._menuEntryTextFields)
def entry(self, index):
if len(self._menuEntryTextFields) >= index + 1:
return self._menuEntryTextFields[index]
return None
def sizeHint(self):
""" Calculates needed space for widget content.
"""
self._scaleWidth = 1 # for getDistance()
self._scaleHeight = 1
neededWidth = self.getDistance('leftMargin', 1) + self.getDistance('rightMargin', 1)
neededHeight = self.getDistance('topMargin', 1) + self.getDistance('bottomMargin', 1)
textFieldWidth = 0
textFieldHeight = 0
for entry in self._menuEntryTextFields:
textFieldWidth += entry.getWidth()
textFieldHeight = max(textFieldHeight, entry.getHeight())
textFieldWidth += max(0, (len(self._menuEntryTextFields) -1) * self._spacer.getWidth())
neededWidth += textFieldWidth
neededHeight += textFieldHeight
# evaluate maximum size
maxWidth = self.maximumSize().width()
maxHeight = self.maximumSize().height()
maxScaleWidth = min(1.0, 1.0 * maxWidth/neededWidth)
maxScaleHeight = min(1.0, 1.0 * maxHeight/neededHeight)
if maxScaleWidth != 1.0 or maxScaleHeight != 1.0:
# this is not limited by keepAspectRationFlag
# as it is about absolute sizes here
# ratio is evaluated in autosize()
scale = min(maxScaleWidth, maxScaleHeight)
neededWidth *= scale
neededHeight *= scale
return QSize(max(self.minimumSize().width(), neededWidth), max(self.minimumSize().height(), neededHeight))
def paint(self, painter, event=None):
""" Takes care of painting widget content on given painter.
"""
VispaWidget.paint(self, painter, event)
self.drawMenuEntries(painter)
def drawMenuEntries(self, painter):
""" Tells TextField object of text field to draw title on widget.
"""
x = self.getDistance('textFieldX')
y = self.getDistance('textFieldY')
spacerWidth = self._spacer.getWidth() * self.zoomFactor()
originalPen = QPen()
painter.setPen(originalPen)
firstFlag = True
for entry in self._menuEntryTextFields:
if not firstFlag:
self._spacer.paint(painter, x, y, self.zoomFactor())
x += spacerWidth
if self._hoverEntry == entry:
hoverRectXOffset = 0.3 * spacerWidth
hoverRectYOffset = 0.3 * self.getDistance('topMargin')
hoverWidth = entry.getWidth() * self.zoomFactor() + 2 * hoverRectXOffset
hoverHeight = entry.getHeight() * self.zoomFactor() + 2 * hoverRectYOffset
#self._hoverGradient.setColorAt(0, self.HOVER_COLOR1)
#self._hoverGradient.setColorAt(1, self.HOVER_COLOR2)
self._hoverGradient.setCenter(QPointF(entry.getDrawRect(self.zoomFactor()).center()))
self._hoverGradient.setFocalPoint(QPointF(entry.getDrawRect(self.zoomFactor()).center()))
self._hoverGradient.setRadius(min(hoverWidth, hoverHeight))
#painter.setBrush(self._hoverBrush)
painter.setBrush(self._hoverGradient)
painter.setPen(Qt.NoPen)
#painter.drawRoundedRect(entry.getDrawRect(self.zoomFactor()), 10, 10)
painter.drawRoundedRect(x - hoverRectXOffset, y - hoverRectYOffset, hoverWidth, hoverHeight, 5, 5)
painter.setPen(originalPen)
entry.paint(painter, x, y, self.zoomFactor())
x += entry.getWidth() * self.zoomFactor()
firstFlag = False
def mouseMoveEvent(self, event):
if bool(event.buttons() & Qt.LeftButton):
VispaWidget.mouseMoveEvent(self, event)
return
for entry in self._menuEntryTextFields:
if entry.getDrawRect(self.zoomFactor()).contains(event.pos()):
self._hoverEntry = entry
self.update()
break
def mousePressEvent(self, event):
VispaWidget.mousePressEvent(self, event)
for i, entry in enumerate(self._menuEntryTextFields):
if self._menuEntrySlots[i] and entry.getDrawRect(self.zoomFactor()).contains(event.pos()):
self.hide()
self._menuEntrySlots[i]()
break
def leaveEvent(self, event):
#logging.debug("%s: leaveEvent()" % self.__class__.__name__)
if not self._associatedWidget or self.parent().childAt(self.parent().mapFromGlobal(self.cursor().pos())) != self._associatedWidget:
self.hide()
self._hoverEntry = None
self.update()
def hide(self):
VispaWidget.hide(self)
self._hoverEntry = None
def showEvent(self, event):
VispaWidget.showEvent(self, event)
self._cursorEntered = False
def enterEvent(self, event):
self._cursorEntered = True
def cursorHasEntered(self):
return self._cursorEntered
def drawCorner(self, painter, position, cornerType, maxRadius=None):
#logging.debug(self.__class__.__name__ +": drawCorner() "+ self.cornerTypeString(cornerType))
thickness = self.CONNECTION_THICKNESS * self.zoomFactor()
halfthick = thickness / 2
cornerRoundness = halfthick ** 0.5
cornerOffset = halfthick * (cornerRoundness)
innerCorner = halfthick * (cornerRoundness - 1)
outerCorner = halfthick * (cornerRoundness + 1)
innerWidth = halfthick * (cornerRoundness - 1)
radius = halfthick * (cornerRoundness + 1)
if maxRadius:
maxRadius = max(maxRadius, thickness)
radius = min(radius, maxRadius)
if cornerType == self.CornerType.TOP_RIGHT:
startAngle = 0
outerCorner = QPointF(position.x() + halfthick - 2 * radius, position.y() - halfthick)
innerCorner = QPointF(outerCorner.x(), outerCorner.y() + (thickness))
center = QPointF(outerCorner.x() + radius, outerCorner.y() + radius)
outerRect = QRectF(outerCorner, QSizeF(2 * radius, 2 * radius))
innerRect = QRectF(innerCorner, QSizeF((2 * radius - thickness), (2 * radius - thickness)))
outerStart = QPointF(outerCorner.x() + 2 * radius, outerCorner.y() + (radius + halfthick))
innerStart = QPointF(outerCorner.x() + (radius - halfthick), outerCorner.y())
elif cornerType == self.CornerType.TOP_LEFT:
startAngle = 90
outerCorner = QPointF(position.x() - halfthick, position.y() - halfthick)
innerCorner = QPointF(outerCorner.x() + (thickness), outerCorner.y() + (thickness))
center = QPointF(outerCorner.x() + radius, outerCorner.y() + radius)
outerRect = QRectF(outerCorner, QSizeF(2 * radius, 2 * radius))
innerRect = QRectF(innerCorner, QSizeF((2 * radius - thickness), (2 * radius - thickness)))
outerStart = QPointF(outerCorner.x() + (radius + halfthick), outerCorner.y())
innerStart = QPointF(outerCorner.x(), outerCorner.y() + (radius + halfthick))
elif cornerType == self.CornerType.BOTTOM_LEFT:
startAngle = 180
outerCorner = QPointF(position.x() - halfthick, position.y() + halfthick - 2 * radius)
innerCorner = QPointF(outerCorner.x() + (thickness), outerCorner.y())
center = QPointF(outerCorner.x() + radius, outerCorner.y() + radius)
outerRect = QRectF(outerCorner, QSizeF(2 * radius, 2 * radius))
innerRect = QRectF(innerCorner, QSizeF((2 * radius - thickness), (2 * radius - thickness)))
outerStart = QPointF(outerCorner.x(), outerCorner.y() + (radius - halfthick))
innerStart = QPointF(outerCorner.x() + (radius + halfthick), outerCorner.y() + (2 * radius))
elif cornerType == self.CornerType.BOTTOM_RIGHT:
startAngle = 270
outerCorner = QPointF(position.x() + halfthick - 2 * radius, position.y() + halfthick - 2 * radius)
innerCorner = QPointF(outerCorner.x(), outerCorner.y())
center = QPointF(outerCorner.x() + radius, outerCorner.y() + radius)
outerRect = QRectF(outerCorner, QSizeF(2 * radius, 2 * radius))
innerRect = QRectF(innerCorner, QSizeF((2 * radius - thickness), (2 * radius - thickness)))
outerStart = QPointF(outerCorner.x() + (radius - halfthick), outerCorner.y() + 2 * radius)
innerStart = QPointF(outerCorner.x() + 2 * radius, outerCorner.y() + (radius - halfthick))
else:
# No defined corner, so nothing to draw.
#print "PointToPointConnection.drawCorner() - No valid corner, aborting..."
return
if painter.redirected(painter.device()):
# e.q. QPixmap.grabWidget()
painter.setBrush(self.FILL_COLOR1)
else:
brush = QRadialGradient(center, radius)
if radius >= thickness:
brush.setColorAt((radius - thickness) / radius, self.FILL_COLOR1) # inner border
brush.setColorAt((radius - halfthick + 1) / radius, self.FILL_COLOR2) # center of line
else:
# If zoom is too small use single color
brush.setColorAt(0, self.FILL_COLOR1)
brush.setColorAt(1, self.FILL_COLOR1) # outer border
painter.setBrush(brush)
path = QPainterPath()
path.moveTo(outerStart)
path.arcTo(outerRect, startAngle, 90)
path.lineTo(innerStart)
path.arcTo(innerRect, startAngle + 90, - 90)
path.closeSubpath()
#painter.setPen(Qt.NoPen)
painter.drawPath(path)
def paint(self, painter, option, widget):
"""
Draws this item with the inputed painter.
:param painter | <QPainter>
rect | <QRect>
"""
if self._dirty:
self.rebuild()
scene = self.scene()
if not scene:
return
grid = scene.gridRect()
typ = self.chartType()
# draw the line chart
if typ == XChartScene.Type.Line:
painter.setRenderHint(painter.Antialiasing)
# draw the path area
area = self._buildData.get('path_area')
if area and self.isShaded():
clr = QColor(self.color())
clr.setAlpha(120)
painter.setPen(Qt.NoPen)
painter.setBrush(clr)
painter.drawPath(area)
# draw the line data
pen = QPen(self.color())
pen.setWidth(2)
painter.setPen(pen)
painter.setBrush(Qt.NoBrush)
painter.drawPath(self.path())
if (self.showPointsInLine()):
palette = QApplication.palette()
pen = QPen(palette.color(palette.Base))
pen.setWidth(2)
painter.setBrush(self.color())
painter.setPen(pen)
for point in self._ellipses:
painter.drawEllipse(point, self.pointRadius(),
self.pointRadius())
# draw a bar chart
elif typ == XChartScene.Type.Bar:
painter.setRenderHint(painter.Antialiasing)
pen = QPen(self.color())
pen.setWidth(1)
painter.setPen(pen)
for key, value, sub_path in self._subpaths:
gradient = QLinearGradient()
clr = QColor(self.color())
if (sub_path != self._hoveredPath):
clr.setAlpha(130)
gradient.setColorAt(0.0, clr.lighter(140))
gradient.setColorAt(0.1, clr.lighter(120))
gradient.setColorAt(0.25, clr.lighter(110))
gradient.setColorAt(1.0, clr.lighter(105))
if (self.orientation() == Qt.Horizontal):
gradient.setStart(0, sub_path.boundingRect().top())
gradient.setFinalStop(0, sub_path.boundingRect().bottom())
else:
gradient.setStart(sub_path.boundingRect().left(), 0)
gradient.setFinalStop(sub_path.boundingRect().right(), 0)
painter.setBrush(gradient)
painter.drawPath(sub_path)
# draw a simple pie chart (calculated by scene)
elif typ == XChartScene.Type.Pie:
painter.setRenderHint(painter.Antialiasing)
center = self.pieCenter()
radius = self.radius()
for key, value, sub_path in self._subpaths:
clr = self.keyColor(key)
gradient = QRadialGradient(QPointF(0, 0), radius)
a = QColor(clr.lighter(140))
b = QColor(clr.lighter(110))
a.setAlpha(40)
b.setAlpha(80)
# look for mouse over
if (sub_path == self._hoveredPath):
a.setAlpha(100)
b.setAlpha(200)
gradient.setColorAt(0, a)
gradient.setColorAt(1, b)
pen = QPen(clr)
pen.setWidth(1)
painter.setBrush(gradient)
painter.setPen(pen)
painter.drawPath(sub_path)
def paintEvent(self, event):
realSize = min(self.width(), self.height())
painter = QPainter()
painter.begin(self)
pen = QPen(Qt.black)
pen.setWidth(1)
painter.setPen(Qt.black)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width() / 2, self.height() / 2)
painter.scale(
float(realSize) / self.scaledSize,
float(realSize) / self.scaledSize)
gradient = QRadialGradient(QPointF(-500, -500), 1500,
QPointF(-500, -500))
gradient.setColorAt(0, QColor(224, 224, 224))
gradient.setColorAt(1, QColor(28, 28, 28))
painter.setPen(pen)
painter.setBrush(QBrush(gradient))
painter.drawEllipse(QPointF(0, 0), 500, 500)
gradient = QRadialGradient(QPointF(500, 500), 1500, QPointF(500, 500))
gradient.setColorAt(0, QColor(224, 224, 224))
gradient.setColorAt(1, QColor(28, 28, 28))
painter.setPen(pen)
painter.setBrush(QBrush(gradient))
painter.drawEllipse(QPointF(0, 0), 450, 450)
painter.setPen(pen)
if (self.isChecked()):
gradient = QRadialGradient(QPointF(-500, -500), 1500,
QPointF(-500, -500))
gradient.setColorAt(0, self._onColor1)
gradient.setColorAt(1, self._onColor2)
else:
gradient = QRadialGradient(QPointF(500, 500), 1500,
QPointF(500, 500))
gradient.setColorAt(0, self._offColor1)
gradient.setColorAt(1, self._offColor2)
painter.setBrush(gradient)
painter.drawEllipse(QPointF(0, 0), 400, 400)
painter.end()
def paint(self, painter, rect, widget_size, draw_highlight):
if not self.model() or not self.totalValue:
return
selections = self.selectionModel()
option = self.viewOptions()
background = option.palette.base()
foreground = QPen(option.palette.color(QPalette.Foreground))
painter.fillRect(rect, background)
painter.setPen(foreground)
if widget_size == self.viewport().rect():
# We are drawing on screen
legend_width = LEGEND_WIDTH
totalSize = self.totalSize
else:
# TODO: factorize with resizeEvent
# We are drawing on printer
fm = QFontMetrics(painter.font())
legend_width = fm.width("0000:0000:0000:0000:0000:0000:0000:0000") # Let's use an ipv6 as the legend size reference
if widget_size.width() - legend_width < widget_size.height():
totalSize = widget_size.width()
else:
totalSize = widget_size.height() + legend_width
if totalSize < legend_width * 2:
totalSize = legend_width * 2
totalSize -= legend_width
pieSize = totalSize - 2*self.margin
if self.validItems > 0:
painter.save()
painter.drawEllipse(self.margin, self.margin, pieSize, pieSize)
startAngle = 0.0
class MyPoint:
def __init__(self, x = 0, y = 0):
self.x = x
self.y = y
def to_rad(x):
return x / 180.0 * M_PI
pies_pos = {}
keyNumber = 0
# Draw all parts of pie
for row in xrange(self.model().rowCount(self.rootIndex())):
index = self.model().index(row, 1, self.rootIndex())
value = self.model().data(index).toDouble()[0]
if value > 0.0:
angle = 360*value/self.totalValue
colorIndex = self.model().index(row, 0, self.rootIndex())
color = QColor(self.model().data(colorIndex, Qt.DecorationRole).toString())
if self.highlight and index.row() == self.highlight.row():
color = color.light(120)
# Create the gradient effect
grad = QRadialGradient(0.0, 0.0, pieSize / 2.0 + 10.0)
grad.setColorAt(1.0, Qt.black)
grad.setColorAt(0.85, color)
grad.setColorAt(0.0, color)
painter.setBrush(QBrush(grad))
painter.setBrushOrigin(totalSize / 2, totalSize / 2)
painter.drawPie(self.margin, self.margin, pieSize, pieSize, int(startAngle*16), int(angle*16))
point_angle = (startAngle + (angle / 2.0))
pies_pos[keyNumber] = MyPoint(self.margin + (pieSize / 2.0) * (1.0 + 0.66 * cos(to_rad(point_angle))),
self.margin + (pieSize / 2.0) * (1.0 - 0.66 * sin(to_rad(point_angle))))
startAngle += angle
keyNumber += 1
# Todo: factorize-me
if draw_highlight:
keyNumber = 0
for row in xrange(self.model().rowCount(self.rootIndex())):
index = self.model().index(row, 1, self.rootIndex())
value = self.model().data(index).toDouble()[0]
if keyNumber >= len(pies_pos):
break
if value > 0.0:
if self.highlight and index.row() == self.highlight.row():
itemHeight = QFontMetrics(painter.font()).height()
x0 = pies_pos[keyNumber].x
y0 = pies_pos[keyNumber].y
x2 = totalSize + itemHeight
y2 = self.margin + (keyNumber +0.5) * itemHeight
y1 = y2
if y0 > y1:
x1 = x0 + (y0 - y1) / 2
else:
x1 = x0 + (y1 - y0) / 2
painter.drawLine(x0, y0, x1, y1)
painter.drawLine(x1, y1, x2, y2)
keyNumber += 1
# Draw the legend
keyNumber = 0
for row in xrange(self.model().rowCount(self.rootIndex())):
index = self.model().index(row, 1, self.rootIndex())
value = self.model().data(index).toDouble()[0]
if value > 0.0:
labelIndex = self.model().index(row, 0, self.rootIndex())
color = QColor(labelIndex.data(Qt.DecorationRole).toString())
txt = unicode(labelIndex.data().toString())
painter.setBrush(color)
itemHeight = QFontMetrics(painter.font()).height()
x = totalSize + itemHeight
y = self.margin + keyNumber * itemHeight
painter.drawRect(x, y, itemHeight, itemHeight)
painter.drawText(QRect(x + 1.5 * itemHeight, y, legend_width - 2 * itemHeight, itemHeight), Qt.AlignLeft|Qt.AlignVCenter, txt)
keyNumber += 1
painter.restore()
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
width = self.width()
height = self.height()
if self.dynamic_resize:
knob_radius = self.dynamic_knob_radius
else:
knob_radius = self.knob_radius
# ensure that the center point is in the middle of a pixel to ensure
# that exact vertial and horizantal ticks are drawn exactly 1px wide
x = math.floor(width / 2.0) + 0.5
y = math.floor(height / 2.0) + 0.5
if DEBUG:
painter.fillRect(0, 0, width, height, Qt.yellow)
painter.translate(x, y)
if self.knob_style == KnobWidget.STYLE_NEEDLE:
r = min(x, y) - 1
painter.setPen(Qt.white)
painter.setBrush(Qt.white)
painter.drawEllipse(QPoint(0, 0), r, r)
angle = self.value_factor * self.total_angle - (self.total_angle / 2.0)
# draw base knob or needle spike
if self.knob_style == KnobWidget.STYLE_ROUND:
painter.setPen(self.border_color)
if self.pressed:
gradient = QRadialGradient(0, 0, knob_radius)
gradient.setColorAt(0, self.base_color_pressed)
gradient.setColorAt(0.85, self.base_color)
gradient.setColorAt(1, self.base_color)
painter.setBrush(gradient)
else:
painter.setBrush(self.base_color)
painter.drawEllipse(QPoint(0, 0), knob_radius, knob_radius)
elif self.knob_style == KnobWidget.STYLE_NEEDLE:
painter.save()
painter.rotate(angle)
painter.setPen(self.needle_color)
painter.setBrush(self.needle_color)
needle = QPolygonF()
needle.append(QPointF(self.needle_base_radius * 0.6, 0))
needle.append(QPointF(0, -knob_radius))
needle.append(QPointF(-self.needle_base_radius * 0.6, 0))
painter.drawPolygon(needle)
painter.restore()
# draw knob mark or needle base
if self.knob_style == KnobWidget.STYLE_ROUND:
painter.save()
painter.rotate(angle)
painter.setPen(QPen(self.mark_color, 2))
painter.drawLine(0, -knob_radius * 0.4, 0, -knob_radius * 0.8)
painter.restore()
elif self.knob_style == KnobWidget.STYLE_NEEDLE:
painter.setPen(self.border_color)
painter.setBrush(self.base_color)
painter.drawEllipse(QPoint(0, 0), self.needle_base_radius, self.needle_base_radius)
if self.scale_visible:
painter.setPen(Qt.black)
# draw scale arc
if self.scale_arc_visible:
painter.drawArc(-knob_radius - self.knob_to_scale,
-knob_radius - self.knob_to_scale,
knob_radius * 2 + self.knob_to_scale * 2,
knob_radius * 2 + self.knob_to_scale * 2,
(90 + self.total_angle / 2) * 16, -self.total_angle * 16)
# draw scale ticks
def value_to_angle(value):
return (float(value - self.minimum_value) / self.value_range) * self.total_angle - (self.total_angle / 2.0)
value = self.minimum_value
while value <= self.maximum_value:
angle = value_to_angle(value)
painter.save()
painter.rotate(value_to_angle(value))
painter.drawLine(0, -knob_radius - self.knob_to_scale,
0, -knob_radius - self.knob_to_scale - self.tick_size_large)
if self.scale_text_visible:
p = painter.worldTransform().map(QPoint(0, -knob_radius - \
self.knob_to_scale - \
self.tick_size_large - \
self.tick_to_text - \
self.text_radius))
painter.restore()
if self.scale_text_visible:
if DEBUG:
painter.save()
painter.setPen(QColor(255, 0, 0, 50))
painter.setBrush(QColor(255, 0, 0, 50))
painter.drawEllipse(QPoint(p.x() - x, p.y() - y),
self.text_radius, self.text_radius)
painter.restore()
painter.drawText(p.x() - x - 30, p.y() - y - 30, 60, 60,
Qt.TextDontClip | Qt.AlignHCenter | Qt.AlignVCenter,
str(value))
for i in range(1, self.scale_step_divisions):
sub_value = value + (float(self.scale_step_size) * i) / self.scale_step_divisions
if sub_value > self.maximum_value:
break
painter.save()
painter.rotate(value_to_angle(sub_value))
painter.drawLine(0, -knob_radius - self.knob_to_scale,
0, -knob_radius - self.knob_to_scale - self.tick_size_small)
painter.restore()
value += self.scale_step_size
if self.title_text != None:
painter.drawText(-knob_radius, knob_radius - 30,
knob_radius * 2, 60,
Qt.TextDontClip | Qt.AlignHCenter | Qt.AlignVCenter,
self.title_text)
def paintEvent(self,event):
realSize=min(self.width(),self.height())
painter=QPainter()
painter.begin(self)
pen=QPen(Qt.black)
pen.setWidth(1)
painter.setPen(Qt.black)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width()/2,self.height()/2)
painter.scale(float(realSize)/self.scaledSize, float(realSize)/self.scaledSize)
gradient = QRadialGradient (QPointF(-500,-500), 1500, QPointF(-500,-500));
gradient.setColorAt(0, QColor(224,224,224));
gradient.setColorAt(1, QColor(28,28,28));
painter.setPen(pen);
painter.setBrush(QBrush(gradient));
painter.drawEllipse(QPointF(0,0), 500, 500);
gradient = QRadialGradient (QPointF(500,500), 1500, QPointF(500,500));
gradient.setColorAt(0, QColor(224,224,224));
gradient.setColorAt(1, QColor(28,28,28));
painter.setPen(pen);
painter.setBrush(QBrush(gradient));
painter.drawEllipse(QPointF(0,0), 450, 450);
painter.setPen(pen);
if(self.isChecked()):
gradient = QRadialGradient (QPointF(-500,-500), 1500, QPointF(-500,-500));
gradient.setColorAt(0, self._onColor1);
gradient.setColorAt(1, self._onColor2);
else:
gradient = QRadialGradient (QPointF(500,500), 1500, QPointF(500,500));
gradient.setColorAt(0, self._offColor1);
gradient.setColorAt(1, self._offColor2);
painter.setBrush(gradient);
painter.drawEllipse(QPointF(0,0), 400, 400);
painter.end()
def drawCorner(self, painter, position, cornerType, maxRadius=None):
#logging.debug(self.__class__.__name__ +": drawCorner() "+ self.cornerTypeString(cornerType))
thickness = self.CONNECTION_THICKNESS * self.zoomFactor()
halfthick = thickness / 2
cornerRoundness = halfthick**0.5
cornerOffset = halfthick * (cornerRoundness)
innerCorner = halfthick * (cornerRoundness - 1)
outerCorner = halfthick * (cornerRoundness + 1)
innerWidth = halfthick * (cornerRoundness - 1)
radius = halfthick * (cornerRoundness + 1)
if maxRadius:
maxRadius = max(maxRadius, thickness)
radius = min(radius, maxRadius)
if cornerType == self.CornerType.TOP_RIGHT:
startAngle = 0
outerCorner = QPointF(position.x() + halfthick - 2 * radius,
position.y() - halfthick)
innerCorner = QPointF(outerCorner.x(),
outerCorner.y() + (thickness))
center = QPointF(outerCorner.x() + radius,
outerCorner.y() + radius)
outerRect = QRectF(outerCorner, QSizeF(2 * radius, 2 * radius))
innerRect = QRectF(
innerCorner,
QSizeF((2 * radius - thickness), (2 * radius - thickness)))
outerStart = QPointF(outerCorner.x() + 2 * radius,
outerCorner.y() + (radius + halfthick))
innerStart = QPointF(outerCorner.x() + (radius - halfthick),
outerCorner.y())
elif cornerType == self.CornerType.TOP_LEFT:
startAngle = 90
outerCorner = QPointF(position.x() - halfthick,
position.y() - halfthick)
innerCorner = QPointF(outerCorner.x() + (thickness),
outerCorner.y() + (thickness))
center = QPointF(outerCorner.x() + radius,
outerCorner.y() + radius)
outerRect = QRectF(outerCorner, QSizeF(2 * radius, 2 * radius))
innerRect = QRectF(
innerCorner,
QSizeF((2 * radius - thickness), (2 * radius - thickness)))
outerStart = QPointF(outerCorner.x() + (radius + halfthick),
outerCorner.y())
innerStart = QPointF(outerCorner.x(),
outerCorner.y() + (radius + halfthick))
elif cornerType == self.CornerType.BOTTOM_LEFT:
startAngle = 180
outerCorner = QPointF(position.x() - halfthick,
position.y() + halfthick - 2 * radius)
innerCorner = QPointF(outerCorner.x() + (thickness),
outerCorner.y())
center = QPointF(outerCorner.x() + radius,
outerCorner.y() + radius)
outerRect = QRectF(outerCorner, QSizeF(2 * radius, 2 * radius))
innerRect = QRectF(
innerCorner,
QSizeF((2 * radius - thickness), (2 * radius - thickness)))
outerStart = QPointF(outerCorner.x(),
outerCorner.y() + (radius - halfthick))
innerStart = QPointF(outerCorner.x() + (radius + halfthick),
outerCorner.y() + (2 * radius))
elif cornerType == self.CornerType.BOTTOM_RIGHT:
startAngle = 270
outerCorner = QPointF(position.x() + halfthick - 2 * radius,
position.y() + halfthick - 2 * radius)
innerCorner = QPointF(outerCorner.x(), outerCorner.y())
center = QPointF(outerCorner.x() + radius,
outerCorner.y() + radius)
outerRect = QRectF(outerCorner, QSizeF(2 * radius, 2 * radius))
innerRect = QRectF(
innerCorner,
QSizeF((2 * radius - thickness), (2 * radius - thickness)))
outerStart = QPointF(outerCorner.x() + (radius - halfthick),
outerCorner.y() + 2 * radius)
innerStart = QPointF(outerCorner.x() + 2 * radius,
outerCorner.y() + (radius - halfthick))
else:
# No defined corner, so nothing to draw.
#print "PointToPointConnection.drawCorner() - No valid corner, aborting..."
return
if painter.redirected(painter.device()):
# e.q. QPixmap.grabWidget()
painter.setBrush(self.FILL_COLOR1)
else:
brush = QRadialGradient(center, radius)
if radius >= thickness:
brush.setColorAt((radius - thickness) / radius,
self.FILL_COLOR1) # inner border
brush.setColorAt((radius - halfthick + 1) / radius,
self.FILL_COLOR2) # center of line
else:
# If zoom is too small use single color
brush.setColorAt(0, self.FILL_COLOR1)
brush.setColorAt(1, self.FILL_COLOR1) # outer border
painter.setBrush(brush)
path = QPainterPath()
path.moveTo(outerStart)
path.arcTo(outerRect, startAngle, 90)
path.lineTo(innerStart)
path.arcTo(innerRect, startAngle + 90, -90)
path.closeSubpath()
#painter.setPen(Qt.NoPen)
painter.drawPath(path)
