def eventFilter(self, object, event):
if event.type() == QtCore.QEvent.MouseButtonPress:
self._value = 0
self.valueLabel.setText(str(self._value))
self.startDragpos = event.pos()
self._startValue = self.parent._value
if event.type() == QtCore.QEvent.HoverEnter:
self._value = 0
self.startDragpos = self.mapToGlobal(event.pos())
self.setStyleSheet(editableStyleSheet().getSliderStyleSheet(
"dragerstyleSheetHover"))
self.parent.activeDrag = self
for drag in self.parent.drags:
if drag != self:
drag.setStyleSheet(
editableStyleSheet().getSliderStyleSheet(
"dragerstyleSheet"))
if event.type() == QtCore.QEvent.HoverLeave:
self._value = 0
self.startDragpos = self.mapToGlobal(event.pos())
if event.pos().y() > self.height() or event.pos().y() < 0:
self.setStyleSheet(editableStyleSheet().getSliderStyleSheet(
"dragerstyleSheet"))
return False
def paint(self, painter, option, widget):
option.state &= ~QStyle.State_Selected
lod = self.canvasRef().getCanvasLodValueFromCurrentScale()
self.setPen(self.pen)
p1, p2 = self.getEndPoints()
if editableStyleSheet().ConnectionMode[0] in [ConnectionTypes.Circuit,ConnectionTypes.ComplexCircuit]:
sameSide = 0
offset = 15
roundnes = editableStyleSheet().ConnectionRoundness[0]
if self.destination().owningNode()._rawNode.__class__.__name__ in ["reroute", "rerouteExecs"]:
xDistance = p2.x() - p1.x()
if xDistance < 0:
p2, p1 = self.getEndPoints()
sameSide = 1
if self.source().owningNode()._rawNode.__class__.__name__ in ["reroute", "rerouteExecs"]:
p11, p22 = self.getEndPoints()
xDistance = p22.x() - p11.x()
if xDistance < 0:
sameSide = -1
p1, p2 = self.getEndPoints()
self.mPath = ConnectionPainter.BasicCircuit(p1, p2, offset, roundnes, sameSide,lod,editableStyleSheet().ConnectionMode[0]==ConnectionTypes.ComplexCircuit)
elif editableStyleSheet().ConnectionMode[0] == ConnectionTypes.Cubic:
self.mPath = ConnectionPainter.Cubic(p1, p2, 150,lod)
self.setPath(self.mPath)
super(UIConnection, self).paint(painter, option, widget)
def asCommentNode(node, painter, option, widget):
frame = QtCore.QRectF(QtCore.QPointF(0, 0), node.geometry().size())
painter.setPen(QtCore.Qt.NoPen)
painter.setBrush(QtCore.Qt.darkGray)
color = Colors.NodeBackgrounds
if node.isSelected():
color = color.lighter(150)
painter.setBrush(node.color)
pen = QtGui.QPen(QtCore.Qt.black, 0.75)
if option.state & QStyle.State_Selected:
pen.setColor(editableStyleSheet().MainColor)
pen.setStyle(QtCore.Qt.SolidLine)
painter.setPen(pen)
painter.drawRoundedRect(frame, node.roundness, node.roundness)
if option.state & QStyle.State_Selected:
pen.setColor(editableStyleSheet().MainColor)
pen.setStyle(node.optPenSelectedType)
pen.setWidth(pen.width() * 1.5)
painter.setPen(pen)
painter.setBrush(QtGui.QColor(0, 0, 0, 0))
painter.drawRoundedRect(frame, node.roundness, node.roundness)
painter.drawLine(frame.left() + 5, node.labelHeight,
frame.right() - 5, node.labelHeight)
NodePainter.drawResizeHandles(node, painter, option, widget)
"""CONVEX HULL TEST
def update(self):
for category in self.categoryPaths.values():
if not category.parent():
category.setBackground(0, editableStyleSheet().BgColorBright)
else:
category.setBackground(
0,
editableStyleSheet().BgColorBright.lighter(150))
super(NodeBoxTreeWidget, self).update()
def update(self):
if self.stypeSheetType == 0:
self.layout().setSpacing(0)
self.sld.setStyleSheet(
editableStyleSheet().getSliderStyleSheet("sliderStyleSheetA"))
elif self.stypeSheetType == 1:
self.sld.setStyleSheet(
editableStyleSheet().getSliderStyleSheet("sliderStyleSheetB"))
super(pyf_Slider, self).update()
def __init__(self, parent, type="float", style=0, name=None, *args):
super(pyf_Slider, self).__init__(parent=parent, *args)
self.parent = parent
self.setLayout(QtWidgets.QHBoxLayout())
self.input = valueBox(type=type)
self.input.setButtonSymbols(QtWidgets.QAbstractSpinBox.NoButtons)
self.type = type
if self.type == "int":
self.sld = slider()
else:
self.sld = doubleSlider()
self.layout().setContentsMargins(10, 0, 0, 0)
self.input.setContentsMargins(0, 0, 0, 0)
self.sld.setContentsMargins(0, 0, 0, 0)
self.label = None
if name:
self.label = QtWidgets.QLabel(name + " ")
self.layout().addWidget(self.label)
self.layout().addWidget(self.input)
self.layout().addWidget(self.sld)
h = 20
self.input.setMinimumWidth(50)
self.input.setMaximumWidth(50)
self.setMaximumHeight(h)
self.setMinimumHeight(h)
self.sld.setMaximumHeight(h)
self.sld.setMinimumHeight(h)
self.input.setMaximumHeight(h)
self.input.setMinimumHeight(h)
self.stypeSheetType = style
if self.stypeSheetType == 0:
self.layout().setSpacing(0)
self.sld.setStyleSheet(
editableStyleSheet().getSliderStyleSheet("sliderStyleSheetA"))
elif self.stypeSheetType == 1:
self.sld.setStyleSheet(
editableStyleSheet().getSliderStyleSheet("sliderStyleSheetB"))
if self.type == "int":
self.sld.valueChanged.connect(
lambda: self.setValue(self.sld.value()))
else:
self.sld.doubleValueChanged.connect(
lambda: self.setValue(self.sld.value()))
self.input.editingFinished.connect(
lambda: self.setValue(self.input.value()))
self._value = 0.0
self._dispMin = 0.0
self._dispMax = 1.0
self.setMinimum(-100.0)
self.setMaximum(100.0)
self.setDisplayMinimun(0)
self.setDisplayMaximum(1)
self.setValue(0.5)
def ChangeFloatingStyle(self, state):
if not state:
self.box.setStyleSheet(editableStyleSheet().getStyleSheet())
else:
self.box.setStyleSheet(
"""QGroupBox{
background-color: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
stop: 0 %s,
stop: 0.6 %s,
stop: 1.0 %s);}""" %
("rgba%s" % str(editableStyleSheet().ButtonsColor.getRgb()),
"rgba%s" % str(editableStyleSheet().BgColorBright.getRgb()),
"rgba%s" % str(editableStyleSheet().BgColorBright.getRgb())))
def eventFilter(self, object, event):
if event.type() == QtCore.QEvent.MouseMove:
if self.activeDrag:
self.activeDrag.setStyleSheet(
editableStyleSheet().getSliderStyleSheet(
"dragerstyleSheetHover"))
deltaX = self.activeDrag.mapToGlobal(
event.pos()).x() - self.activeDrag.startDragpos.x()
if event.pos().x() > self.activeDrag.width() or event.pos().x(
) < 0:
self.activeDrag._value = (deltaX /
8) * self.activeDrag._factor
self.activeDrag.valueLabel.setText(
str(self.initValue + self.activeDrag._value))
self.activeDrag.valueChanged.emit(
self.activeDrag._startValue + self.activeDrag._value)
else:
self.activeDrag._value = 0
self.activeDrag.valueLabel.setText(
str(self.initValue + self.activeDrag._value))
self.activeDrag.startDragpos = self.activeDrag.mapToGlobal(
event.pos())
self.activeDrag._startValue = self.activeDrag.parent._value
self.activeDrag.valueChanged.emit(0)
if event.type() == QtCore.QEvent.MouseButtonRelease:
self.hide()
self.parent().setValue(self._startValue + self._value)
self.parent().editingFinished.emit()
del (self)
return False
def Cubic(p1, p2, defOffset=150, lod=0):
SWITCH_LOD = editableStyleSheet().ConnectionSwitch[0]
mPath = QtGui.QPainterPath()
xDistance = p2.x() - p1.x()
vDistance = p2.y() - p1.y()
offset = abs(xDistance) * 0.5
if abs(xDistance) < defOffset:
offset = defOffset / 2
if abs(vDistance) < 20:
offset = abs(xDistance) * 0.3
mPath.moveTo(p1)
if lod >= SWITCH_LOD:
offset = 20
if xDistance < 0:
cp1 = QtCore.QPoint(p1.x() + offset, p1.y())
cp2 = QtCore.QPoint(p2.x() - offset, p2.y())
else:
cp2 = QtCore.QPoint(p2.x() - offset, p2.y())
cp1 = QtCore.QPoint(p1.x() + offset, p1.y())
if lod >= SWITCH_LOD:
mPath = ConnectionPainter.linearPath([p1, cp1, cp2, p2])
else:
mPath.cubicTo(cp1, cp2, p2)
return mPath
def getEndPoints(self):
p1 = self.drawSource.scenePos() + self.drawSource.pinCenter()
if self.sourcePositionOverride is not None:
p1 = self.sourcePositionOverride()
p2 = self.drawDestination.scenePos() + self.drawDestination.pinCenter()
if self.destinationPositionOverride is not None:
p2 = self.destinationPositionOverride()
if editableStyleSheet().ConnectionMode[0] in [
ConnectionTypes.Circuit, ConnectionTypes.ComplexCircuit
]:
self.sameSide = 0
p1n, p2n = p1, p2
xDistance = p2.x() - p1.x()
if self.destination().owningNode()._rawNode.__class__.__name__ in [
"reroute", "rerouteExecs"
]:
if xDistance < 0:
p2n, p1n = p1, p2
self.sameSide = 1
if self.source().owningNode()._rawNode.__class__.__name__ in [
"reroute", "rerouteExecs"
]:
if xDistance < 0:
p1n, p2n = p1, p2
self.sameSide = -1
p1, p2 = p1n, p2n
return p1, p2
def asRerouteNode(node, painter, option, widget):
color = node.color
color.setAlpha(255)
# if node.isSelected():
color = color.lighter(100)
if node.isTemp:
color = color.lighter(50)
color.setAlpha(50)
linearGrad = QtGui.QRadialGradient(QtCore.QPointF(40, 40), 300)
linearGrad.setColorAt(0, color)
linearGrad.setColorAt(1, color.lighter(180))
br = QtGui.QBrush(linearGrad)
painter.setBrush(br)
pen = QtGui.QPen(QtCore.Qt.black, 0.75)
width = pen.width()
if option.state & QStyle.State_Selected:
# pen.setColor(Colors.Yellow)
pen.setColor(editableStyleSheet().MainColor)
pen.setStyle(node.optPenSelectedType)
pen.setWidth(width * 1.5)
painter.setPen(pen)
painter.drawEllipse(node.boundingRect().center(),
node.drawRect.width() / 2,
node.drawRect.width() / 2)
def asArrayPin(pin, painter, option, widget):
lod = pin.owningNode().canvasRef().getCanvasLodValueFromCurrentScale()
SWITCH_LOD = editableStyleSheet().PinSwitch[0]
gridSize = 3
cellW = pin.pinSize / gridSize
cellH = pin.pinSize / gridSize
pinCenter = pin.pinCenter()
halfPinSize = pin.pinSize / 2
painter.setBrush(QtGui.QBrush(pin.color()))
painter.setPen(QtGui.QPen(QtCore.Qt.black, 0.2))
for row in range(gridSize):
for column in range(gridSize):
x = row * cellW + pinCenter.x() - halfPinSize
y = column * cellH + pinCenter.y() - halfPinSize
painter.drawRect(x, y, cellW, cellH)
if lod < SWITCH_LOD and not pin.bLabelHidden:
frame = QtCore.QRectF(QtCore.QPointF(0, 0), pin.geometry().size())
halfPinSize = pin.pinSize / 2
painter.setFont(pin._font)
textWidth = QtGui.QFontMetrics(painter.font()).width(
pin.displayName())
textHeight = QtGui.QFontMetrics(painter.font()).height()
x = 1 + pin.pinSize + halfPinSize
if pin.direction == PinDirection.Output:
x = frame.width() - textWidth - pin.pinSize - 1
yCenter = textHeight - textHeight / 3
painter.setPen(PinPainter._valuePinNamePen)
painter.drawText(x, yCenter, pin.name)
if pin.hovered:
painter.setPen(QtCore.Qt.NoPen)
painter.setBrush(QtGui.QColor(128, 128, 128, 30))
painter.drawRoundedRect(frame, 3, 3)
def asVariableGetter(node, painter, option, widget):
painter.setPen(QtCore.Qt.NoPen)
painter.setBrush(QtCore.Qt.darkGray)
color = node.color
if node.isSelected():
color = color.lighter(150)
linearGrad = QtGui.QRadialGradient(QtCore.QPointF(40, 40), 300)
linearGrad.setColorAt(0, color)
linearGrad.setColorAt(1, color.lighter(180))
br = QtGui.QBrush(linearGrad)
painter.setBrush(br)
pen = QtGui.QPen(QtCore.Qt.black, 0.5)
if option.state & QStyle.State_Selected:
pen.setColor(editableStyleSheet().MainColor)
pen.setStyle(node.optPenSelectedType)
painter.setPen(pen)
painter.drawRoundedRect(node.boundingRect(), node.roundness,
node.roundness)
painter.setFont(node.nodeNameFont)
painter.setPen(QtGui.QPen(QtCore.Qt.white, 0.5))
textRect = node.boundingRect()
textRect.setWidth(textRect.width() - 10)
painter.drawText(textRect,
QtCore.Qt.AlignCenter | QtCore.Qt.AlignVCenter,
node.var.name)
def insertNode(self,
nodeCategoryPath,
name,
doc=None,
libName=None,
bPyNode=False,
bCompoundNode=False):
nodePath = nodeCategoryPath.split('|')
categoryPath = ''
# walk from tree top to bottom, creating folders if needed
# also writing all paths in dict to avoid duplications
for folderId in range(0, len(nodePath)):
folderName = nodePath[folderId]
if folderId == 0:
categoryPath = folderName
if categoryPath not in self.categoryPaths:
rootFolderItem = QTreeWidgetItem(self)
rootFolderItem.bCategory = True
rootFolderItem.setFlags(QtCore.Qt.ItemIsEnabled)
rootFolderItem.setText(0, folderName)
rootFolderItem.setBackground(
folderId,
editableStyleSheet().BgColorBright)
self.categoryPaths[categoryPath] = rootFolderItem
else:
parentCategoryPath = categoryPath
categoryPath += '|{}'.format(folderName)
if categoryPath not in self.categoryPaths:
childCategoryItem = QTreeWidgetItem(
self.categoryPaths[parentCategoryPath])
childCategoryItem.setFlags(QtCore.Qt.ItemIsEnabled)
childCategoryItem.bCategory = True
childCategoryItem.setText(0, folderName)
childCategoryItem.setBackground(
0,
editableStyleSheet().BgColorBright.lighter(150))
self.categoryPaths[categoryPath] = childCategoryItem
# create node under constructed folder
# TODO: Subclass QTreeWidgetItem to not create dynamic attributes. Below code is ugly
nodeItem = QTreeWidgetItem(self.categoryPaths[categoryPath])
nodeItem.bCategory = False
nodeItem.bPyNode = bPyNode
nodeItem.bCompoundNode = bCompoundNode
nodeItem.setText(0, name)
nodeItem.libName = libName
nodeItem.docString = doc
return nodeItem
def saveThemeAs(self, fileName=None):
okPressed = True
if not fileName:
fileName, okPressed = QInputDialog.getText(self, "Get text", "Your name:", QLineEdit.Normal, "")
if okPressed and fileName != '':
data = editableStyleSheet().serialize()
with open(os.path.join(THEMES_PATH, fileName + ".json"), "w") as f:
json.dump(data, f, separators=(',', ':'))
self.onShow(fileName)
def __init__(self, parent=None):
super(ThemePreferences, self).__init__(parent)
self.content = QWidget()
self.layout = QVBoxLayout(self.content)
self.layout.setContentsMargins(1, 1, 1, 1)
self.layout.setSpacing(2)
self.setWidget(self.content)
self.currTheme = None
self.cbDrawGrid = QCheckBox()
self.cbDrawGrid.stateChanged.connect(lambda state: editableStyleSheet().setDrawGrid(bool(state)))
def BasicCircuit(p1,
p2,
offset=20,
roundnes=5,
sameSide=0,
lod=0,
complexLine=False):
SWITCH_LOD = editableStyleSheet().ConnectionSwitch[0]
offset1 = offset
offset2 = -offset
if sameSide == 1:
offset2 = offset
elif sameSide == -1:
offset1 = -offset
xDistance = (p2.x() + offset2 + roundnes) - (p1.x() + offset1 -
roundnes)
yDistance = p1.y() - p2.y()
midPointY = p2.y() + ((p1.y() - p2.y()) / 2)
path = []
path.append(p1)
if xDistance > 0 or sameSide == -1:
if abs(yDistance) > roundnes * 2:
path.append(QtCore.QPoint(p2.x() + offset2, p1.y()))
path.append(QtCore.QPoint(p2.x() + offset2, p2.y()))
path.append(p2)
else:
x = max(p1.x() + offset1, p2.x() + offset2 * 1.5)
if sameSide == 1:
x = min(p1.x() + offset1, p2.x() + offset2 * 1.5)
path.append(QtCore.QPoint(x, p1.y()))
path.append(QtCore.QPoint(p2.x() + offset2, p2.y()))
path.append(p2)
else:
path.append(QtCore.QPoint(p1.x() + offset1, p1.y()))
path.append(QtCore.QPoint(p1.x() + offset1, midPointY))
path.append(QtCore.QPoint(p2.x() + offset2, midPointY))
path.append(QtCore.QPoint(p2.x() + offset2, p2.y()))
path.append(p2)
if complexLine:
if xDistance > 0:
path = ConnectionPainter.chanferPath(path[:-1], offset)
path.append(p2)
else:
path.reverse()
path = ConnectionPainter.chanferPath(path[:-1], offset)
path.append(p1)
if lod >= SWITCH_LOD:
mPath = ConnectionPainter.linearPath(path)
else:
mPath = ConnectionPainter.roundCornersPath(path, roundnes)
return mPath
def __init__(self, parent, *args):
super(pyf_HueSlider, self).__init__(parent=parent, *args)
self.parent = parent
self.color = QtGui.QColor()
self.color.setHslF(0, 1, 0.5, 1)
self.defColor = self.color.name()
self.setStyleSheet(
editableStyleSheet().getSliderStyleSheet("sliderStyleSheetC"))
self.light = 0.5
self.setMinimum(0.0)
self.setMaximum(1.0)
def main():
import os
import sys
app = QtWidgets.QApplication(sys.argv)
app.setStyle(QtWidgets.QStyleFactory.create("plastique"))
ex = testWidg(None)
app.setStyleSheet(editableStyleSheet().getStyleSheet())
ex.show()
sys.exit(app.exec_())
def __init__(self,
parent,
color1=[0, 0, 0],
color2=[255, 255, 255],
*args):
super(pyf_GradientSlider, self).__init__(parent=parent, *args)
self.parent = parent
self.color1 = QtGui.QColor(color1[0], color1[1], color1[2])
self.color2 = QtGui.QColor(color2[0], color2[1], color2[2])
self.setMinimum(0.0)
self.setMaximum(1.0)
self.setStyleSheet(
editableStyleSheet().getSliderStyleSheet("sliderStyleSheetC"))
def __init__(self, type="float", buttons=False, *args, **kargs):
super(valueBox, self).__init__(*args, **kargs)
self.isFloat = type == "float"
if not self.isFloat:
self.setDecimals(0)
else:
self.setDecimals(4)
if not buttons:
self.setButtonSymbols(QtWidgets.QAbstractSpinBox.NoButtons)
self.setStyleSheet(
editableStyleSheet().getSliderStyleSheet("sliderStyleSheetA"))
self.lineEdit().installEventFilter(self)
self.installEventFilter(self)
def Linear(p1, p2, defOffset=150, roundness=5, lod=0):
SWITCH_LOD = editableStyleSheet().ConnectionSwitch[0]
cp1 = QtCore.QPointF(p1.x() + defOffset, p1.y())
cp2 = QtCore.QPointF(p2.x() - defOffset, p2.y())
if lod >= SWITCH_LOD:
mPath = ConnectionPainter.linearPath([p1, cp1, cp2, p2])
else:
mPath = ConnectionPainter.roundCornersPath([p1, cp1, cp2, p2],
roundness)
return mPath
def asValuePin(pin, painter, option, widget):
lod = pin.owningNode().canvasRef().getCanvasLodValueFromCurrentScale()
SWITCH_LOD = editableStyleSheet().PinSwitch[0]
frame = QtCore.QRectF(QtCore.QPointF(0, 0), pin.geometry().size())
w = frame.width() / 2
h = frame.height() / 2
halfPinSize = pin.pinSize / 2
if lod < SWITCH_LOD and not pin.bLabelHidden:
painter.setFont(pin._font)
textWidth = QtGui.QFontMetrics(painter.font()).width(
pin.displayName())
textHeight = QtGui.QFontMetrics(painter.font()).height()
x = 1 + pin.pinSize + halfPinSize
if pin.direction == PinDirection.Output:
x = frame.width() - textWidth - pin.pinSize - 1
yCenter = textHeight - textHeight / 3
painter.setPen(QtGui.QPen(pin.labelColor, 0.5,
QtCore.Qt.SolidLine))
painter.drawText(x, yCenter, pin.displayName())
pinCenter = pin.pinCenter()
radialGrad = QtGui.QRadialGradient(pinCenter.x(),
pinCenter.y() - 0.3,
halfPinSize * 0.8)
if not pin._rawPin.hasConnections():
radialGrad.setColorAt(0, pin.color().darker(280))
radialGrad.setColorAt(0.5, pin.color().darker(280))
radialGrad.setColorAt(0.65, pin.color().lighter(130))
radialGrad.setColorAt(1, pin.color().lighter(70))
else:
radialGrad.setColorAt(0, pin.color())
radialGrad.setColorAt(1, pin.color())
painter.setPen(QtCore.Qt.NoPen)
if pin.hovered:
radialGrad.setColorAt(1, pin.color().lighter(200))
painter.setBrush(QtGui.QColor(128, 128, 128, 30))
painter.drawRoundedRect(frame, 3, 3)
painter.setBrush(radialGrad)
painter.drawEllipse(pinCenter.x() - halfPinSize,
pinCenter.y() - halfPinSize, pin.pinSize,
pin.pinSize)
def paint(self, painter, option, widget):
option.state &= ~QStyle.State_Selected
lod = self.canvasRef().getCanvasLodValueFromCurrentScale()
self.setPen(self.pen)
p1, p2 = self.getEndPoints()
roundness = editableStyleSheet().ConnectionRoundness[0]
offset = editableStyleSheet().ConnectionOffset[0]
offset1 = offset
offset2 = -offset1
if self.sameSide == 1:
offset2 = offset1
elif self.sameSide == -1:
offset1 = offset2
xDistance = (p2.x() + offset2) - (p1.x() + offset1)
self.sShape = xDistance < 0
sectionPath = None
if editableStyleSheet().ConnectionMode[0] == ConnectionTypes.Circuit:
seg = self.hoverSegment if self.hoverSegment != -1 and self.linPath and self.pressedSegment == -1 else self.pressedSegment
self.mPath, self.linPath, sectionPath = ConnectionPainter.BasicCircuit(
p1, p2, offset, roundness, self.sameSide, lod, False,
self.vOffset, self.hOffsetL, self.vOffsetSShape, self.hOffsetR,
self.hOffsetRSShape, self.hOffsetLSShape, self.snapVToFirst,
self.snapVToSecond, seg)
elif editableStyleSheet(
).ConnectionMode[0] == ConnectionTypes.ComplexCircuit:
self.mPath, self.linPath, sectionPath = ConnectionPainter.BasicCircuit(
p1, p2, offset, roundness, self.sameSide, lod, True)
elif editableStyleSheet().ConnectionMode[0] == ConnectionTypes.Cubic:
self.mPath = ConnectionPainter.Cubic(p1, p2, 150, lod)
self.linPath = None
elif editableStyleSheet().ConnectionMode[0] == ConnectionTypes.Linear:
self.mPath = ConnectionPainter.Linear(p1, p2, offset, roundness,
lod)
self.linPath = None
if self.snapVToSecond and self.offsetting == 0:
self.vOffset = p2.y() - p1.y()
self.setPath(self.mPath)
super(UIConnection, self).paint(painter, option, widget)
pen = QtGui.QPen()
pen.setColor(editableStyleSheet().MainColor)
pen.setWidthF(self.thickness + (self.thickness / 1.5))
painter.setPen(pen)
if sectionPath:
painter.drawPath(sectionPath)
def mousePressEvent(self, event):
super(UIConnection, self).mousePressEvent(event)
t = self.percentageByPoint(event.scenePos(), self.mPath)
self.prevPos = event.pos()
if abs(self.mPath.slopeAtPercent(t * 0.01)) < 1:
self.offsetting = 1
else:
self.offsetting = 2
if self.linPath is not None:
tempPath = ConnectionPainter.linearPath(self.linPath)
t = self.percentageByPoint(event.scenePos(), tempPath)
segments = []
for i, pos in enumerate(self.linPath[:-1]):
t1 = self.percentageByPoint(pos, tempPath)
t2 = self.percentageByPoint(self.linPath[i + 1], tempPath)
segments.append([t1, t2])
for i, seg in enumerate(segments):
if t > seg[0] and t < seg[1]:
valid = []
if not self.sShape:
if self.snapVToFirst:
valid = [0, 1]
elif self.snapVToSecond:
valid = [1, 2]
else:
valid = [1, 2, 3]
else:
valid = [1, 2, 3]
if i in valid:
self.pressedSegment = i
else:
self.pressedSegment = -1
p1, p2 = self.getEndPoints()
offset1 = editableStyleSheet().ConnectionOffset[0]
offset2 = -offset1
if self.sameSide == 1:
offset2 = offset1
elif self.sameSide == -1:
offset1 = offset2
xDistance = (p2.x() + offset2) - (p1.x() + offset1)
self.sShape = xDistance < 0
event.accept()
def __init__(self, parent, *args):
super(pyf_timeline, self).__init__(parent=parent, *args)
self.parent = parent
self.cachedFrmaes = []
self.missingFrames = []
self.hover = False
self.hoverPos = None
self.PressPos = None
self.MovePos = None
self.setRange(0, 30)
self.origMax = self.maximum()
self.oriMin = self.minimum()
self.setOrientation(QtCore.Qt.Horizontal)
self.setStyleSheet(
editableStyleSheet().getSliderStyleSheet("timeStyleSheet"))
self.setMouseTracking(True)
self.setPageStep(1)
self.setMinimumSize(1, 40)
self.installEventFilter(self)
def asExecPin(pin, painter, option, widget):
lod = pin.owningNode().canvasRef().getCanvasLodValueFromCurrentScale()
SWITCH_LOD = editableStyleSheet().PinSwitch[0]
frame = QtCore.QRectF(QtCore.QPointF(0, 0), pin.geometry().size())
w = frame.width() / 2
h = frame.height() / 2
halfPinSize = pin.pinSize / 2
painter.setFont(pin._font)
painter.setPen(PinPainter._execPen)
if lod < SWITCH_LOD and not pin.bLabelHidden:
textWidth = QtGui.QFontMetrics(painter.font()).width(
pin.displayName())
textHeight = QtGui.QFontMetrics(painter.font()).height()
x = 1 + pin.pinSize + halfPinSize
if pin.direction == PinDirection.Output:
x = frame.width() - textWidth - pin.pinSize - 1
yCenter = textHeight - textHeight / 3
painter.setPen(QtGui.QPen(pin.labelColor, 0.5,
QtCore.Qt.SolidLine))
painter.drawText(x, yCenter, pin.displayName())
if pin._rawPin.hasConnections():
painter.setBrush(QtGui.QBrush(pin.color()))
else:
painter.setBrush(QtCore.Qt.NoBrush)
pinCenter = pin.pinCenter()
xOffset = pinCenter.x() - \
pin.pinSize if pin.direction == PinDirection.Input else pinCenter.x() - \
pin.pinSize * 0.8
arrow = QtGui.QPolygonF([
QtCore.QPointF(2, 0.0),
QtCore.QPointF(2 + pin.pinSize / 2.0, 0.0),
QtCore.QPointF(2 + pin.pinSize, pin.pinSize / 2.0),
QtCore.QPointF(2 + pin.pinSize / 2.0, pin.pinSize),
QtCore.QPointF(2, pin.pinSize)
]).translated(xOffset, 1)
painter.drawPolygon(arrow)
if pin.hovered:
painter.setPen(QtCore.Qt.NoPen)
painter.setBrush(QtGui.QColor(128, 128, 128, 30))
painter.drawRoundedRect(frame, 3, 3)
def drawResizeHandles(node, painter, option, widget):
if node.resizable and not node.collapsed:
pen = QtGui.QPen()
height = node.geometry().height()
width = node.geometry().width()
rf = node.roundness * 2
pen.setColor(editableStyleSheet().MainColor)
pen.setStyle(node.optPenSelectedType)
painter.setPen(pen)
# left strip
if node.resizeStrips[0]:
painter.drawLine(0, rf / 2, 0, height - rf / 2)
# top strip
if node.resizeStrips[1]:
painter.drawLine(rf / 2, 0, width - rf / 2, 0)
# right strip
if node.resizeStrips[2]:
painter.drawLine(width, rf / 2, width, height - rf / 2)
# bottom strip
if node.resizeStrips[3]:
painter.drawLine(rf / 2, height, width - rf / 2, height)
# bottom right strip
if node.resizeStrips[4]:
painter.drawArc(width - rf, height - rf, rf, rf, 0, -90 * 16)
# bottom left strip
if node.resizeStrips[5]:
painter.drawArc(0, height - rf, rf, rf, -90 * 16, -90 * 16)
# top left strip
if node.resizeStrips[6]:
painter.drawArc(0, 0, rf, rf, 90 * 16, 90 * 16)
# top right strip
if node.resizeStrips[7]:
painter.drawArc(width - rf, 0, rf, rf, 90 * 16, -90 * 16)
def __init__(self, parent=None):
super(StyleSheetEditor, self).__init__(parent)
self.style = editableStyleSheet()
self.setLayout(QtWidgets.QVBoxLayout())
self.mainGroup = QtWidgets.QGroupBox(self)
self.mainGroupLay = QtWidgets.QVBoxLayout(self.mainGroup)
mainLabel = QtWidgets.QLabel("Main Color Hue", parent=self.mainGroup)
self.main_hue = pyf_HueSlider(self.mainGroup)
self.main_hue.valueChanged.connect(self.updateHue)
self.main_light = pyf_GradientSlider(self.mainGroup)
self.main_light.valueChanged.connect(self.updateLight)
self.mainGroupLay.addWidget(mainLabel)
self.mainGroupLay.addWidget(self.main_hue)
self.mainGroupLay.addWidget(self.main_light)
self.bgColor = pyf_GradientSlider(self)
self.bgColor.valueChanged.connect(self.updateBg)
self.layout().addWidget(self.mainGroup)
self.layout().addWidget(self.bgColor)
self.setColor(self.style.MainColor)
self.bgColor.setValue(0.196)
self.main_light.setValue(self.MainColor.lightnessF())
self.USETEXTUREBG = True
def __init__(self):
super(LoggerTool, self).__init__()
self.logView = QTextBrowser()
self.logView.setContextMenuPolicy(QtCore.Qt.ActionsContextMenu)
self.logView.setOpenLinks(False)
self.logView.setReadOnly(True)
self.logView.setStyleSheet(
"background-color: %s; Font: 10pt 'Consolas'" % "rgba%s" %
str(editableStyleSheet().LoggerBgColor.getRgb()))
self.clearAction = QAction("Clear", None)
self.clearAction.triggered.connect(self.clearView)
self.logView.addAction(self.clearAction)
self.logView.anchorClicked.connect(self.anchorClickedMethod)
self.logView.setTextColor(QtGui.QColor('white'))
self.setWidget(self.logView)
#####################################################
# Sys Output Redirection
#####################################################
self.handler = None
if REDIRECT:
self.handler = QtHandler(self)
else:
self.handler = logging.StreamHandler(sys.stdout)
self.handler.setFormatter(LoggerTool.formater)
logger.addHandler(self.handler)
logger.setLevel(logging.DEBUG)
sys.excepthook = LoggerTool.exceptHook
if self.handler and REDIRECT:
self.handler.messageHolder.messageWritten.connect(
lambda value: self.logPython(value, 0))
self.handler.messageHolder.warningWritten.connect(
lambda value: self.logPython(value, 1))
self.handler.messageHolder.errorWritten.connect(
lambda value: self.logPython(value, 2))
self.handler.messageHolder.flushSig.connect(self.flushPython)
