Source Code for Module nukescripts.misc

  1  # Copyright (c) 2009 The Foundry Visionmongers Ltd.  All Rights Reserved. 
  2   
  3  import nuke, nukescripts 
  4  import random 
  5  import os 
  6  import textwrap 
  7   
  8   
  9 -def copy_knobs(args): 
 10    g1 = nuke.thisGroup() 
 11    selNodes = g1.selectedNodes() 
 12   
 13    g2 = nuke.nodes.Group(name = "____tempcopyknobgroup__") 
 14    with g2: 
 15      nuke.nodePaste(nukescripts.cut_paste_file()) 
 16   
 17    excludedKnobs = ["name", "xpos", "ypos"] 
 18   
 19    try: 
 20      nodes = g2.nodes() 
 21      for i in g2.nodes(): 
 22        for j in selNodes: 
 23          k1 = i.knobs() 
 24          k2 = j.knobs() 
 25          intersection = dict([(item, k1[item]) for item in k1.keys() if item not in excludedKnobs and k2.has_key(item)]) 
 26          for k in intersection.keys(): 
 27            x1 = i[k] 
 28            x2 = j[k] 
 29            x2.fromScript(x1.toScript()) 
 30    except Exception as e: 
 31      nuke.delete(g2) 
 32      raise e 
 33    nuke.delete(g2) 
 34   
 35   
 36 -def connect_selected_to_viewer(inputIndex): 
 37    """Connects the selected node to the given viewer input index, ignoring errors if no node is selected.""" 
 38   
 39    selection = None 
 40    try: 
 41      selection = nuke.selectedNode() 
 42    except ValueError:  # no node selected 
 43      pass 
 44   
 45    if selection is not None and selection.Class() == 'Viewer': 
 46      selection = None 
 47   
 48    nuke.connectViewer(inputIndex, selection) 
 49   
 50   
 51 -def toggle_monitor_output(): 
 52    """Toggles monitor output (switches it on if it's off, or vice versa) for the currently active viewer.""" 
 53    viewer = nuke.activeViewer() 
 54    if viewer is not None: 
 55      enableKnob = viewer.node().knob('MonitorOutEnable') 
 56      enableKnob.setValue(not enableKnob.value()) 
 57   
 58   
 59 -def clear_selection_recursive(group = nuke.root()): 
 60    """Sets all nodes to unselected, including in child groups.""" 
 61    for n in group.selectedNodes(): 
 62      n.setSelected(False) 
 63    groups = [i for i in group.nodes() if i.Class() == 'Group'] 
 64    for i in groups: 
 65      clear_selection_recursive(i) 
 66   
 67   
 68 -def goofy_title(): 
 69    """Returns a random message for use as an untitled script name. 
 70    Can be assigned to nuke.untitled as a callable. 
 71    Put a goofy_title.txt somewhere in your NUKE_PATH to customise.""" 
 72   
 73    goofyFile = None 
 74    for dir in nuke.pluginPath(): 
 75        fileName = os.path.join(dir, "goofy_title.txt") 
 76        if os.path.exists(fileName): 
 77            goofyFile = fileName 
 78            break 
 79   
 80    if goofyFile is None: 
 81        return "Missing goofy_title.txt" 
 82   
 83    file = open(goofyFile) 
 84    lines = file.readlines() 
 85    file.close() 
 86   
 87    lines = [line.strip() for line in lines] 
 88    lines = [line for line in lines if len(line) > 0 and line[0] != '#'] 
 89   
 90    if len(lines) < 1: 
 91      return "Empty goofy_title.txt" 
 92   
 93    return random.choice(lines) 
 94   
 95   
 96 -def declone(node): 
 97    if node.clones() == 0: 
 98      return 
 99    args = node.writeKnobs(nuke.WRITE_ALL | nuke.WRITE_USER_KNOB_DEFS | nuke.WRITE_NON_DEFAULT_ONLY | nuke.TO_SCRIPT) 
