def getPkgNodeByPath(self, nodePkgPath=''):
'''
used by root ytNode
nodePath is node fullName in nuke, getted by node.fullName()
'''
yl.debug('get ytNode by path: %s' % nodePkgPath)
if not isinstance(nodePkgPath, str):
yl.error(
'TypeError: parameter need string, getted by node.fullName() in nuke'
)
return None
if nodePkgPath == '':
return self.rootNode
pathNames = nodePkgPath.split('.')
nodePkg = self.rootNode
if pathNames != []:
for p in pathNames:
cn = nodePkg.getChildrenName()
if p in cn:
nodePkg = nodePkg[cn.index(p)]
else:
yl.error('can not find node: %s' % nodePkgPath)
return None
return nodePkg
return None
def getNodeFilePath(self,
nodeClassItem,
knob,
conditionKnob=None,
conditionValue=None):
# perNodeFilePathCallback
callbackType = 3
nodes = [
n for n in nuke.toNode(
nodeClassItem.getParent().getNodePath()).nodes()
if n.Class() == nodeClassItem.getValue()
]
yl.debug('get nodes')
for index, node in enumerate(nodes):
if node.knob(knob) and (
conditionKnob is None or
(node.knob(conditionKnob)
and node[conditionKnob].getValue() is conditionValue)):
path = node[knob].getValue()
pi = pkgItem(parent=nodeClassItem,
value=node.name(),
status=pkgStatus.NORMAL,
itemtype=pkgItemType.NODE,
pos=index)
pi.setDirPath(node[knob].value())
pi.setNodePath('.'.join(
(nodeClassItem.getParent().getNodePath(), node.name())))
yl.debug('get node: %s' % pi.getValue())
self.callback(pi, callbackType)
nodeClassItem.appendItem(pi)
self.pathAnalysis(pi, path)
def deRegeditPlugin(pluginName):
global plugins
if pluginName in getPluginsName():
yl.debug('deRegedited plugin: %s' % pluginName)
p = getPluginByName(pluginName)
plugins.pop(getPluginsName().index(pluginName))
else:
yl.warning('plugin: %s do not existed, ignore' % p.getName())
def stoppedCallback(self):
if len(self.stoppedCallbackList) > 0:
yl.debug('stoppedCallback of plugin: %s ' % self.plugin.name)
try:
for c in self.stoppedCallbackList:
c[0](self, *c[1])
except Exception as e:
yl.error(e.message)
def show(self):
yl.debug('show yangTools')
if not self.isShow:
self.addNukeCallback()
self.outlineGui.show()
t = getNodeTreeThread(self.rootNode)
t.start()
self.isShow = True
def __init__(self, parent=None):
super(ytOutlineWidget, self).__init__(parent)
yl.debug('initialize ytOutlineWidget')
self.setWindowFlags(QtCore.Qt.Window)
self.setStyleSheet(
'QToolButton:hover {background-color:gray; border:1px;}')
self.pluginButtons = []
self.init()
def stop(self):
yl.debug('stop yangTools')
if self.isShow:
self.removeNukeCallback()
self.rootNode.clearChildren()
self.outlineGui.outlineTreeView.model().resetModel()
[p.stop() for p in ytPlugins.plugins]
self.isShow = False
def getFiles(self):
if not self.__isGettingFiles:
self.__isGettingFiles = True
yl.debug('create getting file thread')
getFilesThread = pkgGetFilesThread()
yl.debug('start get file list thread')
getFilesThread.start()
else:
yl.warning('getting file list, please wait a moment...')
def nukeDestroyNodeCallback(self):
'''the callback that called while deleting node in nuke'''
yl.debug('nukeDestroyNodeCallback begin')
node = nuke.thisNode()
yn = self.getPkgNodeByPath(node.fullName())
parent = yn.getParent()
if parent:
yn.getParent().removeChild(yn)
yl.debug('nukeDestroyNodeCallback end')
def __init__(self, name='', node=None, parent=None):
yl.debug('initialize ytNode: %s' % name)
self._name = name
self._node = node
self._selected = False
self._children = []
self._parent = parent
if self._parent is not None and self not in self._parent.getChildren():
parent.appendChild(self)
def __init__(self, root=None, parent=None):
super(ytNodeModel, self).__init__(parent)
yl.debug('initialize ytNode.ytNodeModel')
self._parent = parent
self.root = root
self._header = []
# self.resetModeSignal.connect(self.updateView)
self.createNodeSignal.connect(self.createNode)
self.deleteNodeSignal.connect(self.deleteNode)
def getNukeMainWindow(self):
yl.debug('get main window instance of nuke')
self.app = QtWidgets.QApplication.instance()
for w in self.app.topLevelWidgets():
if w.inherits('QMainWindow') and w.metaObject().className(
) == 'Foundry::UI::DockMainWindow':
return w
else:
yl.error('RuntimeError: Could not find DockMainWindow instance')
def ytTreeViewSelectionCallback(self, selected, deselected):
# signal loop break: gui -> ytNode -> nuke -> (break here) -> ytNode -> gui -> ...
yl.debug('ytTreeViewSelectionCallback')
if ytVariables.ytCaller.yt_caller_isNukeCallback:
ytVariables.ytCaller.yt_caller_isNukeCallback = False
return
# deselect deselected node in nuke
[i.internalPointer().setSelection(False) for i in deselected.indexes()]
# select selected node in nuke
[i.internalPointer().setSelection(True) for i in selected.indexes()]
def deleteNode(self, node, caller):
yl.debug('treeview delete node: %s' % node.getName())
index = self.getIndexFromNode(node)
# selection = QtCore.QItemSelection(self._parent.selectionModel().selection())
self.beginRemoveRows(index.parent(), index.row(), index.row())
if index.isValid():
# self._parent.selectionModel().select(index, QtCore.QItemSelectionModel.Deselect)
yl.debug('remove index: %d' % index.row())
self.removeRow(index.row(), self.parent(index))
self.endRemoveRows()
def getNodePath(self, node):
yl.debug('get node path')
path = node.getName()
while True:
parent = node.getParent()
if parent:
path = parent.getName() + '.' + path
node = parent
else:
break
return path
def getFullIndex(self):
yl.debug('get full index')
if self._parent is not None and self in self._parent.getChildren():
fullIndex = []
child = self
while True:
fullIndex.insert(0, child.getIndex())
child = child.getParent()
if child.getParent() is None:
return fullIndex
return [0]
def registerPlugin(plugin):
global plugins
if isinstance(plugin, ytPlugin.ytPlugin):
if plugin.name not in getPluginsName():
p = ytPlugin.ytRegeditPlugin(plugin)
plugins.append(p)
yl.debug('registered plugin: %s' % p.getName())
return True
else:
yl.warning('plugin: %s has existed, ignore' % p.getName())
return False
def removeNukeCallback(self):
'''remove method from Nuke callback list'''
yl.debug('nukeDestroyNodeCallback')
if '*' in nuke.onCreates and (self.nukeCreateNodeCallback,
(), {}, None) in nuke.onCreates['*']:
nuke.removeOnCreate(self.nukeCreateNodeCallback)
if '*' in nuke.knobChangeds or (self.nukeSelectionCallback, (), {},
None) in nuke.knobChangeds['*']:
nuke.removeKnobChanged(self.nukeSelectionCallback)
if '*' in nuke.onDestroys and (self.nukeDestroyNodeCallback,
(), {}, None) in nuke.onDestroys['*']:
nuke.removeOnDestroy(self.nukeDestroyNodeCallback)
def getNodeTree(self, space=None):
if space is None:
space = ytNode.ytNode('root', nuke.root())
yl.debug('get node tree in space: %s' % space.getName())
ns = nuke.toNode(space.getPath()).nodes()
if len(ns) > 0:
for n in ns:
pn = ytNode.ytNode(n.name(), n, space)
pn.setSelection(n['selected'].value(),
ytVariables.ytCaller.yt_caller_nuke)
if n.Class() == 'Group':
self.getNodeTree(pn)
def setCallback(self):
yl.debug('put __getFilesComplete function in getFilesCompleteCallback')
yCallbacks.getFilesCompleteCallback.append(
(self.__getFilesComplete, ()))
yCallbacks.pkgGuiShowCallback.append((self.queueStart, ()))
yCallbacks.pkgGuiCloseCallback.append((self.queueStop, ()))
yCallbacks.pkgItemThreadQueueEmptyCallback.append(
(self.__setItemThreadQueueEmpty, (True, )))
yCallbacks.pkgItemThreadQueueEmptyCallback.append(
(self.__setIsNotPackaging, ()))
yCallbacks.pkgItemThreadQueueNotEmptyCallback.append(
(self.__setItemThreadQueueEmpty, (False, )))
def nukeSelectionCallback(self):
'''the callback that called while selecting node in nuke'''
k = nuke.thisKnob()
if k.name() == 'selected':
yl.debug('nukeSelectNodeCallback')
n = nuke.thisNode()
if ytVariables.ytCaller.yt_caller_isGuiCallback:
ytVariables.ytCaller.yt_caller_isGuiCallback = False
return
yt = self.getPkgNodeByPath(n.fullName())
if yt is not None:
yt.setSelection(k.value(), ytVariables.ytCaller.yt_caller_nuke)
def nukeCreateNodeCallback(self):
'''the callback that called while creating node in nuke'''
yl.debug('nukeCreateNodeCallback')
node = nuke.thisNode()
if '.' not in node.fullName():
parent = self.getPkgNodeByPath()
else:
parent = self.getPkgNodeByPath('.'.join(
node.fullName().split('.')[:-1]))
if parent is not None:
yn = ytNode.ytNode(node.name(), node, parent)
yn.setSelection(node['selected'].value(),
ytVariables.ytCaller.yt_caller_nuke)
def addNukeCallback(self):
'''add method to Nuke callback list'''
yl.debug('nukeAddNodeCallback')
if '*' not in nuke.onCreates or (self.nukeCreateNodeCallback, (), {},
None) not in nuke.onCreates['*']:
nuke.addOnCreate(self.nukeCreateNodeCallback)
if '*' not in nuke.knobChangeds or (
self.nukeSelectionCallback,
(), {}, None) not in nuke.knobChangeds['*']:
nuke.addKnobChanged(self.nukeSelectionCallback)
if '*' not in nuke.onDestroys or (self.nukeDestroyNodeCallback, (), {},
None) not in nuke.onDestroys['*']:
nuke.addOnDestroy(self.nukeDestroyNodeCallback)
def addYtCallback(self):
'''add methods to corresponding callback lists'''
yl.debug(
'add method to ytNode\'s callback lists and plugin\'s callback list'
)
ytCallbacks.ytNode_selectionChanged_callback.append(
(self.ytNodeSelectionCallback, ()))
ytCallbacks.ytNode_childCreated_callback.append(
(self.outlineGui.outlineTreeView.model().createNodeSignal.emit,
()))
ytCallbacks.ytNode_childDestroyed_callback.append(
(self.outlineGui.outlineTreeView.model().deleteNodeSignal.emit,
()))
def pkgItems(self, path):
if not self.__isPackaging:
self.__isPackaging = True
if os.path.isdir(path):
self.__pkgedFilePath = {}
for items in self.walkItems():
for index, item in enumerate(items):
yl.debug('add pkg item:%s to thread queue' %
item.getValue())
self.__queue.put(
pkgItemThread(item, path, self.__pkgedFilePath))
else:
yl.error('path: %s is not exists' % path)
else:
yl.warning('packaging, wait a moment')
def copy(self, newName=None, newDirname=None, replace=False):
'''
copy file
if newName is None, keep name as source
if newDirname is None, copy to source path, so newName must be different with source name.
if replace is True, if destination path is exists, remove it, than move.
'''
# newName analize
if not os.path.isdir(newDirname):
os.mkdirs(newDirname)
dirname = os.path.dirname(self.__path)
if newDirname is None:
newDirname = dirname
if newName is None:
newName = os.path.basename(self.__path)
analizePathPattern = re.compile(self.__regex)
newNameResult = analizePathPattern.match(newName)
if newNameResult:
result = analizePathPattern.match(os.path.basename(self.__path))
for num in self.__frames:
fileName = ''.join(
(result.group(1), str(seq2num(num, result.group(2))),
result.group(5)))
newName = ''.join((newNameResult.group(1),
str(seq2num(num, newNameResult.group(2))),
newNameResult.group(5)))
if newName != fileName or newDirname != dirname:
if os.path.exists(os.path.join(newDirname, newName)):
if replace:
try:
os.remove(os.path.join(newDirname, newName))
yl.warning('destination is exists ,remove it')
except Exception, e:
yl.error(e.message)
else:
yl.warning(
'copy failed, destination is exists, pass')
continue
try:
shutil.copyfile(os.path.join(dirname, fileName),
os.path.join(newDirname, newName))
except Exception, e:
yl.error(e.message)
yl.debug('copy file: {} => {}'.format(fileName, newName))
else:
yl.warning(
'copy failed, destination name is the same as source name'
)
def createNode(self, node, caller):
yl.debug('create node: %s in treeview' % node.getName())
parent = node.getParent()
if parent is not None:
# yl.debug('parent is %s' % parent.getName())
parentIndex = self.getIndexFromNode(parent)
# yl.debug('parent index is %s' % parentIndex.row())
i = node.getIndex()
# selection = QtCore.QItemSelection(self._parent.selectionModel().selection())
self.beginInsertRows(parentIndex, i, i)
if parentIndex.isValid():
yl.debug('insert index: %d' % i)
self.insertRow(i, parentIndex)
else:
self.insertRow(i, QtCore.QModelIndex())
self.endInsertRows()
def getFilesInSpace(self, spaceItem):
global searchNodes
# perNodeClassCallback
callbackType = 2
yl.debug('get node class')
for index, node in enumerate(searchNodes):
pi = pkgItem(parent=spaceItem,
value=node[0],
status=pkgStatus.NORMAL,
itemtype=pkgItemType.NODECLASS,
pos=index)
pi.setNodePath('.'.join((spaceItem.getNodePath(), pi.getValue())))
yl.debug('create node class: %s' % pi.getValue())
self.callback(pi, callbackType)
spaceItem.appendItem(pi)
self.getNodeFilePath(pi, node[1], node[2], node[3])
def printNodeTree(self, space=None, level=0):
yl.debug('print node tree')
if space is None:
space = self.rootNode
print '\nroot'
children = space.getChildren()
if len(children) > 0:
prefix = '│' * (level != 0) + ' ' * level
for index, child in enumerate(children):
if index == len(children) - 1:
print '%-60s%s' % (prefix + '└─' + child.getName(),
str(child.getSelection()))
elif index != len(children):
print '%-60s%s' % (prefix + '├─' + child.getName(),
str(child.getSelection()))
if child.getNode().Class() == 'Group':
self.printNodeTree(child, level + 1)
def setCurrentWidget(self, old, new):
if new:
w = new
while True:
n = w.windowTitle()
pw = w.parent()
if n:
if n in ytVariables.ytNukeWidgets.yt_widgets:
ytVariables.ytNukeWidgets.yt_current_widget = n
yl.debug('go into {}'.format(n))
elif 'Viewer' in n:
ytVariables.ytNukeWidgets.yt_current_widget = 'Viewer'
yl.debug('go into {}'.format(n))
return None
elif pw:
w = pw
else:
return None
