def paint(self, painter, option=None, widget=None):
if self.validateImage():
wasSmoothPixmapTransform = painter.testRenderHint(QtGui.QPainter.SmoothPixmapTransform)
painter.setRenderHint(QtGui.QPainter.SmoothPixmapTransform)
if Colors.noRescale:
# Let the painter scale the image for us. This may degrade
# both quality and performance.
if self.sharedImage.image is not None:
painter.drawImage(self.pos(), self.sharedImage.image)
else:
painter.drawPixmap(self.pos(), self.sharedImage.pixmap)
else:
m = painter.worldMatrix()
painter.setWorldMatrix(QtGui.QMatrix())
x = m.dx()
y = m.dy()
if self.noSubPixeling:
x = QtCore.qRound(x)
y = QtCore.qRound(y)
if self.sharedImage.image is not None:
painter.drawImage(QtCore.QPointF(x, y),
self.sharedImage.image)
else:
painter.drawPixmap(QtCore.QPointF(x, y),
self.sharedImage.pixmap)
if not wasSmoothPixmapTransform:
painter.setRenderHint(QtGui.QPainter.SmoothPixmapTransform,
False)
def setRange(self, minValue, maxValue):
if minValue < 0 or maxValue > 99 or minValue > maxValue:
QtCore.qWarning("LCDRange::setRange(%d, %d)\n"
"\tRange must be 0..99\n"
"\tand minValue must not be greater than maxValue" % (minValue, maxValue))
return
self.slider.setRange(minValue, maxValue)
def drawBackgroundToPixmap(self):
r = self.scene.sceneRect()
self.background = QtGui.QPixmap(QtCore.qRound(r.width()),
QtCore.qRound(r.height()))
self.background.fill(QtCore.Qt.black)
painter = QtGui.QPainter(self.background)
bg = QtGui.QImage(':/images/demobg.png')
painter.drawImage(0, 0, bg)
def __init__(self):
super(ColorItem, self).__init__()
self.color = QtGui.QColor(QtCore.qrand() % 256, QtCore.qrand() % 256,
QtCore.qrand() % 256)
self.setToolTip(
"QColor(%d, %d, %d)\nClick and drag this color onto the robot!" %
(self.color.red(), self.color.green(), self.color.blue())
)
self.setCursor(QtCore.Qt.OpenHandCursor)
def _pyside():
from PySide import (
QtGui,
QtCore,
QtNetwork,
QtXml,
QtHelp,
QtUiTools,
__version__
)
QtWidgets = QtGui
Qt.__binding__ = "PySide"
Qt.__qt_version__ = QtCore.qVersion()
Qt.__binding_version__ = __version__
QtCompat.load_ui = lambda fname: QtUiTools.QUiLoader().load(fname)
QtCompat.setSectionResizeMode = QtGui.QHeaderView.setResizeMode
QtCompat.translate = (
lambda context, sourceText, disambiguation, n:
QtCore.QCoreApplication.translate(context,
sourceText,
disambiguation,
QtCore.QCoreApplication.CodecForTr,
n))
return QtCore, QtGui, QtWidgets, QtNetwork, QtXml, QtHelp
def mouseMoveEvent(self, event):
if QtCore.QLineF(QtCore.QPointF(event.screenPos()), QtCore.QPointF(event.buttonDownScreenPos(QtCore.Qt.LeftButton))).length() < QtWidgets.QApplication.startDragDistance():
return
drag = QtGui.QDrag(event.widget())
mime = QtCore.QMimeData()
drag.setMimeData(mime)
ColorItem.n += 1
if ColorItem.n > 2 and QtCore.qrand() % 3 == 0:
image = QtGui.QImage(':/images/head.png')
mime.setImageData(image)
drag.setPixmap(QtGui.QPixmap.fromImage(image).scaled(30,40))
drag.setHotSpot(QtCore.QPoint(15, 30))
else:
mime.setColorData(self.color)
mime.setText("#%02x%02x%02x" % (self.color.red(), self.color.green(), self.color.blue()))
pixmap = QtGui.QPixmap(34, 34)
pixmap.fill(QtCore.Qt.white)
painter = QtGui.QPainter(pixmap)
painter.translate(15, 15)
painter.setRenderHint(QtGui.QPainter.Antialiasing)
self.paint(painter, None, None)
painter.end()
pixmap.setMask(pixmap.createHeuristicMask())
drag.setPixmap(pixmap)
drag.setHotSpot(QtCore.QPoint(15, 20))
drag.exec_()
self.setCursor(QtCore.Qt.OpenHandCursor)
def shotRect(self):
gravity = 4.0
time = self.timerCount / 40.0
velocity = self.shootForce
radians = self.shootAngle * 3.14159265 / 180
velx = velocity * math.cos(radians)
vely = velocity * math.sin(radians)
x0 = (CannonField.barrelRect.right() + 5) * math.cos(radians)
y0 = (CannonField.barrelRect.right() + 5) * math.sin(radians)
x = x0 + velx * time
y = y0 + vely * time - 0.5 * gravity * time * time
result = QtCore.QRect(0, 0, 6, 6)
result.moveCenter(QtCore.QPoint(QtCore.qRound(x), self.height() - 1 - QtCore.qRound(y)))
return result
def __init__(self):
super(Mouse, self).__init__()
self.angle = 0.0
self.speed = 0.0
self.mouseEyeDirection = 0.0
self.color = QtGui.QColor(QtCore.qrand() % 256, QtCore.qrand() % 256,
QtCore.qrand() % 256)
self.rotate(QtCore.qrand() % (360 * 16))
# In the C++ version of this example, this class is also derived from
# QObject in order to receive timer events. PyQt does not support
# deriving from more than one wrapped class so we just create an
# explicit timer instead.
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.timerEvent)
self.timer.start(1000 / 33)
def mouseMoveEvent(self, event):
if not self.barrelPressed:
return
pos = event.pos()
if pos.x() <= 0:
pos.setX(1)
if pos.y() >= self.height():
pos.setY(self.height() - 1)
rad = math.atan((float(self.rect().bottom()) - pos.y()) / pos.x())
self.setAngle(QtCore.qRound(rad * 180 / 3.14159265))
def keyPressEvent(self, event):
key = event.key()
if key == QtCore.Qt.Key_Up:
self.centerNode.moveBy(0, -20)
elif key == QtCore.Qt.Key_Down:
self.centerNode.moveBy(0, 20)
elif key == QtCore.Qt.Key_Left:
self.centerNode.moveBy(-20, 0)
elif key == QtCore.Qt.Key_Right:
self.centerNode.moveBy(20, 0)
elif key == QtCore.Qt.Key_Plus:
self.scaleView(1.2)
elif key == QtCore.Qt.Key_Minus:
self.scaleView(1 / 1.2)
elif key == QtCore.Qt.Key_Space or key == QtCore.Qt.Key_Enter:
for item in self.scene().items():
if isinstance(item, Node):
item.setPos(-150 + QtCore.qrand() % 300, -150 + QtCore.qrand() % 300)
else:
QtGui.QGraphicsView.keyPressEvent(self, event)
def calculateForces(self):
if not self.scene() or self.scene().mouseGrabberItem() is self:
self.newPos = self.pos()
return
# Sum up all forces pushing this item away.
xvel = 0.0
yvel = 0.0
for item in self.scene().items():
if not isinstance(item, Node):
continue
line = QtCore.QLineF(self.mapFromItem(item, 0, 0), QtCore.QPointF(0, 0))
dx = line.dx()
dy = line.dy()
l = 2.0 * (dx * dx + dy * dy)
if l > 0:
xvel += (dx * 150.0) / l
yvel += (dy * 150.0) / l
# Now subtract all forces pulling items together.
weight = (len(self.edgeList) + 1) * 10.0
for edge in self.edgeList:
if edge().sourceNode() is self:
pos = self.mapFromItem(edge().destNode(), 0, 0)
else:
pos = self.mapFromItem(edge().sourceNode(), 0, 0)
xvel += pos.x() / weight
yvel += pos.y() / weight
if QtCore.qAbs(xvel) < 0.1 and QtCore.qAbs(yvel) < 0.1:
xvel = yvel = 0.0
sceneRect = self.scene().sceneRect()
self.newPos = self.pos() + QtCore.QPointF(xvel, yvel)
self.newPos.setX(min(max(self.newPos.x(), sceneRect.left() + 10), sceneRect.right() - 10))
self.newPos.setY(min(max(self.newPos.y(), sceneRect.top() + 10), sceneRect.bottom() - 10))
def timerEvent(self):
# Don't move too far away.
lineToCenter = QtCore.QLineF(QtCore.QPointF(0, 0), self.mapFromScene(0, 0))
if lineToCenter.length() > 150:
angleToCenter = math.acos(lineToCenter.dx() / lineToCenter.length())
if lineToCenter.dy() < 0:
angleToCenter = Mouse.TwoPi - angleToCenter;
angleToCenter = Mouse.normalizeAngle((Mouse.Pi - angleToCenter) + Mouse.Pi / 2)
if angleToCenter < Mouse.Pi and angleToCenter > Mouse.Pi / 4:
# Rotate left.
self.angle += [-0.25, 0.25][self.angle < -Mouse.Pi / 2]
elif angleToCenter >= Mouse.Pi and angleToCenter < (Mouse.Pi + Mouse.Pi / 2 + Mouse.Pi / 4):
# Rotate right.
self.angle += [-0.25, 0.25][self.angle < Mouse.Pi / 2]
elif math.sin(self.angle) < 0:
self.angle += 0.25
elif math.sin(self.angle) > 0:
self.angle -= 0.25
# Try not to crash with any other mice.
dangerMice = self.scene().items(QtGui.QPolygonF([self.mapToScene(0, 0),
self.mapToScene(-30, -50),
self.mapToScene(30, -50)]))
for item in dangerMice:
if item is self:
continue
lineToMouse = QtCore.QLineF(QtCore.QPointF(0, 0), self.mapFromItem(item, 0, 0))
angleToMouse = math.acos(lineToMouse.dx() / lineToMouse.length())
if lineToMouse.dy() < 0:
angleToMouse = Mouse.TwoPi - angleToMouse
angleToMouse = Mouse.normalizeAngle((Mouse.Pi - angleToMouse) + Mouse.Pi / 2)
if angleToMouse >= 0 and angleToMouse < Mouse.Pi / 2:
# Rotate right.
self.angle += 0.5
elif angleToMouse <= Mouse.TwoPi and angleToMouse > (Mouse.TwoPi - Mouse.Pi / 2):
# Rotate left.
self.angle -= 0.5
# Add some random movement.
if len(dangerMice) > 1 and (QtCore.qrand() % 10) == 0:
if QtCore.qrand() % 1:
self.angle += (QtCore.qrand() % 100) / 500.0
else:
self.angle -= (QtCore.qrand() % 100) / 500.0
self.speed += (-50 + QtCore.qrand() % 100) / 100.0
dx = math.sin(self.angle) * 10
self.mouseEyeDirection = [dx / 5, 0.0][QtCore.qAbs(dx / 5) < 1]
self.rotate(dx)
self.setPos(self.mapToParent(0, -(3 + math.sin(self.speed) * 3)))
def _pyside2():
from PySide2 import (
QtWidgets,
QtGui,
QtCore,
QtNetwork,
QtXml,
QtHelp,
QtUiTools,
__version__
)
Qt.__binding__ = "PySide2"
Qt.__qt_version__ = QtCore.qVersion()
Qt.__binding_version__ = __version__
QtCompat.load_ui = lambda fname: QtUiTools.QUiLoader().load(fname)
QtCompat.setSectionResizeMode = QtWidgets.QHeaderView.setSectionResizeMode
QtCompat.translate = QtCore.QCoreApplication.translate
return QtCore, QtGui, QtWidgets, QtNetwork, QtXml, QtHelp
def launch_ffmpeg_command(input,
preset,
server=None,
job=None,
root=None,
asset=None,
task_folder=None):
"""Calls FFMpeg to process an input using the given preset.
"""
w = common_ui.MessageBox(u'Converting...', u'Should take a few minutes...')
try:
FFMPEG_BIN = settings.local_settings.value(u'preferences/ffmpeg_path')
if not FFMPEG_BIN:
raise RuntimeError(
u'The path to FFMpeg has not yet been set.\nYou can set the path in the General > External Applications section.'
)
if not QtCore.QFileInfo(FFMPEG_BIN):
raise RuntimeError('FFMpeg was not found!')
server = server if server else settings.ACTIVE['server']
job = job if job else settings.ACTIVE['job']
root = root if root else settings.ACTIVE['root']
asset = asset if asset else settings.ACTIVE['asset']
task_folder = task_folder if task_folder else settings.ACTIVE[
'task_folder']
input = input.replace(u'\\', '/').lower()
# We want to get the first item of any sequence
if common.is_collapsed(input):
input = common.get_sequence_startpath(input)
else:
seq = common.get_sequence(input)
if not seq:
raise RuntimeError(u'{} is not a sequence.'.format(input))
_dir = QtCore.QFileInfo(input).dir().path()
if not QtCore.QFileInfo(_dir):
raise RuntimeError(u'{} does not exists.'.format(_dir))
f = []
for entry in _scandir.scandir(_dir):
_path = entry.path.replace(u'\\', u'/').lower()
if not seq.group(1) in _path:
continue
_seq = common.get_sequence(_path)
if not _seq:
continue
f.append(int(_seq.group(2)))
if not f:
raise RuntimeError(
u'Could not find the first frame of the sequence.')
startframe = min(f)
endframe = max(f)
# Framerate
db = bookmark_db.get_db(server, job, root)
framerate = db.value(1, 'framerate', table=u'properties')
if not framerate:
framerate = 24
input = seq.group(1) + '%0{}d'.format(len(
seq.group(2))) + seq.group(3) + '.' + seq.group(4)
output = seq.group(1).rstrip(u'.').rstrip(u'_').rstrip() + u'.mp4'
# Add informative label
label = u''
if job:
label += job
label += u'_'
if asset:
label += asset
label += u'_'
if task_folder:
label += task_folder
label += u' \\| '
vseq = common.get_sequence(output)
if vseq:
label += 'v' + vseq.group(2) + u' '
label += datetime.now().strftime('(%a %d/%m/%Y) \\| ')
label += u'{}-{} \\| '.format(startframe, endframe)
w.open()
QtWidgets.QApplication.instance().processEvents()
cmd = preset.format(
BIN=FFMPEG_BIN,
FRAMERATE=framerate,
STARTFRAME=startframe,
INPUT=os.path.normpath(input),
OUTPUT=os.path.normpath(output),
FONT=get_font_path(),
LABEL=label,
)
subprocess.check_output(cmd, shell=True)
w.close()
log.success('Successfully saved {}'.format(output))
common_ui.OkBox(u'Finished converting',
'Saved to {}'.format(output)).open()
except Exception as e:
w.close()
log.error(u'Conversion failed.')
common_ui.ErrorBox(u'Conversion failed', unicode(e)).open()
def qCleanupResources():
QtCore.qUnregisterResourceData(0x01, qt_resource_struct, qt_resource_name,
qt_resource_data)
def mimeDataAdd(mimeData, format, objects):
data = QtCore.QByteArray()
stream = QtCore.QDataStream(data, QtCore.QIODevice.WriteOnly)
text = QtCore.QString(":".join(objects))
stream << text
mimeData.setData(format, data)
EMAIL_SUBJECT_PREFIX = "cuemail: please check "
EMAIL_BODY_PREFIX = "Your PSTs request that you check "
EMAIL_BODY_SUFFIX = "\n\n"
EMAIL_DOMAIN = ""
GITHUB_CREATE_ISSUE_URL = 'https://github.com/AcademySoftwareFoundation/OpenCue/issues/new'
URL_USERGUIDE = "https://www.opencue.io/docs/"
URL_SUGGESTION = "%s?labels=enhancement&template=enhancement.md" % GITHUB_CREATE_ISSUE_URL
URL_BUG = "%s?labels=bug&template=bug_report.md" % GITHUB_CREATE_ISSUE_URL
if platform.system() == "Windows":
DEFAULT_EDITOR = "notepad"
else:
DEFAULT_EDITOR = "gview -R -m -M -U %s/gvimrc +" % DEFAULT_INI_PATH
EMPTY_INDEX = QtCore.QModelIndex()
QVARIANT_CENTER = QtCore.Qt.AlignCenter
QVARIANT_RIGHT = QtCore.Qt.AlignRight
QVARIANT_NULL = None
QVARIANT_BLACK = QtGui.QColor(QtCore.Qt.black)
QVARIANT_GREY = QtGui.QColor(QtCore.Qt.gray)
ALLOWED_TAGS = ("general", "desktop", "playblast", "util", "preprocess", "wan", "cuda", "splathw",
'naiad', 'massive')
RGB_FRAME_STATE = {opencue.api.job_pb2.DEAD: QtGui.QColor(255, 0, 0),
opencue.api.job_pb2.DEPEND: QtGui.QColor(160, 32, 240),
opencue.api.job_pb2.EATEN: QtGui.QColor(150, 0, 0),
opencue.api.job_pb2.RUNNING: QtGui.QColor(200, 200, 55),
opencue.api.job_pb2.SETUP: QtGui.QColor(160, 32, 240),
def getPassFor(host_param):
for line in open(os.getenv("HOME") + '/.rcremote', 'r').readlines():
s = line.strip().split('#', 1)
if len(s) < 2:
continue
host = s[0]
password = s[1]
if host == host_param:
return password
raise Exception("can't find password for " + host_param +
" in ~/.rcremote (format 'host#password')")
if __name__ == '__main__':
app = QtCore.QCoreApplication(sys.argv)
ic = Ice.initialize(sys.argv)
status = 0
mprx = {}
if len(sys.argv) < 2:
try:
print('Reading password from ~/.rcremote...')
password = getPassFor('localhost')
print('ok.')
except:
print('Couldn\'t read password from file!')
print('\nUsage: rcremoteserver <password>')
sys.exit(-1)
else:
password = sys.argv[1]
def _setSize(self, x, y):
self.resize(x, y)
self.setMinimumSize(QtCore.QSize(x, y))
self.setMaximumSize(QtCore.QSize(x, y))
def movePreviousRow(self, index):
self.beginMoveRows(QtCore.QModelIndex(), index, index,
QtCore.QModelIndex(), index - 1)
self.frames.insert(index - 1, self.frames.pop(index))
self.endMoveRows()
class Signaller(QtCore.QObject):
signal = QtCore.Signal(str)
def __init__(self):
super().__init__()
def insertRow(self, index, pixmap=None):
self.beginInsertRows(QtCore.QModelIndex(), index, index)
self.frames.insert(index, Frame(pixmap))
self.endInsertRows()
def removeRow(self, index):
self.beginRemoveRows(QtCore.QModelIndex(), self.rowCount(),
self.rowCount())
print(index.row())
self.frames.pop(index.row())
self.endRemoveRows()
def appendRow(self, pixmap=None):
self.beginInsertRows(QtCore.QModelIndex(), self.rowCount(),
self.rowCount())
self.frames.append(Frame(pixmap))
self.endInsertRows()
def rowCount(self, parent=QtCore.QModelIndex()):
if parent.isValid(): return 0
return len(self.frames)
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(691, 662)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.gridLayout_2 = QtWidgets.QGridLayout(self.centralwidget)
self.gridLayout_2.setObjectName("gridLayout_2")
self.gridLayout_4 = QtWidgets.QGridLayout()
self.gridLayout_4.setObjectName("gridLayout_4")
self.pushButton_ask_and_send = QtWidgets.QPushButton(
self.centralwidget)
self.pushButton_ask_and_send.setObjectName("pushButton_ask_and_send")
self.gridLayout_4.addWidget(self.pushButton_ask_and_send, 0, 0, 1, 1)
self.pushButton_cancel_send = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_cancel_send.setCheckable(False)
self.pushButton_cancel_send.setObjectName("pushButton_cancel_send")
self.gridLayout_4.addWidget(self.pushButton_cancel_send, 0, 1, 1, 1)
self.listWidget_emails = QtWidgets.QListWidget(self.centralwidget)
self.listWidget_emails.setObjectName("listWidget_emails")
self.gridLayout_4.addWidget(self.listWidget_emails, 1, 0, 1, 2)
self.gridLayout_2.addLayout(self.gridLayout_4, 0, 0, 1, 1)
self.gridLayout = QtWidgets.QGridLayout()
self.gridLayout.setObjectName("gridLayout")
self.pushButton_open_list_and_template = QtWidgets.QPushButton(
self.centralwidget)
self.pushButton_open_list_and_template.setObjectName(
"pushButton_open_list_and_template")
self.gridLayout.addWidget(self.pushButton_open_list_and_template, 0, 0,
1, 1)
self.textBrowser = QtWidgets.QTextBrowser(self.centralwidget)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(99)
sizePolicy.setHeightForWidth(
self.textBrowser.sizePolicy().hasHeightForWidth())
self.textBrowser.setSizePolicy(sizePolicy)
self.textBrowser.setObjectName("textBrowser")
self.gridLayout.addWidget(self.textBrowser, 1, 0, 1, 1)
self.listWidget_attachments = QtWidgets.QListWidget(self.centralwidget)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(1)
sizePolicy.setHeightForWidth(
self.listWidget_attachments.sizePolicy().hasHeightForWidth())
self.listWidget_attachments.setSizePolicy(sizePolicy)
self.listWidget_attachments.setMinimumSize(QtCore.QSize(0, 75))
self.listWidget_attachments.setObjectName("listWidget_attachments")
self.gridLayout.addWidget(self.listWidget_attachments, 2, 0, 1, 1)
self.gridLayout_2.addLayout(self.gridLayout, 0, 1, 1, 1)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 691, 21))
self.menubar.setObjectName("menubar")
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def index(self, row, column, parent=QtCore.QModelIndex()):
"""Get an index at a certain location."""
return self.createIndex(row, column, parent)
def moveNextRow(self, index):
self.beginMoveRows(QtCore.QModelIndex(), index, index,
QtCore.QModelIndex(), index + 2)
self.frames.insert(index + 1, self.frames.pop(index))
self.endMoveRows()
class AOVsToAddModel(BaseAOVTreeModel):
"""This class represents the available AOVs and AOVGroups that will be
added.
"""
inserted_items_signal = QtCore.Signal([AOVBaseNode])
removed_items_signal = QtCore.Signal([AOVBaseNode])
# -------------------------------------------------------------------------
# METHODS
# -------------------------------------------------------------------------
def clear_all(self):
"""Clear the tree of any nodes."""
parent = QtCore.QModelIndex()
node = self.get_node(parent)
# Remove each child.
for row in reversed(range(len(node.children))):
index = self.index(row, 0, parent)
self.remove_index(index)
def dropMimeData(self, data, action, row, column, parent): # pylint: disable=unused-argument
"""Handle dropping mime data on the view."""
if not utils.has_aov_mime_data(data):
return False
self.insert_data(utils.decode_aov_mime_data(data))
return True
def flags(self, index):
"""Tree node flags."""
if not index.isValid():
return None
node = index.internalPointer()
parent = node.parent
if parent == self.root:
return (QtCore.Qt.ItemIsEnabled
| QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsDragEnabled)
if isinstance(parent, AOVGroupNode):
return QtCore.Qt.ItemIsEnabled
return None
def insert_data(self, data, position=None):
"""Insert data into the model."""
parent = QtCore.QModelIndex()
# Filter data to remove items that area already installed.
data = [item for item in data if item not in self.items]
parent_node = self.get_node(parent)
if position is None:
position = len(self.items)
rows = len(data)
if not rows:
return False
self.beginInsertRows(parent, position, position + rows - 1)
added_items = []
for item in data:
if isinstance(item, AOV):
child_node = AOVNode(item)
elif isinstance(item, IntrinsicAOVGroup):
child_node = IntrinsicAOVGroupNode(item)
else:
child_node = AOVGroupNode(item)
parent_node.insert_child(position, child_node)
added_items.append(child_node)
self.inserted_items_signal.emit(added_items)
self.endInsertRows()
return True
def remove_index(self, index):
"""Remove an index."""
parent = QtCore.QModelIndex()
parent_node = self.get_node(parent)
row = index.row()
self.beginRemoveRows(parent, row, row)
self.removed_items_signal.emit([parent_node.children[row]])
parent_node.remove_child(row)
self.endRemoveRows()
return True
def supportedDropActions(self):
"""Supported drop actions."""
# Add support for MoveAction since that's what Houdini thinks is
# happening when you try and drop a node on a widget.
return QtCore.Qt.CopyAction
def check(x):
self.assertEqual(QtCore.qAbs(x), abs(x))
class CueLineEdit(QtWidgets.QLineEdit):
"""Wrapper around QLineEdit that allows for changing text with up/down arrow keys."""
focusChange = QtCore.Signal(bool)
def __init__(self, defaultText=None, completerStrings=None, parent=None):
super(CueLineEdit, self).__init__(parent=parent)
self.setText(defaultText)
self.index = -1
self.setSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding,
QtWidgets.QSizePolicy.Fixed)
self.completer = QtWidgets.QCompleter()
try:
self.completerModel = QtCore.QStringListModel()
except AttributeError:
self.completerModel = QtGui.QStringListModel()
self.completerStrings = completerStrings or []
self.setupCompleter()
self.setStyleSheet(Style.LINE_EDIT)
def focusInEvent(self, e):
super(CueLineEdit, self).focusInEvent(e)
self.focusChange.emit(True)
def focusOutEvent(self, e):
super(CueLineEdit, self).focusOutEvent(e)
self.focusChange.emit(False)
def setupCompleter(self):
"""Add completer items """
self.completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
self.completerModel.setStringList(self.completerStrings)
self.completer.setModel(self.completerModel)
self.setCompleter(self.completer)
def keyPressEvent(self, event):
"""Add up and down arrow key events to built in functionality."""
keyPressed = event.key()
if keyPressed in [
Constants.UP_KEY, Constants.DOWN_KEY, Constants.TAB_KEY
]:
if keyPressed == Constants.UP_KEY:
self.index = max(0, self.index - 1)
elif keyPressed == Constants.DOWN_KEY:
self.index = min(
len(self.completerStrings) - 1, self.index + 1)
elif keyPressed == Constants.TAB_KEY and self.completerStrings:
self.tabPressed()
if self.completerStrings:
self.setTextToCompleterIndex()
super(CueLineEdit, self).keyPressEvent(event)
def setTextToCompleterIndex(self):
"""Set the current text to current index of the completers."""
self.setText(self.completerStrings[self.index])
def tabPressed(self):
"""Action called with the tab key is pressed.
Completes the string based on the completers.
"""
current_text = self.text()
matches = [
i for i in self.completerStrings if i.startswith(current_text)
]
if matches:
self.setText(matches[0])
""" Unittest for bug #515 """
""" http://bugs.openbossa.org/show_bug.cgi?id=515 """
from PySide2 import QtCore
callCleanup = False
def _cleanup():
global callCleanup
callCleanup = True
def _checkCleanup():
global callCleanup
assert(callCleanup)
app = QtCore.QCoreApplication([])
QtCore.qAddPostRoutine(_cleanup)
QtCore.qAddPostRoutine(_checkCleanup)
del app
def _setupUi(self):
self.setObjectName('LightCreator_DIALOG')
self.setWindowTitle('Light Creator')
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed,
QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
vert_VERTLAY = QtWidgets.QVBoxLayout(self)
vert_VERTLAY.setObjectName("vert_VERTLAY")
main_GRIDLAY = QtWidgets.QGridLayout(self)
main_GRIDLAY.setObjectName("main_GRIDLAY")
btnSize = QtCore.QSize(71, 23)
self.create_BTN = QtWidgets.QPushButton(self)
self.create_BTN.setSizePolicy(sizePolicy)
self.create_BTN.setMinimumSize(btnSize)
self.create_BTN.setMaximumSize(btnSize)
self.create_BTN.setText('Create')
self.create_BTN.setObjectName("create_BTN")
self.cancel_BTN = QtWidgets.QPushButton(self)
self.cancel_BTN.setSizePolicy(sizePolicy)
self.cancel_BTN.setMinimumSize(btnSize)
self.cancel_BTN.setMaximumSize(btnSize)
self.cancel_BTN.setText('Cancel')
self.cancel_BTN.setObjectName("cancel_BTN")
# Create controls for each token type and adjust window size accordingly
defaultFactory = self.factories['default']
activeRule = defaultFactory.naming.getActiveRule()
self.tokens = dict()
i = 0
if activeRule:
for field in activeRule.fields:
if defaultFactory.naming.hasToken(field):
token = defaultFactory.naming.getToken(field)
self.tokens[token.name] = {'obj': token, 'index': i}
i += 1
self._setSize(112 * len(self.tokens), 91)
for key, value in self.tokens.iteritems():
tokenObj = self.tokens[key]['obj']
labelSize = QtCore.QSize(60, 13)
label = QtWidgets.QLabel(self)
label.setSizePolicy(sizePolicy)
label.setMinimumSize(labelSize)
label.setMaximumSize(labelSize)
label.setObjectName(tokenObj.name + '_LABEL')
label.setText(tokenObj.name.capitalize())
if isinstance(tokenObj, defaultFactory.naming.TokenNumber):
#Create spinbox
ctrlSpinSize = QtCore.QSize(61, 21)
ctrlSpin = QtWidgets.QSpinBox(self)
ctrlSpin.setSizePolicy(sizePolicy)
ctrlSpin.setMinimumSize(ctrlSpinSize)
ctrlSpin.setMaximumSize(ctrlSpinSize)
ctrlSpin.setObjectName(tokenObj.name + '_SPINBOX')
ctrlSpin.setValue(tokenObj.default)
ctrlSpin.setRange(0, 1000000)
self.tokens[key]['ctrl'] = ctrlSpin
self.tokens[key]['label'] = label
else:
if tokenObj.required:
#Create line edit
ctrlLineSize = QtCore.QSize(113, 20)
ctrlLine = QtWidgets.QLineEdit(self)
ctrlLine.setSizePolicy(sizePolicy)
ctrlLine.setMinimumSize(ctrlLineSize)
ctrlLine.setMaximumSize(ctrlLineSize)
ctrlLine.setObjectName(tokenObj.name + '_LINEEDIT')
ctrlLine.setFocus(QtCore.Qt.PopupFocusReason)
self.tokens[key]['ctrl'] = ctrlLine
labelSize = QtCore.QSize(110, 13)
label.setMinimumSize(labelSize)
label.setMaximumSize(labelSize)
self.tokens[key]['label'] = label
else:
#Create combobox with options
ctrlComboSize = QtCore.QSize(111, 22)
ctrlCombo = QtWidgets.QComboBox(self)
ctrlCombo.setSizePolicy(sizePolicy)
ctrlCombo.setMinimumSize(ctrlComboSize)
ctrlCombo.setMaximumSize(ctrlComboSize)
ctrlCombo.setObjectName(tokenObj.name + '_COMBOBOX')
model = dvm.ObjectsListModel(tokenObj.options.keys(),
ctrlCombo)
ctrlCombo.setModel(model)
if tokenObj.default:
dataList = ctrlCombo.model().dataList
for x in range(len(dataList)):
if dataList[x] == tokenObj.default:
ctrlCombo.setCurrentIndex(x)
break
self.tokens[key]['ctrl'] = ctrlCombo
labelSize = QtCore.QSize(110, 13)
label.setMinimumSize(labelSize)
label.setMaximumSize(labelSize)
self.tokens[key]['label'] = label
for key, value in self.tokens.iteritems():
for item in self.tokens[key].keys():
tokenCtrl = self.tokens[key]['ctrl']
tokenLabel = self.tokens[key]['label']
tokenIndex = self.tokens[key]['index']
if item == 'label':
main_GRIDLAY.addWidget(tokenLabel, 0, tokenIndex * 2, 1, 1,
QtCore.Qt.AlignLeft)
elif item == 'ctrl':
main_GRIDLAY.addWidget(tokenCtrl, 1, tokenIndex * 2, 1, 1,
QtCore.Qt.AlignCenter)
for column in range(0, i, 2):
main_GRIDLAY.setColumnMinimumWidth(column, 1)
main_GRIDLAY.setColumnStretch(column, 1)
vert_VERTLAY.addLayout(main_GRIDLAY)
btns_GRIDLAY = QtWidgets.QGridLayout(self)
btns_GRIDLAY.setObjectName('btns_GRIDLAY')
btns_GRIDLAY.addWidget(self.create_BTN, 0, 1, 1, 1,
QtCore.Qt.AlignCenter)
btns_GRIDLAY.addWidget(self.cancel_BTN, 0, 2, 1, 1,
QtCore.Qt.AlignCenter)
spacing = 112 * (i / 2)
btns_GRIDLAY.setColumnMinimumWidth(0, spacing)
btns_GRIDLAY.setColumnStretch(0, spacing)
btns_GRIDLAY.setColumnMinimumWidth(3, spacing)
btns_GRIDLAY.setColumnStretch(3, spacing)
vert_VERTLAY.addLayout(btns_GRIDLAY)
self.setLayout(vert_VERTLAY)
QtCore.QMetaObject.connectSlotsByName(self)
def boundingRect(self):
adjust = 2.0
return QtCore.QRectF(-10 - adjust, -10 - adjust,
23 + adjust, 23 + adjust)
class Exporter(QtCore.QThread):
progressed = QtCore.Signal(int)
failed = QtCore.Signal()
export_finished = QtCore.Signal()
def __init__(self,
get_scene_func,
filename,
w,
h,
extra_enc_args=None,
time=None):
super().__init__()
self._get_scene_func = get_scene_func
self._filename = filename
self._width = w
self._height = h
self._extra_enc_args = extra_enc_args if extra_enc_args is not None else []
self._time = time
self._cancelled = False
def run(self):
filename, width, height = self._filename, self._width, self._height
if filename.endswith('gif'):
palette_filename = op.join(tempfile.gettempdir(), 'palette.png')
pass1_args = ['-vf', 'palettegen']
pass2_args = self._extra_enc_args + [
'-i', palette_filename, '-lavfi', 'paletteuse'
]
ok = self._export(palette_filename, width, height, pass1_args)
if not ok:
return
ok = self._export(filename, width, height, pass2_args)
else:
ok = self._export(filename, width, height, self._extra_enc_args)
if ok:
self.export_finished.emit()
def _export(self, filename, width, height, extra_enc_args=None):
fd_r, fd_w = os.pipe()
cfg = self._get_scene_func()
if not cfg:
self.failed.emit()
return False
fps = cfg['framerate']
duration = cfg['duration']
samples = cfg['samples']
cmd = [
'ffmpeg', '-r',
'%d/%d' % fps, '-nostats', '-nostdin', '-f', 'rawvideo',
'-video_size',
'%dx%d' % (width, height), '-pixel_format', 'rgba', '-i',
'pipe:%d' % fd_r
]
if extra_enc_args:
cmd += extra_enc_args
cmd += ['-y', filename]
reader = subprocess.Popen(cmd, pass_fds=(fd_r, ))
os.close(fd_r)
capture_buffer = bytearray(width * height * 4)
# node.gl context
ngl_viewer = ngl.Context()
ngl_viewer.configure(
platform=ngl.PLATFORM_AUTO,
backend=get_backend(cfg['backend']),
offscreen=1,
width=width,
height=height,
viewport=get_viewport(width, height, cfg['aspect_ratio']),
samples=samples,
clear_color=cfg['clear_color'],
capture_buffer=capture_buffer,
)
ngl_viewer.set_scene_from_string(cfg['scene'])
if self._time is not None:
ngl_viewer.draw(self._time)
os.write(fd_w, capture_buffer)
self.progressed.emit(100)
else:
# Draw every frame
nb_frame = int(duration * fps[0] / fps[1])
for i in range(nb_frame):
if self._cancelled:
break
time = i * fps[1] / float(fps[0])
ngl_viewer.draw(time)
os.write(fd_w, capture_buffer)
self.progressed.emit(i * 100 / nb_frame)
self.progressed.emit(100)
os.close(fd_w)
reader.wait()
return True
def cancel(self):
self._cancelled = True
sceneRect.width() - 4, sceneRect.height() - 4)
message = self.tr("Click and drag the nodes around, and zoom with the "
"mouse wheel or the '+' and '-' keys")
font = painter.font()
font.setBold(True)
font.setPointSize(14)
painter.setFont(font)
painter.setPen(QtCore.Qt.lightGray)
painter.drawText(textRect.translated(2, 2), message)
painter.setPen(QtCore.Qt.black)
painter.drawText(textRect, message)
def scaleView(self, scaleFactor):
factor = self.matrix().scale(scaleFactor, scaleFactor).mapRect(QtCore.QRectF(0, 0, 1, 1)).width()
if factor < 0.07 or factor > 100:
return
self.scale(scaleFactor, scaleFactor)
if __name__ == "__main__":
app = QtWidgets.QApplication(sys.argv)
QtCore.qsrand(QtCore.QTime(0,0,0).secsTo(QtCore.QTime.currentTime()))
widget = GraphWidget()
widget.show()
sys.exit(app.exec_())
def setupUI(self):
self.setObjectName("MainWindow")
self.setFixedSize(282, 214)
_translate = QtCore.QCoreApplication.translate
self.setWindowTitle(_translate("MainWindow", "Client"))
# self.background_image = QtWidgets.QLabel(self)
# self.background_image.setGeometry(QtCore.QRect(0, 0, 281, 211))
# self.background_image.setStyleSheet("background-color: rgb(238, 255, 238);")
# self.background_image.setText("")
# self.background_image.setScaledContents(True)
# self.background_image.setObjectName("background_image")
self.IP_box = QtWidgets.QLineEdit(self)
self.IP_box.setGeometry(QtCore.QRect(40, 90, 201, 41))
font = QtGui.QFont()
font.setFamily("Helvetica")
font.setPointSize(12)
self.IP_box.setFont(font)
self.IP_box.setStyleSheet("background-color: rgb(246, 252, 255);")
self.IP_box.setObjectName("IP_box")
self.IP_box.setText(_translate("MainWindow", "127.0.0.1"))
self.port_box = QtWidgets.QLineEdit(self)
self.port_box.setGeometry(QtCore.QRect(40, 150, 101, 41))
font = QtGui.QFont()
font.setFamily("Helvetica")
font.setPointSize(12)
self.port_box.setFont(font)
self.port_box.setStyleSheet("background-color: rgb(246, 252, 255);")
self.port_box.setObjectName("port_box")
self.port_box.setText(_translate("MainWindow", " 6666"))
self.connect_button = QtWidgets.QPushButton(
self, clicked=lambda: self.Connect())
self.connect_button.setGeometry(QtCore.QRect(160, 150, 81, 41))
font = QtGui.QFont()
font.setFamily("Helvetica")
font.setPointSize(11)
self.connect_button.setFont(font)
self.connect_button.setStyleSheet(
"background-color: rgb(224, 237, 255)")
self.connect_button.setCheckable(False)
self.connect_button.setChecked(False)
self.connect_button.setObjectName("connect_button")
self.connect_button.setText(_translate("MainWindow", "Kết nối"))
self.WELCOME_label = QtWidgets.QLabel(self)
self.WELCOME_label.setGeometry(QtCore.QRect(40, 20, 201, 51))
font = QtGui.QFont()
font.setFamily("Helvetica")
font.setPointSize(22)
font.setBold(True)
font.setWeight(75)
self.WELCOME_label.setFont(font)
self.WELCOME_label.setStyleSheet("color: rgb(255, 24, 128);")
self.WELCOME_label.setAlignment(QtCore.Qt.AlignCenter)
self.WELCOME_label.setObjectName("WELCOME_label")
self.WELCOME_label.setText(_translate("MainWindow", "CLIENT"))
QtCore.QMetaObject.connectSlotsByName(self)
def paintEvent(self, event): penCapStyle = [QtCore.Qt.FlatCap, QtCore.Qt.SquareCap, QtCore.Qt.RoundCap] penJoinStyle = [QtCore.Qt.MiterJoin, QtCore.Qt.BevelJoin, QtCore.Qt.RoundJoin] brushStyle = [QtCore.Qt.SolidPattern, QtCore.Qt.Dense1Pattern, QtCore.Qt.Dense7Pattern, QtCore.Qt.CrossPattern, QtCore.Qt.FDiagPattern, QtCore.Qt.DiagCrossPattern] painter = QtGui.QPainter(self) painter.setRenderHint(QtGui.QPainter.Antialiasing, True) painter.setPen(QtGui.QPen(QtCore.Qt.black, 15, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin)) painter.setBrush(QtGui.QBrush(QtCore.Qt.blue, QtCore.Qt.DiagCrossPattern)) # painter.drawPie(80, 80, 400, 240, 60 * 16, 270 * 16) poly = [QtCore.QPoint(0, 85), QtCore.QPoint(75, 75), QtCore.QPoint(100, 10), QtCore.QPoint(125, 75), QtCore.QPoint(200, 85), QtCore.QPoint(150, 125), QtCore.QPoint(160, 190), QtCore.QPoint(100, 150), QtCore.QPoint(40, 190), QtCore.QPoint(50, 125), QtCore.QPoint(0, 85)] gradient = QtGui.QLinearGradient(50, 100, 300, 350) gradient.setColorAt(0.0, QtCore.Qt.white) gradient.setColorAt(0.5, QtCore.Qt.green) gradient.setColorAt(1.0, QtCore.Qt.black) painter.setBrush(gradient) painter.setBackgroundColor(QtCore.Qt.red) painter.setPen(QtGui.QPen(QtCore.Qt.red, 4, QtCore.Qt.DashDotLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin)) # painter.drawPolygon(poly) painter.drawRect(80, 80, 240, 140)
def readData(self):
message = self.socket.readLine().data().decode("utf-8")
self.text += message + '\r\n'
#sayThis(self.text)
widgets = self.root.property('widgets')
widgets.property('textedit').setProperty('text', self.text)
def sendmessage(self, message):
self.socket.write(message.encode("utf-8"))
def displayError(self):
#QtGui.QMessageBox.information(self.root, "Connection", "Error during connection")
widgets = self.root.property('widgets')
QtCore.QMetaObject.invokeMethod(widgets['error'], "show", QtCore.Qt.DirectConnection)
def closeEvent(self, event):
self.socket.disconnectFromHost()
if __name__ == "__main__":
app = QtWidgets.QApplication(sys.argv)
view = QtQuick.QQuickView()
url = QtCore.QUrl('talk.qml')
ctx = view.rootContext()
con = Controller(ctx)
ctx.setContextProperty("con", con)
view.setSource(url)
view.show()
sys.exit(app.exec_())
# Values.
for i, item in enumerate(items):
# Ellipse.
ellipseState.assignProperty(item, 'pos',
QtCore.QPointF(math.cos((i / 63.0) * 6.28) * 250,
math.sin((i / 63.0) * 6.28) * 250))
# Figure 8.
figure8State.assignProperty(item, 'pos',
QtCore.QPointF(math.sin((i / 63.0) * 6.28) * 250,
math.sin(((i * 2)/63.0) * 6.28) * 250))
# Random.
randomState.assignProperty(item, 'pos',
QtCore.QPointF(-250 + QtCore.qrand() % 500,
-250 + QtCore.qrand() % 500))
# Tiled.
tiledState.assignProperty(item, 'pos',
QtCore.QPointF(((i % 8) - 4) * kineticPix.width() + kineticPix.width() / 2,
((i // 8) - 4) * kineticPix.height() + kineticPix.height() / 2))
# Centered.
centeredState.assignProperty(item, 'pos', QtCore.QPointF())
# Ui.
view = View(scene)
view.setWindowTitle("Animated Tiles")
view.setViewportUpdateMode(QtGui.QGraphicsView.BoundingRectViewportUpdate)
view.setBackgroundBrush(QtGui.QBrush(bgPix))
dx = math.sin(self.angle) * 10
self.mouseEyeDirection = [dx / 5, 0.0][QtCore.qAbs(dx / 5) < 1]
self.rotate(dx)
self.setPos(self.mapToParent(0, -(3 + math.sin(self.speed) * 3)))
if __name__ == '__main__':
import sys
MouseCount = 7
app = QtGui.QApplication(sys.argv)
QtCore.qsrand(QtCore.QTime(0,0,0).secsTo(QtCore.QTime.currentTime()))
scene = QtGui.QGraphicsScene()
scene.setSceneRect(-300, -300, 600, 600)
scene.setItemIndexMethod(QtGui.QGraphicsScene.NoIndex)
for i in range(MouseCount):
mouse = Mouse()
mouse.setPos(math.sin((i * 6.28) / MouseCount) * 200,
math.cos((i * 6.28) / MouseCount) * 200)
scene.addItem(mouse)
view = QtGui.QGraphicsView(scene)
view.setRenderHint(QtGui.QPainter.Antialiasing)
view.setBackgroundBrush(QtGui.QBrush(QtGui.QPixmap(':/images/cheese.jpg')))
view.setCacheMode(QtGui.QGraphicsView.CacheBackground)
def qInitResources():
QtCore.qRegisterResourceData(0x01, qt_resource_struct, qt_resource_name, qt_resource_data)
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#Texts are not updated in GUI unless processEvents is called
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
print('step2')
app.emit(QtCore.SIGNAL("SEND_MESSAGE(QString)"), 'step2')
for i in range(1000000):
app.processEvents() #let the main loop process gui events.
print('finish')
app.emit(QtCore.SIGNAL("SEND_MESSAGE(QString)"), 'finish')
#Create the demo container
wdFrm = QtWidgets.QWidget()
layout = QtWidgets.QVBoxLayout(wdFrm)
#A line edit to display computation step
wdLineEdit = QtWidgets.QLineEdit("No computation running")
layout.addWidget(wdLineEdit)
#connect to the custom signal to print the step in the QLineEdit
app.connect(QtCore.SIGNAL("SEND_MESSAGE(QString)"), wdLineEdit.setText)
#Create a button to launch the computation
wdButtonCompute = QtWidgets.QPushButton("Compute")
layout.addWidget(wdButtonCompute)
wdButtonCompute.clicked.connect(Compute)
wdFrm.show()
sys.exit(app.exec_())
def qInitResources():
QtCore.qRegisterResourceData(0x01, qt_resource_struct, qt_resource_name,
qt_resource_data)
def _start_timer(self):
"""Start and continuously refresh timer in background to keep the total
number of rows up to date."""
self.timer = QtCore.QTimer(self)
self.timer.start(self.__refreshtime)
self.timer.timeout.connect(self.auto_refresh)
class NodeGraph(QtCore.QObject):
node_selected = QtCore.Signal(list)
def __init__(self, parent=None):
super(NodeGraph, self).__init__(parent)
self._model = NodeGraphModel()
self._viewer = NodeViewer()
self._undo_stack = QUndoStack(self)
self._init_actions()
self._wire_signals()
self.patch_context_menu()
def _wire_signals(self):
self._viewer.moved_nodes.connect(self._on_nodes_moved)
self._viewer.search_triggered.connect(self._on_search_triggered)
self._viewer.connection_changed.connect(self._on_connection_changed)
self._viewer.node_selected.connect(self._on_node_selected)
def _init_actions(self):
# setup tab search shortcut.
tab = QAction('Search Nodes', self)
tab.setShortcut('tab')
tab.triggered.connect(self._toggle_tab_search)
self._viewer.addAction(tab)
setup_actions(self)
def _toggle_tab_search(self):
"""
toggle the tab search widget.
"""
self._viewer.tab_search_set_nodes(NodeVendor.names)
self._viewer.tab_search_toggle()
def _on_nodes_moved(self, node_data):
"""
called when selected nodes in the viewer has changed position.
Args:
node_data (dict): {<node_view>: <previous_pos>}
"""
self._undo_stack.beginMacro('moved nodes')
for node_view, prev_pos in node_data.items():
node = self._model.nodes[node_view.id]
self._undo_stack.push(NodeMovedCmd(node, node.pos(), prev_pos))
self._undo_stack.endMacro()
def _on_nodes_moved(self, node_data):
"""
called when a node in the viewer is selected on left click.
"""
nodes = self.selected_nodes()
self.node_selected.emit(nodes)
def _on_search_triggered(self, node_type, pos):
"""
called when the tab search widget is triggered in the viewer.
Args:
node_type (str): node identifier.
pos (tuple): x,y position for the node.
"""
self.create_node(node_type, pos=pos)
def _on_connection_changed(self, disconnected, connected):
"""
called when a pipe connection has been changed in the viewer.
Args:
disconnected (list[list[widgets.port.PortItem]):
pair list of port view items.
connected (list[list[widgets.port.PortItem]]):
pair list of port view items.
"""
if not (disconnected or connected):
return
label = 'connected node(s)' if connected else 'disconnected node(s)'
ptypes = {'in': 'inputs', 'out': 'outputs'}
self._undo_stack.beginMacro(label)
for p1_view, p2_view in disconnected:
node1 = self._model.nodes[p1_view.node.id]
node2 = self._model.nodes[p2_view.node.id]
port1 = getattr(node1, ptypes[p1_view.port_type])()[p1_view.name]
port2 = getattr(node2, ptypes[p2_view.port_type])()[p2_view.name]
port1.disconnect_from(port2)
for p1_view, p2_view in connected:
node1 = self._model.nodes[p1_view.node.id]
node2 = self._model.nodes[p2_view.node.id]
port1 = getattr(node1, ptypes[p1_view.port_type])()[p1_view.name]
port2 = getattr(node2, ptypes[p2_view.port_type])()[p2_view.name]
port1.connect_to(port2)
self._undo_stack.endMacro()
@property
def model(self):
"""
Return the node graph model.
Returns:
NodeGraphModel: model object.
"""
return self._model
def show(self):
"""
Show node graph viewer widget.
"""
self._viewer.show()
def hide(self):
"""
Hide node graph viewer widget.
"""
self._viewer.hide()
def close(self):
"""
Close node graph viewer widget.
"""
self._viewer.close()
def viewer(self):
"""
Return the node graph viewer widget object.
Returns:
NodeGraphQt.widgets.viewer.NodeViewer: viewer widget.
"""
return self._viewer
def scene(self):
"""
Return the scene object.
Returns:
NodeGraphQt.widgets.scene.NodeScene: node scene.
"""
return self._viewer.scene()
def undo_stack(self):
"""
Returns the undo stack used in the node graph
Returns:
QUndoStack: undo stack.
"""
return self._undo_stack
def begin_undo(self, name='undo'):
"""
Start of an undo block followed by a end_undo().
Args:
name (str): name for the undo block.
"""
self._undo_stack.beginMacro(name)
def end_undo(self):
"""
End of an undo block started by begin_undo().
"""
self._undo_stack.endMacro()
def context_menu(self):
"""
Returns a node graph context menu object.
Returns:
ContextMenu: node graph context menu object instance.
"""
return self._viewer.context_menu()
@staticmethod
def modify_context_menu(viewer):
def openFileOfItem(self, row, column):
item = self.filesTable.item(row, 0)
QtGui.QDesktopServices.openUrl(
QtCore.QUrl(self.currentDir.absoluteFilePath(item.text())))
def set(self, n, p):
inc = self.screenRect.width() / n
self.marker = QtCore.QRect(inc * p, 0, inc, self.height)
def qCleanupResources():
QtCore.qUnregisterResourceData(0x01, qt_resource_struct, qt_resource_name, qt_resource_data)
def __init__(self, width, height):
super(Panel, self).__init__()
self.selectedX = 0
self.selectedY = 0
self.width = width
self.height = height
self.flipped = False
self.flipLeft = True
self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setCacheMode(QtGui.QGraphicsView.CacheBackground)
self.setViewportUpdateMode(QtGui.QGraphicsView.FullViewportUpdate)
self.setRenderHints(QtGui.QPainter.Antialiasing |
QtGui.QPainter.SmoothPixmapTransform |
QtGui.QPainter.TextAntialiasing)
self.setBackgroundBrush(QtGui.QBrush(QtGui.QPixmap('./images/blue_angle_swirl.jpg')))
if QtOpenGL.QGLFormat.hasOpenGL():
self.setViewport(QtOpenGL.QGLWidget(QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers)))
self.setMinimumSize(50, 50)
self.selectionTimeLine = QtCore.QTimeLine(150, self)
self.flipTimeLine = QtCore.QTimeLine(500, self)
bounds = QtCore.QRectF((-width / 2.0) * 150, (-height / 2.0) * 150, width * 150, height * 150)
self.scene = QtGui.QGraphicsScene(bounds, self)
self.setScene(self.scene)
self.baseItem = RoundRectItem(bounds, QtGui.QColor(226, 255, 92, 64))
self.scene.addItem(self.baseItem)
embed = QtGui.QWidget()
self.ui = Ui_BackSide()
self.ui.setupUi(embed)
self.ui.hostName.setFocus()
self.backItem = RoundRectItem(bounds, embed.palette().window(), embed)
self.backItem.setTransform(QtGui.QTransform().rotate(180, QtCore.Qt.YAxis))
self.backItem.setParentItem(self.baseItem)
self.selectionItem = RoundRectItem(QtCore.QRectF(-60, -60, 120, 120), QtCore.Qt.gray)
self.selectionItem.setParentItem(self.baseItem)
self.selectionItem.setZValue(-1)
self.selectionItem.setPos(self.posForLocation(0, 0))
self.startPos = self.selectionItem.pos()
self.endPos = QtCore.QPointF()
self.grid = []
for y in range(height):
self.grid.append([])
for x in range(width):
item = RoundRectItem(QtCore.QRectF(-54, -54, 108, 108), QtGui.QColor(214, 240, 110, 128))
item.setPos(self.posForLocation(x, y))
item.setParentItem(self.baseItem)
item.setFlag(QtGui.QGraphicsItem.ItemIsFocusable)
self.grid[y].append(item)
rand = QtCore.qrand() % 9
if rand == 0 :
item.setPixmap(QtGui.QPixmap(':/images/kontact_contacts.png'))
elif rand == 1:
item.setPixmap(QtGui.QPixmap(':/images/kontact_journal.png'))
elif rand == 2:
item.setPixmap(QtGui.QPixmap(':/images/kontact_notes.png'))
elif rand == 3:
item.setPixmap(QtGui.QPixmap(':/images/kopeteavailable.png'))
elif rand == 4:
item.setPixmap(QtGui.QPixmap(':/images/metacontact_online.png'))
elif rand == 5:
item.setPixmap(QtGui.QPixmap(':/images/minitools.png'))
elif rand == 6:
item.setPixmap(QtGui.QPixmap(':/images/kontact_journal.png'))
elif rand == 7:
item.setPixmap(QtGui.QPixmap(':/images/kontact_contacts.png'))
elif rand == 8:
item.setPixmap(QtGui.QPixmap(':/images/kopeteavailable.png'))
else:
pass
item.qobject.activated.connect(self.flip)
self.grid[0][0].setFocus()
self.backItem.qobject.activated.connect(self.flip)
self.selectionTimeLine.valueChanged.connect(self.updateSelectionStep)
self.flipTimeLine.valueChanged.connect(self.updateFlipStep)
self.splash = SplashItem()
self.splash.setZValue(5)
self.splash.setPos(-self.splash.rect().width()/2,
self.scene.sceneRect().top())
self.scene.addItem(self.splash)
self.splash.grabKeyboard()
self.updateSelectionStep(0)
self.setWindowTitle("Pad Navigator Example")