100    newnode = nuke.createNode(node.Class(), knobs = args) 
101    nuke.inputs(newnode, nuke.inputs(node)) 
102    num_inputs = nuke.inputs(node) 
103    for i in range(num_inputs): 
104       newnode.setInput(i, node.input(i)) 
105    node.setInput(0, newnode) 
106    nuke.delete(node) 
107   
108   
109 -def showname(): 
110    '''Shows the current script path and, if the selected node is a Read or Write node, the filename from it.''' 
111   
112    # get the nuke script path 
113    # we always need this 
114    nukescript = nuke.value("root.name") 
115   
116    # look if there is a selected node 
117    # if not, output the script only 
118    p = nuke.Panel("Current Info", 500) 
119    try: 
120      n = nuke.selectedNode() 
121      if n.Class() == "Read" or n.Class() == "Write": 
122        a = nuke.value(n.name()+".first", nuke.value("root.first_frame")) 
123        b = nuke.value(n.name()+".last", nuke.value("root.last_frame")) 
124        curfile = n.knob("file").value()+" "+str(a)+"-"+str(b) 
125        p.addSingleLineInput("Filename", curfile) 
126        p.addSingleLineInput("Script", nukescript) 
127        p.show() 
128      else: 
129        p.addSingleLineInput("Script", nukescript) 
130        p.show() 
131    except: 
132      p.addSingleLineInput("Script", nukescript) 
133      p.show() 
134   
135   
136 -def swapAB(n): 
137    """Swaps the first two inputs of a node.""" 
138   
139    if max(n.inputs(), n.minimumInputs()) > 1: 
140      a = n.input(0) 
141      n.setInput(0, n.input(1)) 
142      n.setInput(1, a) 
143   
144   
145 -def print_callback_info(verbose=False, callbackTypes=None): 
146    """ 
147    Returns a list of all currently active callbacks, with the following optional 
148    arguments: 
149        verbose=False      : prints the documentation as well as the callback 
150        callbackTypes=None : limit the callback info to a particular callback 
151                             type (e.g. ['OnCreates']) 
152    """ 
153    # list of all callback types 
154    all_Callback_Types = [ 'onUserCreates', 
155                           'onCreates', 
156                           'onScriptLoads', 
157                           'onScriptSaves', 
158                           'onScriptCloses', 
159                           'onDestroys', 
160                           'knobChangeds', 
161                           'updateUIs', 
162                           'autolabels', 
163                           'beforeRenders', 
164                           'beforeFrameRenders', 
165                           'afterRenders', 
166                           'afterFrameRenders', 
167                           'renderProgresses', 
168                           'filenameFilters', 
169                           'validateFilenames', 
170                           'autoSaveFilters', 
171                           'autoSaveRestoreFilters', 
172                           'autoSaveDeleteFilters', 
173                        ] 
174   
175    #if no callbackTypes defined or is an invalid type, then default search all callback types 
176    is_valid_type = (type(callbackTypes) is dict) or (type(callbackTypes) is list) 
177    if ( not callbackTypes or (not is_valid_type ) ): 
178      callbackTypes = all_Callback_Types 
179   
180    callback_defs = {} 
181   
182    for callbackType in callbackTypes: 
183      callback_defs[callbackType] = eval('nuke.%s' %(callbackType)) 
184   
185    # find the max target name length 
186    maxTargetNameLen = max( map( len,' '.join( [ (k+'').join( callback_defs[k].keys() ) for k in callback_defs.keys() ] ).split(' ') ) ) 
187   
188    indent = (maxTargetNameLen+8)*' ' 
189   
190    sortedCallbackTypes = sorted( callback_defs.keys() ) 
191    for callbackType in sortedCallbackTypes: 
192      for callbackTarget in callback_defs[callbackType].keys(): 
193        for func, a, b, c in callback_defs[callbackType][callbackTarget]: 
194          id = '%s%s%s : '%(callbackType[:-1],'_'*(maxTargetNameLen-len(callbackType)-len(callbackTarget)+1),callbackTarget) 
195          print '%s%s' %(id, func.__name__) 
196          if verbose: 
197            doc = func.__doc__ 
198            if not doc: 
199              doc='NO DOCUMENTATION' 
200            docNoReturns = str(doc).lstrip().replace('\n','') 
201            docNoConsecutiveSpaces = " ".join(docNoReturns.split()) 
202            docWrappedText = textwrap.wrap(docNoConsecutiveSpaces, 60) 
203            for line in docWrappedText: 
204              print indent + line.replace('\n', '\n' + indent) 
205