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