def dock_in_nuke():
import nuke
from nukescripts import panels
pane = nuke.getPaneFor("io.cyclopsvfx.Brontes_nuke")
panels.registerWidgetAsPanel('nuke_brontes.Brontes_nuke', 'Brontes_nuke',
'io.cyclopsvfx.Brontes_nuke',
True).addToPane(pane)
def quickSubmit():
for widget in QtGui.QApplication.allWidgets():
name = widget.objectName()
if 'SubmissionWindow' in name:
widget.deleteLater()
pane = nuke.getPaneFor('Properties.1')
panels.registerWidgetAsPanel('showUI.SubmissionWindow', '腾清素材上传_NUKE', 'uk.co.thefoundry.SubmissionWindow', True).addToPane(pane)
def addKnobScripterPanel():
global knobScripterPanel
try:
knobScripterPanel = panels.registerWidgetAsPanel(moduleName + 'KnobScripterPane', 'Knob Scripter',
'com.adrianpueyo.KnobScripterPane')
knobScripterPanel.addToPane(nuke.getPaneFor('Properties.1'))
except:
knobScripterPanel = panels.registerWidgetAsPanel(moduleName + 'KnobScripterPane', 'Knob Scripter', 'com.adrianpueyo.KnobScripterPane')
def run():
## make this work in a .py file and in 'copy and paste' into the script editor
moduleName = __name__
if moduleName == '__main__':
moduleName = ''
else:
moduleName = moduleName + '.'
pane = nuke.getPaneFor('Properties.1')
panels.registerWidgetAsPanel(moduleName + 'NukeConnectGui', 'Jeeves Connect', 'uk.co.thefoundry.NukeConnectGui', True).addToPane(pane)
def main():
if not nuke.getPaneFor('HCom-guillaumej'):
pane = nuke.getPaneFor('Properties.1')
panels.registerWidgetAsPanel( __name__ + '.HComLauncherPanelWidget', 'HCom', 'HCom-guillaumej', create=True).addToPane(pane)
t = threading.Thread(target=checkForHCom)
t.start()
else:
nuke.message('HCom already opened')
def main():
if not nuke.getPaneFor('HCom-guillaumej'):
pane = nuke.getPaneFor('Properties.1')
panels.registerWidgetAsPanel(__name__ + '.HComLauncherPanelWidget',
'HCom',
'HCom-guillaumej',
create=True).addToPane(pane)
t = threading.Thread(target=checkForHCom)
t.start()
else:
nuke.message('HCom already opened')
def get_nuke_dock_widget():
from nukescripts import panels
import nuke
# delete existing dock
for obj in QtWidgets.QApplication.allWidgets():
if obj.objectName() == "tapp.dock":
obj.deleteLater()
pane = nuke.getPaneFor("Properties.1")
panel = panels.registerWidgetAsPanel("tapp.docked_widget.Dock",
"Tapp",
"tapp.dock",
True).addToPane(pane)
return panel.customKnob.getObject().widget
def runNuke():
moduleName = __name__
if moduleName == '__main__':
moduleName = ''
else:
moduleName = moduleName + '.'
dockedWindow = False # Edit this to change between docked window and free floating window (DOES NOT WORK PROPERLY AT THE MOMENT)
if dockedWindow:
pane = nuke.getPaneFor('Properties.1')
panel = panels.registerWidgetAsPanel( moduleName + 'MediaViewer' , windowTitle, ('uk.co.thefoundry.'+windowObject+'Window'), True).addToPane(pane) # View pane and add it to panes menu
global gui
gui = panel.customKnob.getObject().widget
else:
global gui
gui = MediaViewer()
gui.show()
def runNuke():
moduleName = __name__
if moduleName == '__main__':
moduleName = ''
else:
moduleName = moduleName + '.'
global gui
if launchAsPanel:
pane = nuke.getPaneFor('Properties.1')
panel = panels.registerWidgetAsPanel(
moduleName + 'SearchReplace', windowTitle,
('uk.co.thefoundry.' + windowObject + 'Window'),
True).addToPane(pane) # View pane and add it to panes menu
gui = panel.customKnob.getObject().widget
else:
gui = SearchReplace()
gui.show()
def runNuke():
moduleName = __name__
if moduleName == '__main__':
moduleName = ''
else:
moduleName = moduleName + '.'
global gui
if launchAsPanel:
pane = nuke.getPaneFor('Properties.1')
panel = panels.registerWidgetAsPanel( moduleName + 'Main' , windowTitle, ('uk.co.thefoundry.'+windowObject+'Window'), True).addToPane(pane) # View pane and add it to panes menu
gui = panel.customKnob.getObject().widget
else:
if parentToNukeMainWindow:
gui = Main( parent=QtGui.QApplication.activeWindow() )
else:
gui = Main()
#gui.setWindowModality(QtCore.Qt.WindowModal) # Set modality
gui.show()
def main():
scriptsDir=os.path.dirname(__file__)
parentScriptsDir=os.path.dirname(scriptsDir)
cacheManagerDir=parentScriptsDir+'/mlCacheManager'
#del sys.modules['shotManager']
sys.path.append(cacheManagerDir)
from nukescripts import panels
nuke.pluginAddPath(cacheManagerDir)
import cacheManager
reload(cacheManager)
from cacheManager import NukeTestWindow
win=panels.registerWidgetAsPanel('cacheManager.NukeTestWindow', 'cacheManager', 'farts', True)
pane = nuke.getPaneFor('Properties.1')
#pane = nuke.getPaneFor('DAG.1')
#win.show()
win.addToPane(pane)
def runNuke():
moduleName = __name__
if moduleName == '__main__':
moduleName = ''
else:
moduleName = moduleName + '.'
dockedWindow = False # Edit this to change between docked window and free floating window (DOES NOT WORK PROPERLY AT THE MOMENT)
if dockedWindow:
pane = nuke.getPaneFor('Properties.1')
panel = panels.registerWidgetAsPanel(
moduleName + 'MediaViewer', windowTitle,
('uk.co.thefoundry.' + windowObject + 'Window'),
True).addToPane(pane) # View pane and add it to panes menu
global gui
gui = panel.customKnob.getObject().widget
else:
global gui
gui = MediaViewer()
gui.show()
def runNuke():
moduleName = __name__
if moduleName == '__main__':
moduleName = ''
else:
moduleName = moduleName + '.'
global gui
if launchAsPanel:
pane = nuke.getPaneFor('Properties.1')
panel = panels.registerWidgetAsPanel(
moduleName + 'HelloWorld', windowTitle,
('uk.co.thefoundry.' + windowObject + 'Window'),
True).addToPane(pane) # View pane and add it to panes menu
gui = panel.customKnob.getObject().widget
else:
if parentToNukeMainWindow:
gui = HelloWorld(parent=QtGui.QApplication.activeWindow())
else:
gui = HelloWorld()
#gui.setWindowModality(QtCore.Qt.WindowModal) # Set modality
gui.show()
def main():
shotManagerDir = os.path.dirname(mlTools.__file__).replace(
"\\", "/") + '/mlShotManager'
#del sys.modules['shotManager']
sys.path.append(shotManagerDir)
from nukescripts import panels
nuke.pluginAddPath(shotManagerDir)
from mlTools.mlShotManager import shotManager
reload(shotManager)
from shotManager import shotManagerWindow
win = panels.registerWidgetAsPanel(
'mlTools.mlShotManager.shotManager.shotManagerWindow', 'shotManager',
'farts', True)
pane = nuke.getPaneFor('Viewer.1')
#pane = nuke.getPaneFor('Properties.1')
#pane = nuke.getPaneFor('DAG.1')
#win.show()
win.addToPane(pane)
def main():
scriptsDir = os.path.dirname(__file__)
parentScriptsDir = os.path.dirname(scriptsDir)
autoCompDir = parentScriptsDir + '/mlAutoComp'
sys.path.append(autoCompDir)
from nukescripts import panels
nuke.pluginAddPath(autoCompDir)
import autoComp
reload(autoComp)
from autoComp import nukeAutoCompWindow
win = panels.registerWidgetAsPanel('autoComp.nukeAutoCompWindow',
'autoComp', 'farts', True)
pane = nuke.getPaneFor('Viewer.1')
#pane = nuke.getPaneFor('Properties.1')
#pane = nuke.getPaneFor('DAG.1')
#win.show()
win.addToPane(pane)
def showTools():
pane = nuke.getPaneFor('Properties.1')
panels.registerWidgetAsPanel('WatermarkControlPanel', 'Watermark Tools', 'uk.co.thefoundry.WatermarkControlPanel', True).addToPane(pane)
rugbyBugsRenderReconstructMenu.addCommand(
'Reconstruct Data Elements',
lambda: rbRenderReconstruct.RbRenderReconstruct().reconstructDataREs())
rugbyBugsRenderReconstructMenu.addCommand(
'Reconstruct Multi Matte Elements',
lambda: rbRenderReconstruct.RbRenderReconstruct().reconstructMultiMatteREs(
))
rugbyBugsRenderReconstructMenu.addCommand(
'Reconstruct Shadow Elements',
lambda: rbRenderReconstruct.RbRenderReconstruct().reconstructShadowREs())
#Create RugbyBugs Ui (Pane)
#------------------------------------------------------------------
#registerWidgetAsPanel
panels.registerWidgetAsPanel('rugbyBugsNukeInterface.RugbyBugsNukeInterface',
'RugbyBugsUi', 'uk.co.thefoundry.NukeTestWindow')
#Import and execute Carls Startup scripts
#------------------------------------------------------------------
#import and execute rbNukeStartupCarl module
try:
#import
from rugbyBugs.nuke.rbNukeStartupCarl import rbNukeStartupCarl
if (doReload): reload(rbNukeStartupCarl)
#execute
nuke.addOnScriptLoad(
rbNukeStartupCarl.RbNukeStartupCarl().createInitialSetup)
nuke.tprint('Successfully loaded and executed Carls startup scripts')
# -*- coding:utf-8 -*-
__date__ = '2017/4/5 13:46'
__author__ = 'liaokong'
from CommonToolkit import CommonToolkit
from nukescripts import panels
from PyDropping import PyDropping
import nukescripts
nukescripts.addDropDataCallback(PyDropping)
panels.registerWidgetAsPanel('CommonToolkit', u'预设工具', "example.test.panel",
True)
def myinit():
try:
from nukescripts import panels
panels.registerWidgetAsPanel('__import__("add_clip").OpenClipWindow', 'Open Clip', 'im.cmc.OpenClipWindow')
except:
debug("Couldn't register panel")
def show(cls, self, *args, **kwargs):
"""Show the Nuke window."""
# Window is already initialised
if self is not cls:
if self.dockable():
return None
return super(NukeWindow, self).show()
#Close down any instances of the window
try:
cls.clearWindowInstance(cls.WindowID)
except AttributeError:
settings = {}
else:
settings = getWindowSettings(cls.WindowID)
#Load settings
try:
nukeSettings = settings['nuke']
except KeyError:
nukeSettings = settings['nuke'] = {}
if hasattr(cls, 'WindowDockable'):
docked = cls.WindowDockable
else:
try:
docked = nukeSettings['docked']
except KeyError:
try:
docked = cls.WindowDefaults['docked']
except (AttributeError, KeyError):
docked = True
dockOverride = False
if docked:
# Attempt to find the module in the global scope
# If it can't be found, then it can't be docked
namespace = searchGlobals(cls)
if namespace is None:
docked = cls.WindowDockable = False
dockOverride = True
#Return new class instance and show window
if docked:
try:
pane = Pane.get(nukeSettings['dock']['panel']) or Pane.auto()
except KeyError:
pane = Pane.auto()
# Set WindowID if needed but disable saving
class WindowClass(cls):
if not hasattr(cls, 'WindowID'):
WindowID = uuid.uuid4().hex
def enableSaveWindowPosition(self, enable):
return super(WindowClass, self).enableSaveWindowPosition(False)
panel = panels.registerWidgetAsPanel(
widget=namespace,
name=getattr(WindowClass, 'WindowName', 'New Window'),
id=WindowClass.WindowID,
create=True,
)
panel.addToPane(pane)
panelObject = panel.customKnob.getObject()
if panelObject is not None:
widget = panelObject.widget
_removeMargins(widget)
widget.deferred(widget.windowReady.emit)
return widget
kwargs['dockable'] = False
win = super(NukeWindow, cls).show(*args, **kwargs)
if dockOverride:
cls.WindowDockable = True
win.setDockable(True, override=True)
return win
def populate_ftrack(self):
import nuke
import legacy
from nukescripts import panels
from ftrack_connect_nuke.connector import Connector
# Check if QtWebKit or QWebEngine is avaliable.
from FnAssetAPI.ui.toolkit import is_webwidget_supported
has_webwidgets = is_webwidget_supported()
Connector.registerAssets()
# wrappers for initializing the widgets with
# the correct connector object
def wrapImportAssetDialog(*args, **kwargs):
from ftrack_connect.ui.widget.import_asset import FtrackImportAssetDialog
return FtrackImportAssetDialog(connector=Connector())
def wrapAssetManagerDialog(*args, **kwargs):
from ftrack_connect.ui.widget.asset_manager import FtrackAssetManagerDialog
return FtrackAssetManagerDialog(connector=Connector())
# Populate the ui
nukeMenu = nuke.menu("Nuke")
ftrackMenu = nukeMenu.addMenu("&ftrack")
ftrackMenu.addSeparator()
# add ftrack publish node to the menu
ftrackMenu.addCommand('Create Publish Node',
lambda: legacy.createFtrackPublish())
ftrackMenu.addSeparator()
globals()['ftrackImportAssetClass'] = wrapImportAssetDialog
panels.registerWidgetAsPanel(
'{0}.{1}'.format(__name__, 'ftrackImportAssetClass'),
'ftrackImportAsset', 'ftrackDialogs.ftrackImportAssetDialog')
ftrackMenu.addSeparator()
ftrackMenu.addCommand(
'Import Asset', 'pane = nuke.getPaneFor("Properties.1");'
'panel = nukescripts.restorePanel("ftrackDialogs.ftrackImportAssetDialog");'
'panel.addToPane(pane)')
globals()['ftrackAssetManagerDialogClass'] = wrapAssetManagerDialog
# Create the asset manager dialog entry in the menu
panels.registerWidgetAsPanel(
'{0}.{1}'.format(__name__, 'ftrackAssetManagerDialogClass'),
'ftrackAssetManager', 'ftrackDialogs.ftrackAssetManagerDialog')
ftrackMenu.addCommand(
'Asset Manager', 'pane = nuke.getPaneFor("Properties.1");'
'panel = nukescripts.restorePanel("ftrackDialogs.ftrackAssetManagerDialog");'
'panel.addToPane(pane)')
if has_webwidgets:
def wrapAssetInfoDialog(*args, **kwargs):
from ftrack_connect_nuke.ui.widget.info_view import AssetInfoView
return AssetInfoView(bridge=self._bridge)
globals()['ftrackAssetInfoDialogClass'] = wrapAssetInfoDialog
# Create the crew dialog entry in the menu
panels.registerWidgetAsPanel(
'{0}.{1}'.format(__name__, 'ftrackAssetInfoDialogClass'),
'ftrackAssetInfo', 'ftrackDialogs.ftrackAssetInfoDialog')
ftrackMenu.addCommand(
'Asset Info', 'pane = nuke.getPaneFor("Properties.1");'
'panel = nukescripts.restorePanel("ftrackDialogs.ftrackAssetInfoDialog");'
'panel.addToPane(pane)')
ftrackMenu.addSeparator()
if has_webwidgets:
from ftrack_connect_foundry.ui.info_view import WorkingTaskInfoView as _WorkingTaskInfoView
from ftrack_connect_foundry.ui.tasks_view import TasksView as _TasksView
# Add Web Views located in the ftrack_connect_foundry package to the
# menu for easier access.
for widget in [_TasksView, _WorkingTaskInfoView]:
ftrackMenu.addCommand(
widget.getDisplayName(),
'pane = nuke.getPaneFor("Properties.1");'
'panel = nukescripts.restorePanel("{identifier}");'
'panel.addToPane(pane)'.format(
identifier=widget.getIdentifier()))
ftrackMenu.addSeparator()
# Add new entries in the ftrack menu.
ftrackMenu.addSeparator()
if has_webwidgets:
from ftrack_connect_nuke.ui.widget.publish_gizmo import GizmoPublisherDialog
ftrackMenu.addCommand('Publish gizmo', GizmoPublisherDialog)
# Add ftrack publish node
toolbar = nuke.toolbar("Nodes")
ftrackNodesMenu = toolbar.addMenu("ftrack", icon="ftrack_logo.png")
ftrackNodesMenu.addCommand('ftrackPublish',
lambda: legacy.createFtrackPublish())
# Set calbacks
def asset_info_menu_switch():
'''Enable and disable asset info depending on selection.'''
this_node = nuke.thisNode()
# Do not continue if selection is not node.
if not isinstance(this_node, nuke.Node):
return
try:
is_ftrack = this_node.knob('assetVersionId')
except ValueError:
is_ftrack = False
nuke_menu = nuke.menu('Nuke')
menu_item = nuke_menu.findItem('&ftrack')
asset_info_menu = menu_item.findItem('Asset Info')
if has_webwidgets and asset_info_menu:
if is_ftrack:
asset_info_menu.setEnabled(True)
else:
asset_info_menu.setEnabled(False)
nuke.addKnobChanged(asset_info_menu_switch)
# other callbacks
nuke.addOnScriptLoad(legacy.refAssetManager)
nuke.addOnScriptLoad(legacy.scan_for_new_assets)
nuke.addOnUserCreate(legacy.addFtrackComponentField, nodeClass='Write')
nuke.addOnUserCreate(legacy.addFtrackComponentField,
nodeClass='WriteGeo')
nuke.addOnUserCreate(legacy.addFtrackComponentField, nodeClass='Read')
nuke.addKnobChanged(legacy.ftrackPublishKnobChanged, nodeClass="Group")
nuke.addOnCreate(legacy.ftrackPublishHieroInit)
# Set default values from environments.
start_frame = os.environ.get('FS', 0)
end_frame = os.environ.get('FE', 100)
FnAssetAPI.logging.debug(
'Setting start frame : {}'.format(start_frame))
nuke.knob('root.first_frame', str(start_frame))
FnAssetAPI.logging.debug('Setting end frame : {}'.format(end_frame))
nuke.knob('root.last_frame', str(end_frame))
saveAllTask_btn.clicked.connect(self.saveTodoList)
showAllTask_btn.clicked.connect(self.printTaskUI)
self.show()
def addTaskUI(self):
'''
Adds a layout being composed of a QLineEdit, a TaskProgressBar, and a button to reset the task
'''
taskUI = TaskUI(parent = self)
self.layoutMain.addLayout(taskUI.getLayout())
self.allTasksUI.append(taskUI)
def saveTodoList(self, listTaskUI):
# for i in list
pass
def printTask(self):
for i in range(self.layoutMain.count()):
sublayout = self.layoutMain.itemAt(i)
for s in range(sublayout.count()):
print type(sublayout.itemAt(s))
print s
def printTaskUI(self):
for task in self.allTasksUI:
print task.getTaskFromUI()
ui = ToDoListUI()
panels.registerWidgetAsPanel('ToDoListUI', 'TodoList', 'fr.victor.ToDoListUI')
self.setPixmap(QtGui.QPixmap(self.imageFile))
#----------------------------------------------------------------------------------------------------------
#Floating Panel
#----------------------------------------------------------------------------------------------------------
scaleTreeWidgetInstance = None
def ScaleTree():
global scaleTreeWidgetInstance
if scaleTreeWidgetInstance != None:
try:
scaleTreeWidgetInstance.close()
except:
pass
scaleTreeWidgetInstance = scaleTreeWidget()
scaleTreeWidgetInstance.show()
#----------------------------------------------------------------------------------------------------------
#Docked Panel
#----------------------------------------------------------------------------------------------------------
panels.registerWidgetAsPanel('mod_ScaleTree.scaleTreeWidget', 'W_scaleTree',
'W_scaleTree.widget')
#----------------------------------------------------------------------------------------------------------
def show(cls, namespace=None, *args, **kwargs):
"""Show the Nuke window.
IMPORTANT:
If using the dockable window, then the namespace needs to be set.
This is simply a string of how the window is called, such as "module.MyWindow.show(namespace='module.MyWindow')".
It's not ideal and can't be error checked, but it's required for the time being.
"""
#Close down any instances of the window
try:
cls.clearWindowInstance(cls.WindowID)
except AttributeError:
settings = {}
else:
settings = getWindowSettings(cls.WindowID)
#Load settings
try:
nukeSettings = settings['nuke']
except KeyError:
nukeSettings = settings['nuke'] = {}
if hasattr(cls, 'WindowDockable'):
docked = cls.WindowDockable
else:
try:
docked = nukeSettings['docked']
except KeyError:
try:
docked = cls.WindowDefaults['docked']
except (AttributeError, KeyError):
docked = True
#Return new class instance and show window
if docked:
try:
pane = Pane.get(nukeSettings['dock']['panel']) or Pane.auto()
except KeyError:
pane = Pane.auto()
try:
panel = panels.registerWidgetAsPanel(
widget=namespace or cls.__name__,
name=getattr(cls, 'WindowName', 'New Window'),
id=cls.WindowID,
create=True,
)
panel.addToPane(pane)
#Handle errors
except AttributeError:
if namespace is None:
raise NameError(
'namespace is not set, use a syntax like module.window.show(namespace="module.window") to fix'
)
else:
raise NameError(
'invalid class or namespace "{}"'.format(namespace))
except TypeError:
raise TypeError(
'invalid class or namespace "{}"'.format(namespace))
else:
panel_obj = panel.customKnob.getObject()
if panel_obj is not None:
widget = panel_obj.widget
_removeMargins(widget)
return widget
return super(NukeWindow, cls).show(*args, **kwargs)
def show(cls, self, *args, **kwargs):
"""Show the Nuke window.
IMPORTANT:
If using the dockable window, then the namespace needs to be set.
This is simply a string of how the window is called, such as "module.MyWindow.show(namespace='module.MyWindow')".
It's not ideal and can't be error checked, but it's required for the time being.
"""
# Window is already initialised
if self is not cls:
if self.dockable():
return None
return super(NukeWindow, self).show()
#Close down any instances of the window
try:
cls.clearWindowInstance(cls.WindowID)
except AttributeError:
settings = {}
else:
settings = getWindowSettings(cls.WindowID)
#Load settings
try:
nukeSettings = settings['nuke']
except KeyError:
nukeSettings = settings['nuke'] = {}
if hasattr(cls, 'WindowDockable'):
docked = cls.WindowDockable
else:
try:
docked = nukeSettings['docked']
except KeyError:
try:
docked = cls.WindowDefaults['docked']
except (AttributeError, KeyError):
docked = True
dockOverride = False
if docked:
# Attempt to find the module in the global scope
# If it can't be found, then it can't be docked
namespace = searchGlobals(cls)
if namespace is None:
docked = cls.WindowDockable = False
dockOverride = True
#Return new class instance and show window
if docked:
try:
pane = Pane.get(nukeSettings['dock']['panel']) or Pane.auto()
except KeyError:
pane = Pane.auto()
panel = panels.registerWidgetAsPanel(
widget=namespace,
name=getattr(cls, 'WindowName', 'New Window'),
id=cls.WindowID,
create=True,
)
panel.addToPane(pane)
panelObject = panel.customKnob.getObject()
if panelObject is not None:
widget = panelObject.widget
_removeMargins(widget)
return widget
kwargs['dockable'] = False
win = super(NukeWindow, cls).show(*args, **kwargs)
if dockOverride:
cls.WindowDockable = True
win.setDockable(True, override=True)
return win
def populate_ftrack(self):
import nuke
import legacy
from nukescripts import panels
from ftrack_connect_nuke.ui.widget.crew import NukeCrew
from ftrack_connect_nuke.connector import Connector
# Check if QtWebKit or QWebEngine is avaliable.
from FnAssetAPI.ui.toolkit import is_webwidget_supported
has_webwidgets = is_webwidget_supported()
Connector.registerAssets()
# wrappers for initializing the widgets with
# the correct connector object
def wrapImportAssetDialog(*args, **kwargs):
from ftrack_connect.ui.widget.import_asset import FtrackImportAssetDialog
return FtrackImportAssetDialog(connector=Connector())
def wrapAssetManagerDialog(*args, **kwargs):
from ftrack_connect.ui.widget.asset_manager import FtrackAssetManagerDialog
return FtrackAssetManagerDialog(connector=Connector())
# Populate the ui
nukeMenu = nuke.menu("Nuke")
ftrackMenu = nukeMenu.addMenu("&ftrack")
ftrackMenu.addSeparator()
# add ftrack publish node to the menu
ftrackMenu.addCommand('Create Publish Node',
lambda: legacy.createFtrackPublish())
ftrackMenu.addSeparator()
globals()['ftrackImportAssetClass'] = wrapImportAssetDialog
panels.registerWidgetAsPanel(
'{0}.{1}'.format(__name__, 'ftrackImportAssetClass'),
'ftrackImportAsset', 'ftrackDialogs.ftrackImportAssetDialog')
ftrackMenu.addSeparator()
ftrackMenu.addCommand(
'Import Asset', 'pane = nuke.getPaneFor("Properties.1");'
'panel = nukescripts.restorePanel("ftrackDialogs.ftrackImportAssetDialog");'
'panel.addToPane(pane)')
globals()['ftrackAssetManagerDialogClass'] = wrapAssetManagerDialog
# Create the asset manager dialog entry in the menu
panels.registerWidgetAsPanel(
'{0}.{1}'.format(__name__, 'ftrackAssetManagerDialogClass'),
'ftrackAssetManager', 'ftrackDialogs.ftrackAssetManagerDialog')
ftrackMenu.addCommand(
'Asset Manager', 'pane = nuke.getPaneFor("Properties.1");'
'panel = nukescripts.restorePanel("ftrackDialogs.ftrackAssetManagerDialog");'
'panel.addToPane(pane)')
if has_webwidgets:
from ftrack_connect_foundry.ui.info_view import InfoView as _InfoView
ftrackMenu.addCommand(
_InfoView.getDisplayName(),
'pane = nuke.getPaneFor("Properties.1");'
'panel = nukescripts.restorePanel("{identifier}");'
'panel.addToPane(pane)'.format(
identifier=_InfoView.getIdentifier()))
ftrackMenu.addSeparator()
if has_webwidgets:
from ftrack_connect_foundry.ui.info_view import WorkingTaskInfoView as _WorkingTaskInfoView
from ftrack_connect_foundry.ui.tasks_view import TasksView as _TasksView
# Add Web Views located in the ftrack_connect_foundry package to the
# menu for easier access.
for widget in [_TasksView, _WorkingTaskInfoView]:
ftrackMenu.addCommand(
widget.getDisplayName(),
'pane = nuke.getPaneFor("Properties.1");'
'panel = nukescripts.restorePanel("{identifier}");'
'panel.addToPane(pane)'.format(
identifier=widget.getIdentifier()))
ftrackMenu.addSeparator()
# Create the crew dialog entry in the menu
panels.registerWidgetAsPanel(
'ftrack_connect_nuke.ui.widget.crew.NukeCrew', 'Crew',
'widget.Crew')
ftrackMenu.addCommand(
'Crew', 'pane = nuke.getPaneFor("Properties.1");'
'panel = nukescripts.restorePanel("widget.Crew");'
'panel.addToPane(pane)')
# Add new entries in the ftrack menu.
ftrackMenu.addSeparator()
if has_webwidgets:
from ftrack_connect_nuke.ui.widget.publish_gizmo import GizmoPublisherDialog
ftrackMenu.addCommand('Publish gizmo', GizmoPublisherDialog)
# Add ftrack publish node
toolbar = nuke.toolbar("Nodes")
ftrackNodesMenu = toolbar.addMenu("ftrack", icon="logobox.png")
ftrackNodesMenu.addCommand('ftrackPublish',
lambda: legacy.createFtrackPublish())
# Set calbacks
nuke.addOnScriptLoad(legacy.refAssetManager)
nuke.addOnScriptLoad(legacy.scan_for_new_assets)
nuke.addOnUserCreate(legacy.addFtrackComponentField, nodeClass='Write')
nuke.addOnUserCreate(legacy.addFtrackComponentField,
nodeClass='WriteGeo')
nuke.addOnUserCreate(legacy.addFtrackComponentField, nodeClass='Read')
nuke.addKnobChanged(legacy.ftrackPublishKnobChanged, nodeClass="Group")
nuke.addOnCreate(legacy.ftrackPublishHieroInit)
class frameSnippetsPanel(QtGui.QWidget):
""""""
def __init__(self, parent=None):
"""Constructor for frameSnippetsPanel"""
super(frameSnippetsPanel, self).__init__(parent)
self.frameButtons ={}
self.data = {}
self.js_data = {}
self.buttonName = None
self.DBpath = None
#====-------------------- 按钮 --------------------====
self.path = QtGui.QLabel('')
self.delmodel = QtGui.QCheckBox('删除模式')
self.addButton = self.createButton("记录当前帧", self.addSnip)
#
self.buttonsLayout = QtGui.QVBoxLayout()
self.buttonsLayout.addWidget(self.path)
self.buttonsLayout.addWidget(self.delmodel)
self.buttonsLayout.addWidget(self.addButton)
self.dynTab = QtGui.QTabWidget()
self.mainLayout = QtGui.QHBoxLayout()
self.mainLayout.addLayout(self.buttonsLayout)
self.mainLayout.addWidget(self.dynTab)
self.setLayout(self.mainLayout)
#====--------------------
self.initDB()
nuke.callbacks.addOnDestroy(self.onDestroyCallback, nodeClass='Viewer')
nuke.callbacks.addOnScriptLoad(self.setDBpath, nodeClass='Root')
def proDataSave(self):
pathfile = self.DBpath
jn_data = json.dumps(self.js_data)
f = open(pathfile,'w')
f.write(jn_data)
f.close()
def proDataLoad(self,pathfile):
f = open(pathfile,'r')
self.js_data = json.loads(f.read())
f.close()
# def proDataSave(self,data):
# assert self.DBpath !=None
# print os.getcwd()
# f = open(self.DBpath,'w')
# pick_data = pick.dump(data,f)
# f.close()
#
#
# def proDataLoad(self):
# assert self.DBpath !=None
# f = open(self.DBpath,'r')
# pick_data = pick.load(f)
# f.close()
# print pick_data
# return pick_data
def initDB(self):
self.setDBpath()
assert self.DBpath !=None
self.path.setText(self.DBpath)
if os.path.exists(self.DBpath):
self.proDataLoad(self.DBpath)
self.loadButtonFromDB()
def loadButtonFromDB(self):
for vName in self.js_data.keys():
for frame,bName in self.js_data[vName]['frame'].iteritems():
self.addSnip(vName,frame,bName)
def setDBpath(self):
fn = self.getFileName()
if fn == '':
fn = os.getenv('NUKE_TEMP_DIR')+'/'
self.DBpath = fn +'_frameSnip.db'
def getFileName(self):
return nuke.toNode('root').knob('name').value()
def onDestroyCallback(self):
vName = nuke.thisNode().name()
if vName in self.data.keys():
bs = self.data[vName]['frame'].values()
for b in bs: del self.frameButtons[b]
self.data[vName]['obj'].deleteLater()
del self.data[vName]
def createButton(self, text, member):
'''创建按钮包装'''
button = QtGui.QPushButton(text)
button.clicked.connect(member)
return button
def remove(self):
nuke.callbacks.removeOnDestroy(self.onCreateCallback, args=(), kwargs={}, nodeClass='Viewer')
print 'remove'
def getName(self):
u'''
弹出命名窗口
'''
inputName = QtGui.QDialog(self)
#
inNameL = QtGui.QLabel('命名')
inNameLE = QtGui.QLineEdit('')
inNameDBB = QtGui.QDialogButtonBox(QtGui.QDialogButtonBox.Save|QtGui.QDialogButtonBox.Cancel)
inputNameMainLay = QtGui.QVBoxLayout()
inputNameMainLay.addWidget(inNameL)
inputNameMainLay.addWidget(inNameLE)
inputNameMainLay.addWidget(inNameDBB)
inputName.setLayout(inputNameMainLay)
callback = partial(self.nameDialogAccept,inNameLE)
inNameDBB.accepted.connect(callback)
inNameDBB.accepted.connect(inputName.accept)
inNameDBB.rejected.connect(self.nameDialogReject)
inNameDBB.rejected.connect(inputName.reject)
inputName.show()
inputName.exec_()
return self.buttonName
def nameDialogAccept(self,LE):
self.buttonName = LE.text()
def nameDialogReject(self):
self.buttonName = None
def frameDo(self):
b = self.sender()
if b is None or not isinstance(b, QtGui.QPushButton):return
if not self.delmodel.isChecked():
vName,frame = self.frameButtons[b]
nuke.toNode(vName).knob('frame').setValue(int(frame))
else:
print 'del'
vName,frame = self.frameButtons.pop(b)
self.data[vName]['frame'].pop(frame).deleteLater()
del self.js_data[vName]['frame'][frame]
self.chkTab(vName)
self.proDataSave()
def chkTab(self,vName):
#print 'keys',self.data[vName]['frame'].keys()
if len(self.data[vName]['frame'].keys()) == 0:
self.data[vName]['obj'].deleteLater()
del self.data[vName]
del self.js_data[vName]
def addSnip(self,vName = None,frame=None,bName = None ):
addFromDB = 1
if vName is None:
addFromDB = 0
vName = nuke.activeViewer().node().name()
if frame is None:
frame = nuke.activeViewer().node().knob('frame').value()
frame = str(int(frame))
if debug:print vName,frame
if vName not in self.data.keys():
frameTabObj = QtGui.QWidget()
frameTabObjLay = QtGui.QHBoxLayout()
frameTabObj.setLayout(frameTabObjLay)
self.dynTab.addTab(frameTabObj,vName)
self.data[vName] = {}
self.js_data[vName] = {}
self.data[vName]['frame'] = {}
self.js_data[vName]['frame'] = {}
self.data[vName]['lay'] = frameTabObjLay
self.data[vName]['obj'] = frameTabObj
if debug:print self.js_data,self.data
if frame not in self.data[vName]['frame'].keys():
if bName is None:bName = self.getName()
if bName != None:
b = self.createButton("%s : %s" % (frame,bName),self.frameDo)
b.setMaximumWidth(300)
self.data[vName]['frame'][frame] = b
self.js_data[vName]['frame'][frame] = bName
self.data[vName]['lay'].addWidget(b)
self.frameButtons[b] = (vName,frame)
if debug:print self.js_data,self.data
if not addFromDB:self.proDataSave()
panels.registerWidgetAsPanel('frameSnippetsPanel', '时间帧收藏', 'uk.co.thefoundry.frameSnippetsPanel')
import nuke
import PySide.QtCore as QtCore
import PySide.QtGui as QtGui
from nukescripts import panels
class NukeTestWindow(QtGui.QWidget):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.setLayout(QtGui.QVBoxLayout())
self.myTable = QtGui.QTableWidget()
self.myTable.header = ['Date', 'Files', 'Size', 'Path' ]
self.myTable.size = [ 75, 375, 85, 600 ]
self.myTable.setColumnCount(len(self.myTable.header))
self.myTable.setHorizontalHeaderLabels(self.myTable.header)
self.myTable.setSelectionMode(QtGui.QTableView.ExtendedSelection)
self.myTable.setSelectionBehavior(QtGui.QTableView.SelectRows)
self.myTable.setSortingEnabled(1)
self.myTable.sortByColumn(1, QtCore.Qt.DescendingOrder)
self.myTable.setAlternatingRowColors(True)
self.myTable.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.myTable.setRowCount(50)
self.layout().addWidget(self.myTable)
self.myTable.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding))
self.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding))
nuke_tw = panels.registerWidgetAsPanel('gear.NukeTestWindow', 'Test table panel', 'uk.co.max.NukeTestWindow', True)
def load_nuke_test_window():
pane = nuke.getPaneFor('DAG.1')
nuke_tw.addToPane(pane)
# Hack - need a better way for nuke to know it is running inside NukeStudio
isNukeStudio = nuke.env['studio']
nuke.pluginAddPath("./icons", addToSysPath=False);
import nukescripts
import nukescripts.toolbars
import nukescripts.snap3d
import nukescripts.cameratracker
import nukescripts.modelbuilder
import nukescripts.applymaterial
from nukescripts import panels
import sampleWindow1 as sw1
panels.registerWidgetAsPanel('sw1.MyWindow', 'MyWindowTitle', 'MyWindowID')
import sampleWindow2 as sw2
def showWindow():
win = sw2.MyWindow()
win.show()
menubar = nuke.menu('Nuke')
menubar.addCommand('MyMenu/MyWindow', showWindow)
# Set up the toolbars.
nukescripts.toolbars.setup_toolbars()
# Menu definitions
# menu_bar.addCommand('Toolkit/CreateShot',CreateShot)
# h=create_shot_UI.Widget
# print h
# win=panels.registerWidgetAsPanel('h', 'create_shot_UI', 'farts', True)
# pane = nuke.getPaneFor('Properties.1')
# win.addToPane(pane)
# return create_shot_UI.Widget
# def CreateShot():
import create_shot_UI
reload(create_shot_UI)
import create_task_UI
reload(create_task_UI)
panels.registerWidgetAsPanel('create_shot_UI.Widget', 'create shot',
'uk.co.thefoundry.Widget')
# pane = nuke.getPaneFor('Properties.1')
# panels.registerWidgetAsPanel('create_shot_UI.Widget', 'create_shot', 'MyWindowsShot', True).addToPane(pane)
panels.registerWidgetAsPanel('create_task_UI.MainWindow', 'create shotTask',
'uk.co.thefoundry.MainWindow')
# pane1 = nuke.getPaneFor('Properties.2')
# panels.registerWidgetAsPanel('create_task_UI.MainWindow', 'create_shotTask', 'MyWindowsTask', True).addToPane(pane1)
# menu_bar = nuke.menu('Nuke')#menu参数是Nuke
# menu_bar.addCommand('Toolkit/CreateShot',CreateShot)
# menu_bar.addCommand('Toolkit/CreateTask',CreateTask)
# menu_bar.addCommand('Toolkit/ExportExcelFile',CreateExcelfie)
# menu_bar.addCommand('Toolkit/SetStatus',SetStatus)
# menu_bar.addCommand('Toolkit/showShotInfo',showShotInfo)
super(self.__class__, self).__init__(parent=parent)
self.setObjectName('TacticDock')
self.setLayout(QtGui.QVBoxLayout())
self.window = lib.ui_main_classes.Ui_Main()
env.Inst.ui_standalone = self.window
self.layout().addWidget(self.window)
self.layout().setSpacing(0)
self.layout().setContentsMargins(0, 0, 0, 0)
self.setSizePolicy(
QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding))
pane = nuke.getPaneFor('Properties.1')
nuke_panel = panels.registerWidgetAsPanel('TacticDock', 'TACTIC handler',
'uk.co.thefoundry.TacticDock',
True).addToPane(pane)
dir(nuke_panel.customKnob.getObject().widgetClass)
print(nuke_panel.customKnob.getObject().widget.parent().parent().parent().
parent().setContentsMargins(-20, -20, -20, -20))
print(nuke_panel.customKnob.getObject(
).widget.parent().parent().parent().parent().parent().parent().parent().parent(
).parent().parent().parent()) # MainWindow QMainWindow
print(nuke_panel.customKnob.getObject(
).widget.parent().parent().parent().parent().parent().parent().parent().parent(
).parent().parent()) # CentralWidget QSplitter
print(nuke_panel.customKnob.getObject().widget.parent().parent().parent(
).parent().parent().parent().parent().parent().parent()) # MainDock QWidget
print(nuke_panel.customKnob.getObject().widget.parent().parent().parent().
parent().parent().parent().parent().parent()) # Self Dock QStackedWidget
import nuke
from nukescripts import panels
import batch_render_front
import file_import
import auto_layout
import LayerShuffler
nuke.menu('Nuke').addCommand("common_func/batch_render_front",
batch_render_front.main)
nuke.menu('Nuke').addCommand("common_func/file_read&write", file_import.run)
nuke.menu('Nuke').addCommand("common_func/auto_layout", auto_layout.main,
"shift+l")
panels.registerWidgetAsPanel("LayerShuffler.LayerShuffler", "Layer Shuffler",
"LayerShufflerPanelId")
bar.addAction( self.webView.pageAction(QWebPage.Reload))
bar.addSeparator()
self.layout().addWidget( bar )
self.layout().addWidget( self.webView )
url = 'http://www.thefoundry.co.uk/'
self.webView.load( QUrl( url ) )
self.locationEdit.setText( url )
self.setSizePolicy( QSizePolicy( QSizePolicy.Expanding, QSizePolicy.Expanding))
#
## make this work in a .py file and in 'copy and paste' into the script editor
moduleName = __name__
if moduleName == '__main__':
moduleName = ''
else:
moduleName = moduleName + '.'
panels.registerWidgetAsPanel( moduleName + 'WebBrowserWidget', 'Web Browser','uk.co.thefoundry.WebBrowserWidget')
except ImportError:
pass
# =======================================================================
# TOOLBAR
# =======================================================================
# Add a menu to the left-hand-side column of icons
#
# nuke.toolbar("Nodes").addCommand("sjm/test", lambda:nuke.message('test'), "Ctrl+Meta+T")
# nuke.toolbar("Nodes").addCommand("sjm/m-over", lambda:nuke.createNode('Merge2','operation over'))
# nuke.toolbar("Nodes").addCommand("sjm/m-under", lambda:nuke.createNode('Merge2','operation under'))
# nuke.toolbar("Nodes").addCommand("sjm/m-screen", lambda:nuke.createNode('Merge2','operation screen'))
# nuke.toolbar("Nodes").addCommand("sjm/m-mask", lambda:nuke.createNode('Merge2','operation mask'))
# nuke.toolbar("Nodes").addCommand("sjm/m-stencil", lambda:nuke.createNode('Merge2','operation stencil'))
class TacticDock(QtGui.QWidget):
def __init__(self, parent=None):
super(self.__class__, self).__init__(parent=parent)
self.setObjectName('TacticDock')
self.setLayout(QtGui.QVBoxLayout())
self.window = lib.ui_main_classes.Ui_Main()
env.Inst.ui_standalone = self.window
self.layout().addWidget(self.window)
self.layout().setSpacing(0)
self.layout().setContentsMargins(0, 0, 0, 0)
self.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding))
pane = nuke.getPaneFor('Properties.1')
nuke_panel = panels.registerWidgetAsPanel('TacticDock', 'TACTIC handler', 'uk.co.thefoundry.TacticDock', True).addToPane(pane)
dir(nuke_panel.customKnob.getObject().widgetClass)
print(nuke_panel.customKnob.getObject().widget.parent().parent().parent().parent().setContentsMargins(-20,-20,-20,-20))
print(nuke_panel.customKnob.getObject().widget.parent().parent().parent().parent().parent().parent().parent().parent().parent().parent().parent()) # MainWindow QMainWindow
print(nuke_panel.customKnob.getObject().widget.parent().parent().parent().parent().parent().parent().parent().parent().parent().parent()) # CentralWidget QSplitter
print(nuke_panel.customKnob.getObject().widget.parent().parent().parent().parent().parent().parent().parent().parent().parent()) # MainDock QWidget
print(nuke_panel.customKnob.getObject().widget.parent().parent().parent().parent().parent().parent().parent().parent()) # Self Dock QStackedWidget
print(nuke_panel.customKnob.getObject().widget.parent().parent().parent().parent().parent().parent().parent()) # Self Dock QDialog
print(nuke_panel.customKnob.getObject().widget.parent().parent().parent().parent().parent().parent()) # Self Dock QScrollArea
scrollAreaContents = QtGui.QWidget()
lay = QtGui.QVBoxLayout(scrollAreaContents)
# lay.addWidget(QtGui.QPushButton('ASSSAAA WIN!'))
lay.addWidget(lib.ui_main_classes.Ui_Main())
scroll_area = nuke_panel.customKnob.getObject().widget.parent().parent().parent().parent().parent().parent()
from nukescripts import panels
from batch_convert.gui import MainGui
panels.registerWidgetAsPanel('MainGui', 'Batch Textures Convert', 'jtomori.BatchTexturesConvertWidget')
#cmds
rugbyBugsRenderReconstructMenu.addCommand( 'Reconstruct all Elements', lambda: rbRenderReconstruct.RbRenderReconstruct().reconstructAll())
rugbyBugsRenderReconstructMenu.addCommand( 'Reconstruct Light Elements', lambda: rbRenderReconstruct.RbRenderReconstruct().reconstructLightREs())
rugbyBugsRenderReconstructMenu.addCommand( 'Reconstruct Framebuffer Elements', lambda: rbRenderReconstruct.RbRenderReconstruct().reconstructFramebufferREs())
rugbyBugsRenderReconstructMenu.addCommand( 'Reconstruct Data Elements', lambda: rbRenderReconstruct.RbRenderReconstruct().reconstructDataREs())
rugbyBugsRenderReconstructMenu.addCommand( 'Reconstruct Multi Matte Elements', lambda: rbRenderReconstruct.RbRenderReconstruct().reconstructMultiMatteREs())
rugbyBugsRenderReconstructMenu.addCommand( 'Reconstruct Shadow Elements', lambda: rbRenderReconstruct.RbRenderReconstruct().reconstructShadowREs())
#Create RugbyBugs Ui (Pane)
#------------------------------------------------------------------
#registerWidgetAsPanel
panels.registerWidgetAsPanel('rugbyBugsNukeInterface.RugbyBugsNukeInterface', 'RugbyBugsUi', 'uk.co.thefoundry.NukeTestWindow')
#Import and execute Carls Startup scripts
#------------------------------------------------------------------
#import and execute rbNukeStartupCarl module
try:
#import
from rugbyBugs.nuke.rbNukeStartupCarl import rbNukeStartupCarl
if(doReload): reload(rbNukeStartupCarl)
def createPanel(self):
pane = nuke.getPaneFor("example.test.panel")
print pane
panels.registerWidgetAsPanel('PanelTest', 'PanelTest',
"example.test.panel",
True).addToPane(pane)
self.urlChanged)
self.layout().addWidget(self.locationEdit)
bar = QToolBar()
bar.addAction(self.webView.pageAction(QWebPage.Back))
bar.addAction(self.webView.pageAction(QWebPage.Forward))
bar.addAction(self.webView.pageAction(QWebPage.Stop))
bar.addAction(self.webView.pageAction(QWebPage.Reload))
bar.addSeparator()
self.layout().addWidget(bar)
self.layout().addWidget(self.webView)
url = 'http://www.thefoundry.co.uk/'
self.webView.load(QUrl(url))
self.locationEdit.setText(url)
self.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding))
## make this work in a .py file and in 'copy and paste' into the script editor
moduleName = __name__
if moduleName == '__main__':
moduleName = ''
else:
moduleName = moduleName + '.'
panels.registerWidgetAsPanel(moduleName + 'WebBrowserWidget', 'Web Browser',
'uk.co.thefoundry.WebBrowserWidget')
index=rowWidget.ui.type_box.findText(a.shotType.shotType)
rowWidget.ui.type_box.setCurrentIndex(index)
rowWidget.ui.notes_edit.setText(c.get_current_submission_note(a))
rowWidget.ui.version_label.setText(c.get_current_submission_version(a))
rowWidget.ui.artist_box.currentIndexChanged.connect(self.modifiedRow)
rowWidget.ui.status_box.currentIndexChanged.connect(self.modifiedRow)
rowWidget.ui.type_box.currentIndexChanged.connect(self.modifiedRow)
listWidgetItem=QListWidgetItem(self.ui.shotsQListWidget)
listWidgetItem.setSizeHint(rowWidget.sizeHint())
self.ui.shotsQListWidget.addItem(listWidgetItem)
self.ui.shotsQListWidget.setItemWidget(listWidgetItem,rowWidget)
if __name__ == '__main__':
qt_app = QApplication(sys.argv)
view =SimpleShotList()
view.show()
qt_app.exec_()
else:
from nukescripts import panels
panels.registerWidgetAsPanel('inhousekeeper.views.SimpleShotList','inHouseKeeper','uk.co.thefoundry.inHouseWindow')
