def __init__(self, port, graph, hOffset, color, connectionPointType):
super(PortCircle, self).__init__(port)
self.__port = port
self._graph = graph
self._connectionPointType = connectionPointType
self.__connections = set()
self._supportsOnlySingleConnections = connectionPointType == 'In'
self.setSizePolicy(QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed))
size = QtCore.QSizeF(self.__diameter, self.__diameter)
self.setPreferredSize(size)
self.setWindowFrameMargins(0, 0, 0, 0)
self.transform().translate(self.__radius * hOffset, 0)
self.__defaultPen = QtGui.QPen(QtGui.QColor(25, 25, 25), 1.0)
self.__hoverPen = QtGui.QPen(QtGui.QColor(255, 255, 100), 1.5)
self._ellipseItem = QtWidgets.QGraphicsEllipseItem(self)
self._ellipseItem.setPen(self.__defaultPen)
self._ellipseItem.setPos(size.width()/2, size.height()/2)
self._ellipseItem.setRect(
-self.__radius,
-self.__radius,
self.__diameter,
self.__diameter,
)
if connectionPointType == 'In':
self._ellipseItem.setStartAngle(270 * 16)
self._ellipseItem.setSpanAngle(180 * 16)
self.setColor(color)
self.setAcceptHoverEvents(True)
def paint(self, painter, option, widget):
rect = self.windowFrameRect()
painter.setBrush(self.__color)
painter.setPen(QtGui.QPen(QtGui.QColor(0, 0, 0, 0), 0))
roundingY = 10
roundingX = rect.height() / rect.width() * roundingY
painter.drawRoundRect(rect, roundingX, roundingY)
# Title BG
titleHeight = self.__headerItem.size().height() - 3
painter.setBrush(self.__color.darker(125))
roundingY = rect.width() * roundingX / titleHeight
painter.drawRoundRect(0, 0, rect.width(), titleHeight, roundingX,
roundingY)
painter.drawRect(0, titleHeight * 0.5 + 2, rect.width(),
titleHeight * 0.5)
# painter.setPen(self.__linePen)
# painter.drawLine(QtCore.QPoint(0, titleHeight), QtCore.QPoint(rect.width(), titleHeight))
painter.setBrush(QtGui.QColor(0, 0, 0, 0))
if self.__selected:
painter.setPen(self.__selectedPen)
else:
painter.setPen(self.__unselectedPen)
roundingY = 10
roundingX = rect.height() / rect.width() * roundingY
painter.drawRoundRect(rect, roundingX, roundingY)
def __init__(self, port, graph, hOffset, color, connectionPointType):
super(KNodePortCircle, self).__init__(port, graph, hOffset, color,
connectionPointType)
if self.getPort().getDataType().endswith('[]'):
self.setDefaultPen(QtGui.QPen(QtGui.QColor(204, 0, 0), 1.5))
self.setHoverPen(QtGui.QPen(QtGui.QColor(255, 155, 100), 2.0))
class NodeTitle(QtWidgets.QGraphicsWidget):
__color = QtGui.QColor(25, 25, 25)
__font = QtGui.QFont('Decorative', 14)
__font.setLetterSpacing(QtGui.QFont.PercentageSpacing, 115)
__labelBottomSpacing = 12
def __init__(self, text, parent=None):
super(NodeTitle, self).__init__(parent)
self.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed,
QtWidgets.QSizePolicy.Fixed))
self.__textItem = QtWidgets.QGraphicsTextItem(text, self)
self.__textItem.setDefaultTextColor(self.__color)
self.__textItem.setFont(self.__font)
self.__textItem.setPos(0, -2)
option = self.__textItem.document().defaultTextOption()
option.setWrapMode(QtGui.QTextOption.NoWrap)
self.__textItem.document().setDefaultTextOption(option)
self.__textItem.adjustSize()
self.setPreferredSize(self.textSize())
def setText(self, text):
self.__textItem.setPlainText(text)
self.__textItem.adjustSize()
self.setPreferredSize(self.textSize())
def textSize(self):
return QtCore.QSizeF(
self.__textItem.textWidth(),
self.__font.pointSizeF() + self.__labelBottomSpacing)
def _updateThumbnail(self):
if self.__value.width > 0 and self.__value.height > 0:
self._qimage = QtGui.QImage(self._thumbnailSize,
self._thumbnailSize,
QtGui.QImage.Format_RGB32)
for i in range(self._thumbnailSize):
for j in range(self._thumbnailSize):
if self.__value.pixelFormat == "RGB":
pixelColor = self.__value.sampleRGB(
"""RGB""",
float(i) / (self._thumbnailSize - 1.0),
float(j) / (self._thumbnailSize - 1.0))
elif self.__value.pixelFormat == "RGBA":
pixelColor = self.__value.sampleRGBA(
"""RGBA""",
float(i) / (self._thumbnailSize - 1.0),
float(j) / (self._thumbnailSize - 1.0))
pixelValue = QtGui.qRgb(pixelColor.r, pixelColor.g,
pixelColor.b)
self._qimage.setPixel(i, j, pixelValue)
self.tumbnailEditor.setPixmap(QtGui.QPixmap.fromImage(
self._qimage))
self._grid.addWidget(self.tumbnailEditor, 3, 0, 2, 2)
self._grid.setRowStretch(4, 2)
def __init__(self, graph, srcPortCircle, dstPortCircle):
super(Connection, self).__init__()
self.__graph = graph
self.__srcPortCircle = srcPortCircle
self.__dstPortCircle = dstPortCircle
penStyle = QtCore.Qt.DashLine
self.__connectionColor = QtGui.QColor(0, 0, 0)
self.__connectionColor.setRgbF(*self.__srcPortCircle.getColor().getRgbF())
self.__connectionColor.setAlpha(125)
self.__defaultPen = QtGui.QPen(self.__connectionColor, 1.5, s=penStyle)
self.__defaultPen.setDashPattern([1, 2, 2, 1])
self.__connectionHoverColor = QtGui.QColor(0, 0, 0)
self.__connectionHoverColor.setRgbF(*self.__srcPortCircle.getColor().getRgbF())
self.__connectionHoverColor.setAlpha(255)
self.__hoverPen = QtGui.QPen(self.__connectionHoverColor, 1.5, s=penStyle)
self.__hoverPen.setDashPattern([1, 2, 2, 1])
self.setPen(self.__defaultPen)
self.setZValue(-1)
self.setAcceptHoverEvents(True)
self.connect()
class SelectionRect(QtWidgets.QGraphicsWidget):
__backgroundColor = QtGui.QColor(100, 100, 100, 50)
__pen = QtGui.QPen(QtGui.QColor(25, 25, 25), 1.0, QtCore.Qt.DashLine)
def __init__(self, graph, mouseDownPos):
super(SelectionRect, self).__init__()
self.setZValue(-1)
self.__graph = graph
self.__graph.scene().addItem(self)
self.__mouseDownPos = mouseDownPos
self.setPos(self.__mouseDownPos)
self.resize(0, 0)
def setDragPoint(self, dragPoint):
topLeft = QtCore.QPointF(self.__mouseDownPos)
bottomRight = QtCore.QPointF(dragPoint)
if dragPoint.x() < self.__mouseDownPos.x():
topLeft.setX(dragPoint.x())
bottomRight.setX(self.__mouseDownPos.x())
if dragPoint.y() < self.__mouseDownPos.y():
topLeft.setY(dragPoint.y())
bottomRight.setY(self.__mouseDownPos.y())
self.setPos(topLeft)
self.resize(bottomRight.x() - topLeft.x(),
bottomRight.y() - topLeft.y())
def paint(self, painter, option, widget):
rect = self.windowFrameRect()
painter.setBrush(self.__backgroundColor)
painter.setPen(self.__pen)
painter.drawRect(rect)
def destroy(self):
self.__graph.scene().removeItem(self)
def dragObject(self):
if not self.selectedIndexes():
return
item = self.selectedItems()[0]
role = item.data(0, QtCore.Qt.UserRole)
if role == 'Folder':
return
text = 'BeamComponent:' + role
mimeData = QtCore.QMimeData()
mimeData.setText(text)
drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
drag.setHotSpot(QtCore.QPoint(90, 23))
ghostComponent = QtGui.QPixmap(180, 46)
#ghostComponent.fill(QtGui.QColor(67, 143, 153, 80))
ghostComponent.fill (QtGui.QColor (255, 255, 255, 255))
drag.setPixmap(ghostComponent)
drag.start(QtCore.Qt.IgnoreAction)
def getPortColor(dataType):
if dataType.startswith('Xfo'):
return QtGui.QColor(128, 170, 170, 255)
elif dataType.startswith('Float'):
return QtGui.QColor(32, 255, 32, 255)
elif dataType.startswith('Integer'):
return QtGui.QColor(0, 128, 0, 255)
elif dataType.startswith('Boolean'):
return QtGui.QColor(255, 102, 0, 255)
else:
return QtGui.QColor(50, 205, 254, 255)
def __init__(self, parent=None):
# constructors of base classes
super(BeamUI, self).__init__(parent)
self.setObjectName('mainUI')
self.setWindowIcon(QtGui.QIcon(''))
self.setWindowTitle("Beam Editor")
self.setAcceptDrops(True)
self.mainVboxLayout = QtGui.QVBoxLayout (self)
self.guideLayout = QtGui.QVBoxLayout ()
self.mainVboxLayout.addLayout(self.guideLayout)
self.build_from_selection = QtGui.QPushButton("build_from_selection")
self.mainVboxLayout.addWidget(self.build_from_selection)
compDir = shifter.getComponentDirectories ()
path = self.current_path ()
trackLoadComponent = []
for path, comps in compDir.iteritems ():
for comp_name in comps:
if comp_name in trackLoadComponent:
pm.displayWarning(
"Custom component name: %s, already in default "
"components. Names should be unique. This component is"
" not loaded" % comp_name)
continue
else:
trackLoadComponent.append (comp_name)
if not os.path.exists(os.path.join(path,
comp_name, "__init__.py")):
continue
module = shifter.importComponentGuide (comp_name)
print "BeamUI.__init__.module",module
reload (module)
commandbutton = self.loadUiWidget (os.path.join (path.replace("beam_components","widgets"), "commandbutton.ui"))
icon = QtGui.QPixmap(os.path.join (path,module.TYPE,"icon.jpg"))
self.guideLayout.addWidget (commandbutton)
commandbutton.pushButton.setText(module.TYPE)
commandbutton.label.setPixmap (icon)
QtCore.QObject.connect (commandbutton.pushButton, QtCore.SIGNAL ("clicked()"),
partial (self.drawComp, module.TYPE))
self.createConnections()
def __init__(self, parent, color):
super(KColorWidget, self).__init__(parent)
self.installEventFilter(self)
self._color = QtGui.QColor(color)
self.pixmap = QtGui.QPixmap(12, 12)
self.pixmap.fill(self._color)
self.setProperty('colorLabel', True)
self.setFixedSize(24, 24)
self.setScaledContents(True)
self.setPixmap(self.pixmap)
self.createConnections()
class GuideSettings(MayaQWidgetDockableMixin, QtWidgets.QDialog, HelperSlots):
# valueChanged = QtCore.Signal(int)
greenBrush = QtGui.QBrush()
greenBrush.setColor('#179e83')
redBrush = QtGui.QBrush()
redBrush.setColor('#9b2d22')
whiteBrush = QtGui.QBrush()
whiteBrush.setColor('#ffffff')
whiteDownBrush = QtGui.QBrush()
whiteDownBrush.setColor('#E2E2E2')
orangeBrush = QtGui.QBrush()
orangeBrush.setColor('#e67e22')
def __init__(self, parent=None):
pass
def __init__(self, graph, component):
super(KNode, self).__init__(graph, component.getDecoratedName())
self.__component = component
self.__inspectorWidget = None
print "KNode.__component.getNumInputs(): %s"%(self.__component.getNumInputs())
for i in range(self.__component.getNumInputs()):
componentInput = component.getInputByIndex(i)
print "KNode.componentInput: %s"%(componentInput)
self.addPort(KNodeInputPort(self, graph, componentInput))
print "KNode.__component.getNumOutputs(): %s" % (self.__component.getNumOutputs ())
for i in range(self.__component.getNumOutputs()):
componentOutput = component.getOutputByIndex(i)
self.addPort(KNodeOutputPort(self, graph, componentOutput))
self.setGraphPos( QtCore.QPointF( self.__component.getGraphPos().x, self.__component.getGraphPos().y ) )
#self.setGraphPos (QtCore.QPointF (1, 1))
nodeColor = component.getComponentColor()
print "KNode.nodeColor: ",(nodeColor)
self.setColor(QtGui.QColor(nodeColor[0], nodeColor[1], nodeColor[2], nodeColor[3]))
self.setUnselectedColor(self.getColor().darker(125))
self.setSelectedColor(self.getColor().lighter(175))
def defineLineEditSubEditor():
widget = LineEdit(self)
validator = QtGui.QDoubleValidator(self)
validator.setDecimals(3)
widget.setValidator(validator)
self.__editors.append(widget)
return widget
def __init__(self, valueController, parent=None):
super(ScalarSliderEditor, self).__init__(valueController,
parent=parent)
hbox = QtWidgets.QHBoxLayout()
validator = QtGui.QDoubleValidator(self)
validator.setRange(self._range['min'], self._range['max'], 4)
self._editEditor.setValidator(validator)
self._editEditor.setSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Fixed)
self._sliderEditor.setMinimum(self._range['min'] * 1000)
self._sliderEditor.setMaximum(self._range['max'] * 1000)
self._sliderEditor.setSizePolicy(
QtWidgets.QSizePolicy.MinimumExpanding,
QtWidgets.QSizePolicy.Fixed)
self._sliderEditor.setTickInterval(1000)
self._editEditor.setMinimumWidth(50)
self._editEditor.setMaximumWidth(90)
hbox.addWidget(self._editEditor, 1)
hbox.addWidget(self._sliderEditor, 1)
hbox.addStretch()
self.setLayout(hbox)
self.layout().setContentsMargins(0, 0, 0, 0)
self.updateEditorValue()
def __sliderPressed():
self.beginInteraction()
def __sliderReleased():
self.endInteraction()
def __sliderMoved(value):
if self._updatingEditor:
return
value = float(value) / 1000
self._editEditor.setText(str(round(value, 4)))
self._value = value
self._setValueToController()
def __textEdited():
if self._updatingEditor:
return
value = self.getEditorValue()
# if self._dynamicRange:
# self.updateSliderRange(value)
self._sliderEditor.setValue(value * 1000)
self._setValueToController()
self._sliderEditor.sliderPressed.connect(__sliderPressed)
self._sliderEditor.sliderReleased.connect(__sliderReleased)
self._sliderEditor.valueChanged.connect(__sliderMoved)
self._editEditor.editingFinished.connect(__textEdited)
self.setEditable(valueController.isEditable())
def __init__(self, parent=None):
# constructors of base classes
super(BeamUI, self).__init__(parent)
self.setObjectName('mainUI')
self.setWindowIcon(QtGui.QIcon(''))
self.setWindowTitle("Beam Editor")
self.setAcceptDrops(True)
self.graphViewWidget = KGraphViewWidget(parent=self)
self.nodeLibrary = ComponentLibrary(parent=self)
self.horizontalSplitter = QtWidgets.QSplitter(QtCore.Qt.Horizontal,
parent=self)
self.horizontalSplitter.addWidget(self.nodeLibrary)
self.horizontalSplitter.addWidget(self.graphViewWidget)
self.horizontalSplitter.setStretchFactor(0, 0)
self.horizontalSplitter.setStretchFactor(1, 1)
self.horizontalSplitter.setSizes([0, 100])
self.horizontalSplitter.splitterMoved.connect(self.splitterMoved)
self.nodeLibraryExpandedSize = 175
grid = QtWidgets.QVBoxLayout(self)
grid.addWidget(self.horizontalSplitter)
def unhighlight(self):
self._ellipseItem.setBrush(QtGui.QBrush(self._color))
self._ellipseItem.setRect(
-self.__radius,
-self.__radius,
self.__diameter,
self.__diameter,
)
def __init__(self, parent=None):
# constructors of base classes
super(BeamUI, self).__init__(parent)
self.setObjectName('mainUI')
self.setWindowIcon(QtGui.QIcon(''))
self.setWindowTitle("Beam Editor")
self.setAcceptDrops(True)
def highlight(self):
self._ellipseItem.setBrush(QtGui.QBrush(self._color.lighter()))
# make the port bigger to highlight it can accept the connection.
self._ellipseItem.setRect(
-self.__radius * 1.3,
-self.__radius * 1.3,
self.__diameter * 1.3,
self.__diameter * 1.3,
)
class Node (QtWidgets.QGraphicsWidget):
nameChanged = QtCore.Signal (str, str)
__defaultColor = QtGui.QColor (154, 205, 50, 255)
__defaultUnselectedColor = QtGui.QColor (25, 25, 25)
__defaultSelectedColor = QtGui.QColor (255, 255, 255, 255)
__defaultUnselectedPen = QtGui.QPen (__defaultUnselectedColor, 1.6)
__defaultSelectedPen = QtGui.QPen (__defaultSelectedColor, 1.6)
__defaultLinePen = QtGui.QPen (QtGui.QColor (25, 25, 25, 255), 1.25)
def __init__ (self):
super (Node, self).__init__ ()
self.__color = self.__defaultColor
self.__unselectedColor = self.__defaultUnselectedColor
self.__selectedColor = self.__defaultSelectedColor
self.__unselectedPen = QtGui.QPen (self.__defaultUnselectedPen)
self.__selectedPen = QtGui.QPen (self.__defaultSelectedPen)
self.__linePen = QtGui.QPen (self.__defaultLinePen)
self.setMinimumWidth (60)
self.setMinimumHeight (20)
self.setSizePolicy (QtWidgets.QSizePolicy (QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding))
layout = QtWidgets.QGraphicsLinearLayout ()
layout.setContentsMargins (0, 0, 0, 0)
layout.setSpacing (0)
layout.setOrientation (QtCore.Qt.Vertical)
self.setLayout (layout)
self.__headerItem = NodeHeader ("xxx", self)
layout.addItem (self.__headerItem)
layout.setAlignment (self.__headerItem, QtCore.Qt.AlignCenter | QtCore.Qt.AlignTop)
self.__ports = []
self.__inputPortsHolder = PortList (self)
self.__ioPortsHolder = PortList (self)
self.__outputPortsHolder = PortList (self)
layout.addItem (self.__inputPortsHolder)
layout.addItem (self.__ioPortsHolder)
layout.addItem (self.__outputPortsHolder)
self.__selected = False
self.__dragging = False
def addPort(self, port):
if isinstance(port, InputPort):
self.__inputPortsHolder.addPort(port, QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter)
elif isinstance(port, OutputPort):
self.__outputPortsHolder.addPort(port, QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter)
else:
self.__ioPortsHolder.addPort(port, QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter)
self.__ports.append(port)
self.adjustSize()
return port
def __init__(self, parent=None):
super(BeamWindow, self).__init__(parent)
self.setObjectName('BeamMainWindow')
self.setWindowTitle('Beam Editor')
self.setWindowIcon(QtGui.QIcon(''))
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.installEventFilter(self)
self.createLayout()
self.createConnections()
def defineLineEditSubEditor(name):
label = QtWidgets.QLabel(name, self)
hbox.addWidget(label)
widget = LineEdit(self)
validator = QtGui.QDoubleValidator(self)
validator.setDecimals(2)
widget.setValidator(validator)
hbox.addWidget(widget, 1)
self.__editors.append(widget)
return widget
def __init__(self, graph, name):
super(Node, self).__init__()
self.__name = name
self.__graph = graph
self.__color = self.__defaultColor
self.__unselectedColor = self.__defaultUnselectedColor
self.__selectedColor = self.__defaultSelectedColor
self.__unselectedPen = QtGui.QPen(self.__defaultUnselectedPen)
self.__selectedPen = QtGui.QPen(self.__defaultSelectedPen)
self.__linePen = QtGui.QPen(self.__defaultLinePen)
self.setMinimumWidth(60)
self.setMinimumHeight(20)
self.setSizePolicy(
QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding))
layout = QtWidgets.QGraphicsLinearLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
layout.setOrientation(QtCore.Qt.Vertical)
self.setLayout(layout)
self.__headerItem = NodeHeader(self.__name, self)
layout.addItem(self.__headerItem)
layout.setAlignment(self.__headerItem,
QtCore.Qt.AlignCenter | QtCore.Qt.AlignTop)
self.__ports = []
self.__inputPortsHolder = PortList(self)
self.__ioPortsHolder = PortList(self)
self.__outputPortsHolder = PortList(self)
layout.addItem(self.__inputPortsHolder)
layout.addItem(self.__ioPortsHolder)
layout.addItem(self.__outputPortsHolder)
self.__selected = False
self.__dragging = False
def setGraphView(self, graphView):
self.graphView = graphView
# Setup Layout
layout = QtWidgets.QVBoxLayout(self)
layout.addWidget(self.graphView)
self.setLayout(layout)
#########################
## Setup hotkeys for the following actions.
deleteShortcut = QtWidgets.QShortcut(
QtGui.QKeySequence(QtCore.Qt.Key_Delete), self)
deleteShortcut.activated.connect(self.graphView.deleteSelectedNodes)
frameShortcut = QtWidgets.QShortcut(
QtGui.QKeySequence(QtCore.Qt.Key_F), self)
frameShortcut.activated.connect(self.graphView.frameSelectedNodes)
frameShortcut = QtWidgets.QShortcut(
QtGui.QKeySequence(QtCore.Qt.Key_A), self)
frameShortcut.activated.connect(self.graphView.frameAllNodes)
def __init__(self, parent=None):
# constructors of base classes
super(BeamUI, self).__init__(parent)
self.setObjectName('mainUI')
self.setWindowIcon(QtGui.QIcon(''))
self.setWindowTitle("Beam Editor")
self.setAcceptDrops(True)
grid = QtWidgets.QVBoxLayout(self)
compDir = general.getComponentDirectories()
def __init__(self, parent=None):
super(BeamUI, self).__init__(parent)
self.setObjectName('mainUI')
self.setWindowIcon(QtGui.QIcon(''))
self.setWindowTitle("Beam Editor")
self.setAcceptDrops(True)
layout = QtWidgets.QVBoxLayout (self)
self.graphViewWidget = KGraphView (parent = self)
layout.addWidget(self.graphViewWidget)
self.setLayout(layout)
def paint(self, painter, option, widget):
srcPoint = self.mapFromScene(self.__srcPortCircle.centerInSceneCoords())
dstPoint = self.mapFromScene(self.__dstPortCircle.centerInSceneCoords())
dist_between = dstPoint - srcPoint
self.__path = QtGui.QPainterPath()
self.__path.moveTo(srcPoint)
self.__path.cubicTo(
srcPoint + QtCore.QPointF(dist_between.x() * 0.4, 0),
dstPoint - QtCore.QPointF(dist_between.x() * 0.4, 0),
dstPoint
)
self.setPath(self.__path)
super(Connection, self).paint(painter, option, widget)
def frameNodes(self, nodes):
if len(nodes) == 0:
return
def computeWindowFrame():
windowRect = self.rect()
windowRect.setLeft(windowRect.left() + 16)
windowRect.setRight(windowRect.right() - 16)
windowRect.setTop(windowRect.top() + 16)
windowRect.setBottom(windowRect.bottom() - 16)
return windowRect
nodesRect = None
for node in nodes:
nodeRectF = node.transform().mapRect(node.rect())
nodeRect = QtCore.QRect(nodeRectF.x(), nodeRectF.y(),
nodeRectF.width(), nodeRectF.height())
if nodesRect is None:
nodesRect = nodeRect
else:
nodesRect = nodesRect.united(nodeRect)
windowRect = computeWindowFrame()
scaleX = float(windowRect.width()) / float(nodesRect.width())
scaleY = float(windowRect.height()) / float(nodesRect.height())
if scaleY > scaleX:
scale = scaleX
else:
scale = scaleY
if scale < 1.0:
self.setTransform(QtGui.QTransform.fromScale(scale, scale))
else:
self.setTransform(QtGui.QTransform())
sceneRect = self.sceneRect()
pan = sceneRect.center() - nodesRect.center()
sceneRect.translate(-pan.x(), -pan.y())
self.setSceneRect(sceneRect)
# Update the main panel when reframing.
self.update()
def __init__(self, valueController, parent=None):
super(ScalarEditor, self).__init__(valueController, parent=parent)
hbox = QtWidgets.QHBoxLayout()
self._editor = QtWidgets.QLineEdit(self)
validator = QtGui.QDoubleValidator(self)
validator.setDecimals(3)
self._editor.setValidator(validator)
hbox.addWidget(self._editor, 1)
hbox.addStretch(0)
hbox.setContentsMargins(0, 0, 0, 0)
self.setLayout(hbox)
self.setSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Fixed)
self.updateEditorValue()
self._editor.editingFinished.connect(self._setValueToController)
self.setEditable(valueController.isEditable())
def mousePressEvent(self, event):
if event.button() is QtCore.Qt.MouseButton.LeftButton and self.itemAt(
event.pos()) is None:
self.beginNodeSelection.emit()
self._manipulationMode = MANIP_MODE_SELECT
self._mouseDownSelection = copy.copy(self.getSelectedNodes())
self._selectionRect = SelectionRect(graph=self,
mouseDownPos=self.mapToScene(
event.pos()))
elif event.button() is QtCore.Qt.MouseButton.MiddleButton:
self.setCursor(QtCore.Qt.OpenHandCursor)
self._manipulationMode = MANIP_MODE_PAN
self._lastPanPoint = self.mapToScene(event.pos())
elif event.button() is QtCore.Qt.MouseButton.RightButton:
self.setCursor(QtCore.Qt.SizeHorCursor)
self._manipulationMode = MANIP_MODE_ZOOM
self._lastZoomPoint = self.mapToScene(event.pos())
self._lastTransform = QtGui.QTransform(self.transform())
else:
super(GraphView, self).mousePressEvent(event)
