def paintEvent(self, event):
painter = QPainter(self)
area_color = self.palette().color(QPalette.Active, QPalette.Highlight)
if self._full_area_drop:
r = self.rect()
painter.fillRect(r, QBrush(area_color, Qt.Dense4Pattern))
painter.setBrush(QBrush(area_color))
painter.drawRect(r)
return
r = self.rect()
drop_area = self.cursor_location()
if drop_area == DropArea.TopDropArea:
r.setHeight(r.height() * 0.5)
elif drop_area == DropArea.RightDropArea:
r.setX(r.width() * 0.5)
elif drop_area == DropArea.BottomDropArea:
r.setY(r.height() * 0.5)
elif drop_area == DropArea.LeftDropArea:
r.setWidth(r.width() * 0.5)
elif drop_area == DropArea.CenterDropArea:
r = self.rect()
if not r.isNull():
painter.fillRect(r, QBrush(area_color, Qt.Dense4Pattern))
painter.setBrush(QBrush(area_color))
painter.drawRect(r)
def __init__(self, rect=None, parent=None):
self.signals = CurveNodeItemSignals()
gradient = QRadialGradient(
self.WIDTH * 0.75, self.WIDTH * 0.75, self.WIDTH * 0.75, self.WIDTH * 0.75, self.WIDTH * 0.75)
gradient.setColorAt(0, self.theme().accent_color_6 if self.theme() else QColor.fromRgbF(1, 0.5, 0.01, 1))
gradient.setColorAt(1, self.theme().accent_color_8 if self.theme() else QColor.fromRgbF(1, 0.6, 0.06, 1))
self._brush = QBrush(gradient)
self._brush.setStyle(Qt.RadialGradientPattern)
self._pen = QPen()
self._pen.setStyle(Qt.SolidLine)
self._pen.setWidth(2)
self._pen.setColor(self.theme().accent_color if self.theme() else QColor(104, 104, 104, 255))
self._selected_pen = QPen()
self._selected_pen.setStyle(Qt.SolidLine)
self._selected_pen.setWidth(3)
self._selected_pen.setColor(self.theme().accent_color_4 if self.theme() else QColor(67, 255, 163, 255))
super(CurveNodeItem, self).__init__(parent)
self._lock_x_pos = False
self._snap = False
self._current_pos = None
self._new_pos = None
self._line = None
self._is_point1 = False
self.set_rect(rect if rect else QRect(0, 0, 10, 10))
self.setFlags(
QGraphicsItem.ItemIsMovable | QGraphicsItem.ItemIsSelectable | QGraphicsItem.ItemSendsScenePositionChanges)
def paint(self, painter, option, widget):
background_rect = self.boundingRect()
if self.hovered:
painter.setBrush(QBrush(self.color.lighter(160)))
else:
painter.setBrush(QBrush(self.color))
painter.drawEllipse(background_rect)
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.HighQualityAntialiasing)
gradient = QRadialGradient(self._bounds.center(),
self._bounds.width() * 0.5,
self._bounds.center())
gradient.setFocalRadius(self._bounds.width() * 0.3)
gradient.setCenterRadius(self._bounds.width() * 0.7)
gradient.setColorAt(0, Qt.white)
gradient.setColorAt(1, Qt.lightGray)
painter.setPen(QPen(QBrush(Qt.gray), self._bounds.width() * 0.005))
painter.setBrush(QBrush(gradient))
painter.drawEllipse(self._bounds)
painter.setPen(QPen(QBrush(Qt.gray), self._bounds.width() * 0.005))
painter.drawLine(
QPointF(self._bounds.left(),
self._bounds.center().y()),
QPointF(self._bounds.center().x() - self._bounds.width() * 0.35,
self._bounds.center().y()))
painter.drawLine(
QPointF(self._bounds.center().x() + self._bounds.width() * 0.35,
self._bounds.center().y()),
QPointF(self._bounds.right(),
self._bounds.center().y()))
painter.drawLine(
QPointF(self._bounds.center().x(), self._bounds.top()),
QPointF(self._bounds.center().x(),
self._bounds.center().y() - self._bounds.width() * 0.35))
painter.drawLine(
QPointF(self._bounds.center().x(),
self._bounds.center().y() + self._bounds.width() * 0.35),
QPointF(self._bounds.center().x(), self._bounds.bottom()))
if not self.isEnabled():
return
gradient = QRadialGradient(self._knop_bounds.center(),
self._knop_bounds.width() * 0.5,
self._knop_bounds.center())
gradient.setFocalRadius(self._knop_bounds.width() * 0.2)
gradient.setCenterRadius(self._knop_bounds.width() * 0.5)
gradient.setColorAt(0, Qt.gray)
gradient.setColorAt(1, Qt.darkGray)
painter.setPen(QPen(QBrush(Qt.darkGray), self._bounds.width() * 0.005))
painter.setBrush(QBrush(gradient))
painter.drawEllipse(self._knop_bounds)
def setTextColor(self, text_color):
"""
Sets the foreground color to the given color
:param text_color: variant, QColor or str
"""
if isinstance(text_color, QColor):
text_color = color.Color.from_color(text_color)
elif python.is_string(text_color):
text_color = color.Color.from_string(text_color)
self._settings['textColor'] = text_color.to_string()
brush = QBrush()
brush.setColor(text_color)
self.setForeground(0, brush)
def drawSizeInfo(self):
sizeInfoAreaWidth = 200
sizeInfoAreaHeight = 30
spacing = 5
rect = self.selectedArea.normalized()
sizeInfoArea = QRect(rect.left(),
rect.top() - spacing - sizeInfoAreaHeight,
sizeInfoAreaWidth, sizeInfoAreaHeight)
if sizeInfoArea.top() < 0:
sizeInfoArea.moveTopLeft(rect.topLeft() + QPoint(spacing, spacing))
if sizeInfoArea.right() >= self.screenPixel.width():
sizeInfoArea.moveTopLeft(rect.topLeft() -
QPoint(spacing, spacing) -
QPoint(sizeInfoAreaWidth, 0))
if sizeInfoArea.left() < spacing:
sizeInfoArea.moveLeft(spacing)
if sizeInfoArea.top() < spacing:
sizeInfoArea.moveTop(spacing)
self.itemsToRemove.append(
self.graphicsScene.addRect(QRectF(sizeInfoArea), QPen(Qt.white),
QBrush(Qt.black)))
sizeInfo = self.graphicsScene.addSimpleText(' {0} x {1}'.format(
rect.width() * self.scale,
rect.height() * self.scale))
sizeInfo.setPos(sizeInfoArea.topLeft() + QPoint(0, 2))
sizeInfo.setPen(QPen(QColor(255, 255, 255), 2))
self.itemsToRemove.append(sizeInfo)
def paint_background(self, painter, option, index):
"""
Overrides base paint_background icon function
Draw the background for the item
:param painter: QPainter
:param option: QStyleOptionViewItem
:param index: QModelIndex
"""
super(GroupDataItemView, self).paint_background(painter, option, index)
painter.setPen(QPen(Qt.NoPen))
visual_rect = self.visualRect(option)
text = self.name()
metrics = QFontMetrics(self._font)
text_width = metrics.width(text)
padding = (25 * self.dpi())
visual_rect.setX(text_width + padding)
visual_rect.setY(visual_rect.y() + (visual_rect.height() / 2))
visual_rect.setHeight(2 * self.dpi())
visual_rect.setWidth(visual_rect.width() - padding)
color = QColor(self.text_color().red(),
self.text_color().green(),
self.text_color().blue(), 10)
painter.setBrush(QBrush(color))
painter.drawRect(visual_rect)
def paint_blend_slider(self, painter, option, index):
if not self.PAINT_SLIDER or not self.viewer().is_icon_view():
return
painter.setPen(QPen(Qt.NoPen))
rect = self.visual_rect(option)
color = self.viewer().background_color().toRgb()
color.setAlpha(75)
painter.setBrush(QBrush(color))
height = rect.height()
ratio = self.blend_value()
if ratio < 0:
width = 0
elif ratio > 100:
width = rect.width()
else:
width = rect.width() * (float(ratio) / 100)
rect.setWidth(width)
rect.setHeight(height)
rect = self.visual_rect(option)
rect.setY(rect.y() + (4 * self.dpi()))
color = self.viewer().text_color().toRgb()
color.setAlpha(220)
pen = QPen(color)
align = Qt.AlignTop | Qt.AlignHCenter
painter.setPen(pen)
painter.drawText(rect, align, str(self.blend_value()) + "%")
def paint_playhead(self, painter, option):
"""
Pain the playhead if the item has an image sequence
:param painter: QPainter
:param option: QStyleOptionViewItem
"""
image_sequence = self.image_sequence()
if image_sequence and self.under_mouse():
count = image_sequence.frame_count()
current = image_sequence.current_frame_number()
if count > 0:
percent = float((count + current) + 1) / count - 1
else:
percent = 0
icon_rect = self.icon_rect(option)
playhead_color = self.playhead_color()
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(playhead_color))
if percent <= 0:
width = 0
elif percent >= 1:
width = icon_rect.width()
else:
width = (percent * icon_rect.width()) - 1
height = 3 * self.dpi()
y = icon_rect.y() + icon_rect.height() - (height - 1)
painter.drawRect(icon_rect.x(), y, width, height)
def paint_background(self, painter, option, index):
"""
Draw the background for the item
:param painter: QPainter
:param option: QStyleOptionViewItem
:param index:QModelIndex
"""
is_selected = option.state & QStyle.State_Selected
is_mouse_over = option.state & QStyle.State_MouseOver
painter.setPen(QPen(Qt.NoPen))
visual_rect = self.visual_rect(option)
if is_selected:
color = self.background_selected_color()
elif is_mouse_over:
color = self.background_hover_color()
else:
color = self.backgroundColor()
painter.setBrush(QBrush(color))
if not self.viewer().is_icon_view():
spacing = 1 * self.dpi()
height = visual_rect.height() - spacing
visual_rect.setHeight(height)
painter.drawRect(visual_rect)
def __init__(self, parent=None):
super(GridBackgroundImageView, self).__init__(parent=parent)
self._background_image = None
self._background_image_path = None
self._fit_image_to_window = False
self.setBackgroundBrush(QBrush(QColor(70, 70, 70, 255)))
def get_style(self, color, bold=False):
brush = QBrush(QColor(*color))
f = QTextCharFormat()
if bold:
f.setFontWeight(QFont.Bold)
f.setForeground(brush)
return f
def paintEvent(self, event):
painter = QPainter(self)
if self._is_expanded:
rect2 = event.rect()
rect2.setX(15)
rect2.setWidth(1)
painter.fillRect(rect2, QBrush(QColor(87, 87, 87)))
def __drawTriangle(self, painter, x, y):
if self.rolloutStyle() == ExpanderStyles.Maya:
brush = QBrush(QColor(255, 0, 0, 160), Qt.SolidPattern)
else:
brush = QBrush(QColor(255, 255, 255, 160), Qt.SolidPattern)
if not self.isCollapsed():
tl, tr, tp = QPoint(x + 9, y + 8), QPoint(x + 19, y + 8), QPoint(x + 14, y + 13)
points = [tl, tr, tp]
triangle = QPolygon(points)
else:
tl, tr, tp = QPoint(x + 11, y + 5), QPoint(x + 16, y + 10), QPoint(x + 11, y + 15)
points = [tl, tr, tp]
triangle = QPolygon(points)
currentPen = painter.pen()
currentBrush = painter.brush()
painter.setPen(Qt.NoPen)
painter.setBrush(brush)
painter.drawPolygon(triangle)
painter.setPen(currentPen)
painter.setBrush(currentBrush)
def create_rubber_band(self):
"""
Creates a new instance of the selection rubber band
:return: QRubberBand
"""
rubber_band = QRubberBand(QRubberBand.Rectangle, self)
palette = QPalette()
color = self.rubber_band_color()
palette.setBrush(QPalette.Highlight, QBrush(color))
rubber_band.setPalette(palette)
return rubber_band
def _draw_triangle(self, painter, x, y):
if self.rollout_style == AccordionStyle.MAYA:
brush = QBrush(QColor(255, 0, 0, 160), Qt.SolidPattern)
else:
brush = QBrush(QColor(255, 255, 255, 160), Qt.SolidPattern)
if not self.is_collapsed():
tl, tr, tp = QPoint(x + 9, y + 8), QPoint(x + 19, y + 8), QPoint(x + 14, y + 13.0)
points = [tl, tr, tp]
triangle = QPolygon(points)
else:
tl, tr, tp = QPoint(x + 11, y + 6), QPoint(x + 16, y + 11), QPoint(x + 11, y + 16.0)
points = [tl, tr, tp]
triangle = QPolygon(points)
current_pen = painter.pen()
current_brush = painter.brush()
painter.setPen(Qt.NoPen)
painter.setBrush(brush)
painter.drawPolygon(triangle)
painter.setPen(current_pen)
painter.setBrush(current_brush)
def __init__(self, parent, system):
super(SystemTreeWidgetItem,
self).__init__(parent,
[system.key(), system.type()])
self._system = None
self.setSystem(system)
color = COLOR_BUILT if self._system.isBuilt() else COLOR_DEFAULT
self.setForeground(0, QBrush(color))
if system.settings()["location"] == "X":
SubSystemTreeWidgetItem(self, system, location="L")
SubSystemTreeWidgetItem(self, system, location="R")
def paintEvent(self, event):
contents_y = self.editor.verticalScrollBar().value()
page_bottom = contents_y + self.editor.viewport().height()
font_metrics = self.fontMetrics()
current_block = self.editor.document().findBlock(
self.editor.textCursor().position())
painter = QPainter(self)
line_count = 0
# Iterate over all text blocks in the document
block = self.editor.document().begin()
font_size = self.editor.font().pointSize()
font = painter.font()
font.setPixelSize(font_size)
offset = font_metrics.ascent() + font_metrics.descent()
color = painter.pen().color()
painter.setFont(font)
align = Qt.AlignRight
while block.isValid():
line_count += 1
# Get top left position of the block in the document and check if the position of the block is
# outside of the visible area
position = self.editor.document().documentLayout(
).blockBoundingRect(block).topLeft()
if position.y() == page_bottom:
break
rect = QRect(0,
round(position.y()) - contents_y,
self.width() - 5, font_size + offset)
# Draw line rect
if block == current_block:
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(self.bg))
painter.drawRect(
QRect(0,
round(position.y()) - contents_y, self.width(),
font_size + (offset / 2)))
painter.setPen(QPen(color))
# Draw text
painter.drawText(rect, align, str(line_count))
block = block.next()
self.highest_line = line_count
painter.end()
super(ScriptEditorNumberBar, self).paintEvent(event)
def __init__(self, parent, layer):
super(LayerTreeWidgetItem, self).__init__(parent, [layer.name()])
self._layer = layer
self.setExpanded(self._layer.settings()["expanded"])
sortedSubLayers = sorted(layer.layers().items(), key=lambda x: x[0])
for subName, subLayer in sortedSubLayers:
LayerTreeWidgetItem(self, subLayer)
sortedSystems = sorted(layer.systems().items(), key=lambda x: x[0])
for key, system in sortedSystems:
item = SystemTreeWidgetItem(self, system)
color = COLOR_BUILT if self.isBuilt() else COLOR_DEFAULT
self.setForeground(0, QBrush(color))
def paintEvent(self, event):
super(CommandButton, self).paintEvent(event)
if self.has_menu:
painter = QPainter()
painter.begin(self)
brush = QBrush(QColor(self.theme().accent_color))
painter.setRenderHint(painter.Antialiasing)
painter.setBrush(brush)
painter.setPen(Qt.NoPen)
w = self.rect().width() - 1
h = self.rect().height() - 1
polygon = QPolygon()
polygon.append(QPoint(w - 1, h - 8))
polygon.append(QPoint(w - 8, h - 1))
polygon.append(QPoint(w - 1, h - 1))
painter.drawPolygon(polygon)
def _draw_triangle(self, painter, x, y):
brush = QBrush(QColor(255, 255, 255, 160), Qt.SolidPattern)
if not self.is_collapsed():
tl, tr, tp = QPoint(x + 9, y + 8), QPoint(x + 19, y + 8), QPoint(
x + 14, y + 13.0)
points = [tl, tr, tp]
triangle = QPolygon(points)
else:
tl, tr, tp = QPoint(x + 11, y + 6), QPoint(x + 16, y + 11), QPoint(
x + 11, y + 16.0)
points = [tl, tr, tp]
triangle = QPolygon(points)
current_brush = painter.brush()
painter.setBrush(brush)
painter.drawPolygon(triangle)
painter.setBrush(current_brush)
def drawArrow(self, x1, x2, y1, y2, result):
rect = self.selectedArea.normalized()
if y1 <= rect.left():
y1 = rect.left()
elif y1 >= rect.right():
y1 = rect.right()
if y2 <= rect.top():
y2 = rect.top()
elif y2 >= rect.bottom():
y2 = rect.bottom()
tmp = [
ACTION_ARROW, x1, x2, y1, y2,
QPen(QColor(self.penColorNow), int(self.penSizeNow)),
QBrush(QColor(self.penColorNow))
]
if result:
self.drawListResult.append(tmp)
else:
self.drawListProcess = tmp
def paintEvent(self, event):
"""
Overrides base QToolButton paintEvent function
Triggered on frame changed
:param event: QEvent
"""
super(ImageSequenceWidget, self).paintEvent(event)
painter = QPainter()
painter.begin(self)
if self.current_filename() and self._image_sequence.frame_count() > 1:
r = event.rect()
playhead_height = self.playhead_height()
playhead_pos = self._image_sequence.percent() * r.width() - 1
x = r.x()
y = self.height() - playhead_height
painter.seten(Qt.NoPen)
painter.setBrush(QBrush(self.DEFAULT_PLAYHEAD_COLOR))
painter.drawRect(x, y, playhead_pos, playhead_height)
painter.end()
def _paint_drop_indicator(self, painter):
"""
Internal function used to paint the drop indicator manually
:param painter: QPainter
"""
if self.state() == QAbstractItemView.DraggingState:
opt = QStyleOption()
opt.initFrom(self)
opt.rect = self._drop_indicator_rect
rect = opt.rect
color = Qt.black
if dcc.is_maya():
color = Qt.white
brush = QBrush(QColor(color))
pen = QPen(brush, 1, Qt.DotLine)
painter.setPen(pen)
if rect.height() == 0:
painter.drawLine(rect.topLeft(), rect.topRight())
else:
painter.drawRect(rect)
def drawMagnifier(self):
# First, calculate the magnifier position due to the mouse position
watchAreaWidth = 16
watchAreaHeight = 16
watchAreaPixmap = QPixmap()
cursor_pos = self.mousePoint
watchArea = QRect(
QPoint(cursor_pos.x() - watchAreaWidth / 2,
cursor_pos.y() - watchAreaHeight / 2),
QPoint(cursor_pos.x() + watchAreaWidth / 2,
cursor_pos.y() + watchAreaHeight / 2))
if watchArea.left() < 0:
watchArea.moveLeft(0)
watchArea.moveRight(watchAreaWidth)
if self.mousePoint.x() + watchAreaWidth / 2 >= self.screenPixel.width(
):
watchArea.moveRight(self.screenPixel.width() - 1)
watchArea.moveLeft(watchArea.right() - watchAreaWidth)
if self.mousePoint.y() - watchAreaHeight / 2 < 0:
watchArea.moveTop(0)
watchArea.moveBottom(watchAreaHeight)
if self.mousePoint.y(
) + watchAreaHeight / 2 >= self.screenPixel.height():
watchArea.moveBottom(self.screenPixel.height() - 1)
watchArea.moveTop(watchArea.bottom() - watchAreaHeight)
# tricks to solve the hidpi impact on QCursor.pos()
watchArea.setTopLeft(
QPoint(watchArea.topLeft().x() * self.scale,
watchArea.topLeft().y() * self.scale))
watchArea.setBottomRight(
QPoint(watchArea.bottomRight().x() * self.scale,
watchArea.bottomRight().y() * self.scale))
watchAreaPixmap = self.screenPixel.copy(watchArea)
# second, calculate the magnifier area
magnifierAreaWidth = watchAreaWidth * 10
magnifierAreaHeight = watchAreaHeight * 10
fontAreaHeight = 40
cursorSize = 24
magnifierArea = QRectF(
QPoint(QCursor.pos().x() + cursorSize,
QCursor.pos().y() + cursorSize),
QPoint(QCursor.pos().x() + cursorSize + magnifierAreaWidth,
QCursor.pos().y() + cursorSize + magnifierAreaHeight))
if magnifierArea.right() >= self.screenPixel.width():
magnifierArea.moveLeft(QCursor.pos().x() - magnifierAreaWidth -
cursorSize / 2)
if magnifierArea.bottom() + fontAreaHeight >= self.screenPixel.height(
):
magnifierArea.moveTop(QCursor.pos().y() - magnifierAreaHeight -
cursorSize / 2 - fontAreaHeight)
# third, draw the watch area to magnifier area
watchAreaScaled = watchAreaPixmap.scaled(
QSize(magnifierAreaWidth * self.scale,
magnifierAreaHeight * self.scale))
magnifierPixmap = self.graphicsScene.addPixmap(watchAreaScaled)
magnifierPixmap.setOffset(magnifierArea.topLeft())
# then draw lines and text
self.graphicsScene.addRect(QRectF(magnifierArea),
QPen(QColor(255, 255, 255), 2))
self.graphicsScene.addLine(
QLineF(QPointF(magnifierArea.center().x(), magnifierArea.top()),
QPointF(magnifierArea.center().x(),
magnifierArea.bottom())),
QPen(QColor(0, 255, 255), 2))
self.graphicsScene.addLine(
QLineF(QPointF(magnifierArea.left(),
magnifierArea.center().y()),
QPointF(magnifierArea.right(),
magnifierArea.center().y())),
QPen(QColor(0, 255, 255), 2))
# get the rgb of mouse point
pointRgb = QColor(self.screenPixel.toImage().pixel(self.mousePoint))
# draw information
self.graphicsScene.addRect(
QRectF(
magnifierArea.bottomLeft(),
magnifierArea.bottomRight() + QPoint(0, fontAreaHeight + 30)),
QPen(Qt.black), QBrush(Qt.black))
rgbInfo = self.graphicsScene.addSimpleText(
' Rgb: ({0}, {1}, {2})'.format(pointRgb.red(), pointRgb.green(),
pointRgb.blue()))
rgbInfo.setPos(magnifierArea.bottomLeft() + QPoint(0, 5))
rgbInfo.setPen(QPen(QColor(255, 255, 255), 2))
rect = self.selectedArea.normalized()
sizeInfo = self.graphicsScene.addSimpleText(' Size: {0} x {1}'.format(
rect.width() * self.scale,
rect.height() * self.scale))
sizeInfo.setPos(magnifierArea.bottomLeft() + QPoint(0, 15) +
QPoint(0, fontAreaHeight / 2))
sizeInfo.setPen(QPen(QColor(255, 255, 255), 2))
class BaseAnimObject(object):
_glow_pens = {}
for index in range(1, 11):
_glow_pens[index] = [QPen(QColor(0, 255, 0, 12 * index), 1, Qt.SolidLine),
QPen(QColor(0, 255, 0, 5 * index), 3, Qt.SolidLine),
QPen(QColor(0, 255, 0, 2 * index), 5, Qt.SolidLine),
QPen(QColor(0, 255, 0, 25.5 * index), 1, Qt.SolidLine)]
_pens_text = QPen(QColor(202, 207, 210), 1, Qt.SolidLine)
_pens_shadow = QPen(QColor(9, 10, 12), 1, Qt.SolidLine)
_pens_border = QPen(QColor(9, 10, 12), 2, Qt.SolidLine)
_pens_clear = QPen(QColor(0, 0, 0, 0), 1, Qt.SolidLine)
_pens_text_disabled = QPen(QColor(102, 107, 110), 1, Qt.SolidLine)
_pens_shadow_disabled = QPen(QColor(0, 0, 0), 1, Qt.SolidLine)
_brush_clear = QBrush(QColor(0, 0, 0, 0))
_brush_border = QBrush(QColor(9, 10, 12))
def __init__(self):
font = QFont()
font.setPointSize(8)
font.setFamily("Calibri")
self.setFont(font)
self._hover = False
self._glow_index = 0
self._anim_timer = QTimer()
self._anim_timer.timeout.connect(self._animate_glow)
def enterEvent(self, event):
super(self.__class__, self).enterEvent(event)
if not self.isEnabled():
return
self._hover = True
self._start_anim()
def leaveEvent(self, event):
super(self.__class__, self).leaveEvent(event)
if not self.isEnabled():
return
self._hover = False
self._start_anim()
def _animate_glow(self):
if self._hover:
if self._glow_index >= 10:
self._glow_index = 10
self._anim_timer.stop()
else:
self._glow_index += 1
else:
if self._glow_index <= 0:
self._glow_index = 0
self._anim_timer.stop()
else:
self._glow_index -= 1
dcc.execute_deferred(self.update)
def _start_anim(self):
if self._anim_timer.isActive():
return
self._anim_timer.start(20)
def __init__(self, name):
super(RubberRect, self).__init__()
self._name = name
self.setZValue(2)
self.setPen(QPen(self.DEFAULT_RUBBER_RECT_COLOR, 0.5, Qt.SolidLine))
self.setBrush(QBrush(self.DEFAULT_RUBBER_RECT_COLOR))
class CurveNodeItem(QGraphicsItem, object):
curveUpdated = Signal()
WIDTH = 10
def __init__(self, rect=None, parent=None):
self.signals = CurveNodeItemSignals()
gradient = QRadialGradient(
self.WIDTH * 0.75, self.WIDTH * 0.75, self.WIDTH * 0.75, self.WIDTH * 0.75, self.WIDTH * 0.75)
gradient.setColorAt(0, self.theme().accent_color_6 if self.theme() else QColor.fromRgbF(1, 0.5, 0.01, 1))
gradient.setColorAt(1, self.theme().accent_color_8 if self.theme() else QColor.fromRgbF(1, 0.6, 0.06, 1))
self._brush = QBrush(gradient)
self._brush.setStyle(Qt.RadialGradientPattern)
self._pen = QPen()
self._pen.setStyle(Qt.SolidLine)
self._pen.setWidth(2)
self._pen.setColor(self.theme().accent_color if self.theme() else QColor(104, 104, 104, 255))
self._selected_pen = QPen()
self._selected_pen.setStyle(Qt.SolidLine)
self._selected_pen.setWidth(3)
self._selected_pen.setColor(self.theme().accent_color_4 if self.theme() else QColor(67, 255, 163, 255))
super(CurveNodeItem, self).__init__(parent)
self._lock_x_pos = False
self._snap = False
self._current_pos = None
self._new_pos = None
self._line = None
self._is_point1 = False
self.set_rect(rect if rect else QRect(0, 0, 10, 10))
self.setFlags(
QGraphicsItem.ItemIsMovable | QGraphicsItem.ItemIsSelectable | QGraphicsItem.ItemSendsScenePositionChanges)
@property
def snap(self):
return self._snap
@snap.setter
def snap(self, flag):
self._snap = bool(flag)
@property
def lock_x_pos(self):
return self._lock_x_pos
@lock_x_pos.setter
def lock_x_pos(self, value):
self._lock_x_pos = value
def boundingRect(self):
return QRectF(0, 0, 20, 20)
def paint(self, painter, option, widget):
painter.setBrush(self._brush)
painter.setPen(self._selected_pen if self.isSelected() else self._pen)
painter.drawEllipse(self._rect)
def mousePressEvent(self, event):
self._current_pos = self.pos()
super(CurveNodeItem, self).mousePressEvent(event)
def mouseMoveEvent(self, event):
super(CurveNodeItem, self).mouseMoveEvent(event)
curve_offset = -self.WIDTH * 0.5
scale_x = min(max(event.scenePos().x(), curve_offset), self.scene().base_size + curve_offset)
scale_y = min(max(event.scenePos().y(), curve_offset), self.scene().base_size + curve_offset)
if self._lock_x_pos:
scale_x = self._lock_x_pos
if self._snap is not False:
scale_x = round((float(scale_x) / self._snap)) * self._snap
scale_y = round((float(scale_y) / self._snap)) * self._snap
self._new_pos = QPointF(scale_x, scale_y)
self.setPos(self._new_pos)
self.scene().update_curve()
self.signals.curveUpdated.emit()
def mouseReleaseEvent(self, event):
super(CurveNodeItem, self).mouseReleaseEvent(event)
if not self._new_pos:
return
self.scene().undo_stack.push(CurveNodeMoveUndoCommand(self.scene(), self, self._current_pos, self._new_pos))
self._new_pos = None
def itemChange(self, change, value):
if change == self.ItemPositionChange and self.scene():
new_pos = value
self._move_line_to_center(new_pos)
return super(CurveNodeItem, self).itemChange(change, value)
def set_rect(self, rect):
self._rect = rect
self.update()
def add_line(self, line, is_point1):
self._line = line
self._is_point1 = is_point1
self._move_line_to_center(self.pos())
def _move_line_to_center(self, new_pos):
if not self._line:
return
x_offset = self._rect.x() - self._rect.width() / 2
y_offset = self._rect.y() - self._rect.height() / 2
new_center_pos = QPointF(new_pos.x() - x_offset, new_pos.y() - y_offset)
p1 = new_center_pos if self._is_point1 else self._line.line().p1()
p2 = self._line.line().p2() if self._is_point1 else new_center_pos
self._line.setLine(QLineF(p1, p2))
def drawOneStep(self, step):
"""
:type step: tuple
"""
if step[0] == ACTION_RECT:
self.graphicsScene.addRect(
QRectF(QPointF(step[1], step[2]), QPointF(step[3], step[4])),
step[5])
elif step[0] == ACTION_ELLIPSE:
self.graphicsScene.addEllipse(
QRectF(QPointF(step[1], step[2]), QPointF(step[3], step[4])),
step[5])
elif step[0] == ACTION_ARROW:
arrow = QPolygonF()
linex = float(step[1] - step[3])
liney = float(step[2] - step[4])
line = sqrt(pow(linex, 2) + pow(liney, 2))
# in case to divided by 0
if line == 0:
return
sinAngel = liney / line
cosAngel = linex / line
# sideLength is the length of bottom side of the body of an arrow
# arrowSize is the size of the head of an arrow, left and right
# sides' size is arrowSize, and the bottom side's size is arrowSize / 2
sideLength = step[5].width()
arrowSize = 8
bottomSize = arrowSize / 2
tmpPoint = QPointF(step[3] + arrowSize * sideLength * cosAngel,
step[4] + arrowSize * sideLength * sinAngel)
point1 = QPointF(step[1] + sideLength * sinAngel,
step[2] - sideLength * cosAngel)
point2 = QPointF(step[1] - sideLength * sinAngel,
step[2] + sideLength * cosAngel)
point3 = QPointF(tmpPoint.x() - sideLength * sinAngel,
tmpPoint.y() + sideLength * cosAngel)
point4 = QPointF(tmpPoint.x() - bottomSize * sideLength * sinAngel,
tmpPoint.y() + bottomSize * sideLength * cosAngel)
point5 = QPointF(step[3], step[4])
point6 = QPointF(tmpPoint.x() + bottomSize * sideLength * sinAngel,
tmpPoint.y() - bottomSize * sideLength * cosAngel)
point7 = QPointF(tmpPoint.x() + sideLength * sinAngel,
tmpPoint.y() - sideLength * cosAngel)
arrow.append(point1)
arrow.append(point2)
arrow.append(point3)
arrow.append(point4)
arrow.append(point5)
arrow.append(point6)
arrow.append(point7)
arrow.append(point1)
self.graphicsScene.addPolygon(arrow, step[5], step[6])
elif step[0] == ACTION_LINE:
self.graphicsScene.addLine(
QLineF(QPointF(step[1], step[2]), QPointF(step[3], step[4])),
step[5])
elif step[0] == ACTION_FREEPEN:
self.graphicsScene.addPath(step[1], step[2])
elif step[0] == ACTION_TEXT:
textAdd = self.graphicsScene.addSimpleText(step[1], step[2])
textAdd.setPos(step[3])
textAdd.setBrush(QBrush(step[4]))
self.textRect = textAdd.boundingRect()
class BaseButtonStyle(object):
_gradient = {NORMAL: {}, DOWN: {}, DISABLED: {}}
inner_gradient = QLinearGradient(0, 3, 0, 24)
inner_gradient.setColorAt(0, QColor(53, 57, 60))
inner_gradient.setColorAt(1, QColor(33, 34, 36))
_gradient[NORMAL][INNER] = QBrush(inner_gradient)
outer_gradient = QLinearGradient(0, 2, 0, 25)
outer_gradient.setColorAt(0, QColor(69, 73, 76))
outer_gradient.setColorAt(1, QColor(17, 18, 20))
_gradient[NORMAL][OUTER] = QBrush(outer_gradient)
inner_gradient_down = QLinearGradient(0, 3, 0, 24)
inner_gradient_down.setColorAt(0, QColor(20, 21, 23))
inner_gradient_down.setColorAt(1, QColor(48, 49, 51))
_gradient[DOWN][INNER] = QBrush(inner_gradient_down)
outer_gradient_down = QLinearGradient(0, 2, 0, 25)
outer_gradient_down.setColorAt(0, QColor(36, 37, 39))
outer_gradient_down.setColorAt(1, QColor(32, 33, 35))
_gradient[DOWN][OUTER] = QBrush(outer_gradient_down)
inner_gradient_disabled = QLinearGradient(0, 3, 0, 24)
inner_gradient_disabled.setColorAt(0, QColor(33, 37, 40))
inner_gradient_disabled.setColorAt(1, QColor(13, 14, 16))
_gradient[DISABLED][INNER] = QBrush(inner_gradient_disabled)
outer_gradient_disabled = QLinearGradient(0, 2, 0, 25)
outer_gradient_disabled.setColorAt(0, QColor(49, 53, 56))
outer_gradient_disabled.setColorAt(1, QColor(9, 10, 12))
_gradient[DISABLED][OUTER] = QBrush(outer_gradient_disabled)
@staticmethod
def paintEvent(base_button, event):
painter = QStylePainter(base_button)
painter.setRenderHint(QPainter.Antialiasing)
option = QStyleOption()
option.initFrom(base_button)
x = option.rect.x()
y = option.rect.y()
height = option.rect.height() - 1
width = option.rect.width() - 1
radius = base_button._radius
gradient = BaseButtonStyle._gradient[NORMAL]
offset = 0
if base_button.isDown():
gradient = BaseButtonStyle._gradient[DOWN]
offset = 1
elif not base_button.isEnabled():
gradient = BaseButtonStyle._gradient[DISABLED]
painter.setBrush(base_button._brush_border)
painter.setPen(base_button._pens_border)
painter.drawRoundedRect(QRect(x + 1, y + 1, width - 1, height - 1),
radius, radius)
painter.setPen(base_button._pens_clear)
painter.setBrush(gradient[OUTER])
painter.drawRoundedRect(QRect(x + 2, y + 2, width - 3, height - 3),
radius, radius)
painter.setBrush(gradient[INNER])
painter.drawRoundedRect(QRect(x + 3, y + 3, width - 5, height - 5),
radius - 1, radius - 1)
painter.setBrush(base_button._brush_clear)
text = base_button.text()
font = base_button.font()
text_width = base_button._font_metrics.width(text)
text_height = font.pointSize()
text_path = QPainterPath()
text_path.addText((width - text_width) / 2,
height - ((height - text_height) / 2) - 1 + offset,
font, text)
glow_index = base_button._glow_index
glow_pens = base_button._glow_pens
alignment = (Qt.AlignHCenter | Qt.AlignVCenter)
if base_button.isEnabled():
painter.setPen(base_button._pens_shadow)
painter.drawPath(text_path)
painter.setPen(base_button._pens_text)
painter.drawText(x, y + offset, width, height, alignment, text)
if glow_index > 0:
for index in range(3):
painter.setPen(glow_pens[glow_index][index])
painter.drawPath(text_path)
painter.setPen(glow_pens[glow_index][3])
painter.drawText(x, y + offset, width, height, alignment, text)
else:
painter.setPen(base_button._pens_shadow_disabled)
painter.drawPath(text_path)
painter.setPen(base_button._pens_text_disabled)
painter.drawText(x, y + offset, width, height, alignment, text)