def __init__( self ):
from cgm.lib import guiFactory
guiFactory.initializeTemplates()
USE_Template = 'cgmUITemplate'
self.UI_menu = mUI.MelMenu( l='Setup', pmc=self.buildSetupMenu )
ToolboxTabs( self )
self.show()
def __init__( self ):
from cgm.lib import guiFactory
guiFactory.initializeTemplates()
USE_Template = 'cgmUITemplate'
self.UI_menu = MelMenu( l='Setup', pmc=self.buildSetupMenu )
ToolboxTabs( self )
self.show()
class ToolboxWindow(BaseMelWindow):
from cgm.lib import guiFactory
guiFactory.initializeTemplates()
USE_Template = 'cgmUITemplate'
WINDOW_NAME = 'cgmToolbox'
WINDOW_TITLE = 'cgm.Toolbox'
DEFAULT_SIZE = 300, 300
FORCE_DEFAULT_SIZE = True
DEFAULT_MENU = None
def __init__( self ):
from cgm.lib import guiFactory
guiFactory.initializeTemplates()
USE_Template = 'cgmUITemplate'
self.UI_menu = MelMenu( l='Setup', pmc=self.buildSetupMenu )
ToolboxTabs( self )
self.show()
def buildSetupMenu( self, *a ):
self.UI_menu.clear()
setupMenu = cmd.optionVar( q='cgmVar_ToolboxMainMenu' )
MelMenuItem( self.UI_menu, l="Create cgm Tools Menu", cb=setupMenu, c=lambda *a: cmd.optionVar( iv=('cgmVar_ToolboxMainMenu', not setupMenu) ) )
MelMenuItemDiv( self.UI_menu )
installer = AutoStartInstaller()
MelMenuItem( self.UI_menu, l="Auto-Load On Maya Start", cb=installer.isInstalled(), c=lambda *a: AutoStartInstaller().install() )
class namingToolsClass(BaseMelWindow):
from cgm.lib import guiFactory
guiFactory.initializeTemplates()
USE_TEMPLATE = 'cgmUITemplate'
WINDOW_NAME = 'namingTools'
WINDOW_TITLE = 'cgm.namingTools'
DEFAULT_SIZE = 550, 400
DEFAULT_MENU = None
RETAIN = True
MIN_BUTTON = True
MAX_BUTTON = False
FORCE_DEFAULT_SIZE = True #always resets the size of the window when its re-created
def __init__(self):
""" Hamish, why is this import necessary? It errors out if it isn't here....
I guess I had it it in the mel.eval call before which is what locinator id doing
from cgm.lib import guiFactory
guiFactory.initializeTemplates()
"""
import maya.mel as mel
import maya.cmds as mc
from cgm.lib import (guiFactory, search)
from cgm.tools.lib import (tdToolsLib, locinatorLib)
# Maya version check
if mayaVer >= 2011:
self.currentGen = True
else:
self.currentGen = False
# Basic variables
self.window = ''
self.activeTab = ''
self.toolName = 'namingTools'
self.module = 'tdTools'
self.winName = 'NamingToolsWin'
self.optionVars = []
self.showHelp = False
self.helpBlurbs = []
self.oldGenBlurbs = []
self.showTimeSubMenu = False
self.timeSubMenu = []
# About Window
self.description = 'A large series of tools for general rigging purposes including: Curves, Naming, Positioning,Deformers'
self.author = 'Josh Burton'
self.owner = 'CG Monks'
self.website = 'www.cgmonks.com'
self.version = __version__
# About Window
self.sizeOptions = ['Object', 'Average', 'Input Size', 'First Object']
self.sizeMode = 0
self.forceBoundingBoxState = False
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Build
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#Menu
self.UI_HelpMenu = MelMenu(l='Help', pmc=self.buildHelpMenu)
#Tabs
tabs = MelTabLayout(self)
TabAuto = MelColumnLayout(tabs)
TabStandard = MelColumnLayout(tabs)
#tabs.setCB(lambda *a:self.updateCurrentTab(tabs,'cgmTDToolsWinActiveTab'))
#tabs.setCB(self.updateCurrentTab(tabs,'cgmTDToolsWinActiveTab'))
n = 0
for tab in 'Auto', 'Standard':
tabs.setLabel(n, tab)
n += 1
self.buildAutoNameTool(TabAuto)
self.buildAutoNameTool(TabStandard)
self.show()
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Menus
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def buildHelpMenu(self, *a):
self.UI_HelpMenu.clear()
ShowHelpOption = mc.optionVar(q='cgmVar_TDToolsShowHelp')
MelMenuItem(self.UI_HelpMenu,
l="Show Help",
cb=ShowHelpOption,
c=lambda *a: self.do_showHelpToggle())
MelMenuItem(self.UI_HelpMenu,
l="Print Tools Help",
c=lambda *a: self.printHelp())
MelMenuItemDiv(self.UI_HelpMenu)
MelMenuItem(self.UI_HelpMenu, l="About", c=lambda *a: self.showAbout())
def do_showHelpToggle(self):
ShowHelpOption = mc.optionVar(q='cgmVar_TDToolsShowHelp')
guiFactory.toggleMenuShowState(ShowHelpOption, self.helpBlurbs)
mc.optionVar(iv=('cgmVar_TDToolsShowHelp', not ShowHelpOption))
def showAbout(self):
window = mc.window(title="About",
iconName='About',
ut='cgmUITemplate',
resizeToFitChildren=True)
mc.columnLayout(adjustableColumn=True)
guiFactory.header(self.toolName, overrideUpper=True)
mc.text(label='>>>A Part of the cgmTools Collection<<<',
ut='cgmUIInstructionsTemplate')
guiFactory.headerBreak()
guiFactory.lineBreak()
descriptionBlock = guiFactory.textBlock(self.description)
guiFactory.lineBreak()
mc.text(label=('%s%s' % ('Written by: ', self.author)))
mc.text(label=('%s%s%s' % ('Copyright ', self.owner, ', 2011')))
guiFactory.lineBreak()
mc.text(label='Version: %s' % self.version)
mc.text(label='')
guiFactory.doButton(
'Visit Website',
'import webbrowser;webbrowser.open("http://www.cgmonks.com")')
guiFactory.doButton(
'Close', 'import maya.cmds as mc;mc.deleteUI(\"' + window +
'\", window=True)')
mc.setParent('..')
mc.showWindow(window)
def printHelp(self):
import tdToolsLib
help(tdToolsLib)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Tools
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def buildAutoNameTool(self, parent, vis=True):
containerName = 'AutoNameContainer'
self.containerName = MelColumn(parent, vis=vis)
#>>> Begin the section
mc.setParent(self.containerName)
guiFactory.header('Tag and Release')
guiFactory.lineSubBreak()
#>>> Guessed Name
GenratedNameRow = MelHLayout(self.containerName,
ut='cgmUIInstructionsTemplate')
self.GeneratedNameField = MelLabel(
GenratedNameRow,
bgc=dictionary.returnStateColor('help'),
align='center',
label='Name will preview here...')
GenratedNameRow.layout()
mc.setParent(self.containerName)
guiFactory.lineSubBreak()
guiFactory.lineSubBreak()
#>>> Load To Field
#clear our variables
if not mc.optionVar(ex='cgmVar_AutoNameObject'):
mc.optionVar(sv=('cgmVar_AutoNameObject', ''))
LoadAutoNameObjectRow = MelHSingleStretchLayout(self.containerName,
ut='cgmUISubTemplate',
padding=5)
MelSpacer(LoadAutoNameObjectRow, w=5)
MelLabel(LoadAutoNameObjectRow, l='Object:', align='right')
self.AutoNameObjectField = MelTextField(LoadAutoNameObjectRow,
w=125,
ut='cgmUIReservedTemplate',
editable=False)
if mc.optionVar(q='cgmVar_AutoNameObject'):
self.AutoNameObjectField(
edit=True, text=mc.optionVar(q='cgmVar_AutoNameObject'))
guiFactory.doButton2(LoadAutoNameObjectRow, '<<',
'tdToolsLib.uiLoadAutoNameObject(cgmTDToolsWin)',
'Load to field')
LoadAutoNameObjectRow.setStretchWidget(self.AutoNameObjectField)
guiFactory.doButton2(LoadAutoNameObjectRow, 'Up',
lambda *a: tdToolsLib.uiAutoNameWalkUp(self),
'Load to field')
guiFactory.doButton2(LoadAutoNameObjectRow, 'Down',
lambda *a: tdToolsLib.uiAutoNameWalkDown(self),
'Load to field')
guiFactory.doButton2(
LoadAutoNameObjectRow, 'Name it',
lambda *a: tdToolsLib.uiNameLoadedAutoNameObject(self),
'Load to field')
guiFactory.doButton2(
LoadAutoNameObjectRow, 'Name Children',
lambda *a: tdToolsLib.uiNameLoadedAutoNameObjectChildren(self),
'Load to field')
MelSpacer(LoadAutoNameObjectRow, w=5)
LoadAutoNameObjectRow.layout()
mc.setParent(self.containerName)
guiFactory.lineSubBreak()
#>>> Tag Labels
TagLabelsRow = MelHLayout(self.containerName,
ut='cgmUISubTemplate',
padding=2)
MelLabel(TagLabelsRow, label='Position')
MelLabel(TagLabelsRow, label='Direction')
MelLabel(TagLabelsRow, label='Name')
MelLabel(TagLabelsRow, label='Type')
TagLabelsRow.layout()
#>>> Tags
mc.setParent(self.containerName)
TagsRow = MelHLayout(self.containerName,
ut='cgmUISubTemplate',
padding=3)
self.PositionTagField = MelTextField(
TagsRow,
enable=False,
bgc=dictionary.returnStateColor('normal'),
ec=lambda *a: tdToolsLib.uiUpdateAutoNameTag(self, 'cgmPosition'),
w=75)
self.DirectionTagField = MelTextField(
TagsRow,
enable=False,
bgc=dictionary.returnStateColor('normal'),
ec=lambda *a: tdToolsLib.uiUpdateAutoNameTag(self, 'cgmDirection'),
w=75)
self.NameTagField = MelTextField(
TagsRow,
enable=False,
bgc=dictionary.returnStateColor('normal'),
ec=lambda *a: tdToolsLib.uiUpdateAutoNameTag(self, 'cgmName'),
w=75)
"""
self.NameTagFieldPopUp = MelPopupMenu(self.NameTagField,button = 3)
self.NameTagLoadParentPopUp = MelMenuItem(self.NameTagFieldPopUp ,
label = 'Select parent name object',
enable = False)
"""
self.ObjectTypeTagField = MelTextField(
TagsRow,
enable=False,
bgc=dictionary.returnStateColor('normal'),
ec=lambda *a: tdToolsLib.uiUpdateAutoNameTag(self, 'cgmType'),
w=75)
TagsRow.layout()
mc.setParent(self.containerName)
guiFactory.lineSubBreak()
#>>> ModifierTags
mc.setParent(self.containerName)
TagModifiersRow = MelHLayout(self.containerName,
ut='cgmUISubTemplate',
padding=3)
MelLabel(TagModifiersRow,
align='right',
label='Modifiers ------->',
w=75)
self.DirectionModifierTagField = MelTextField(
TagModifiersRow,
enable=False,
bgc=dictionary.returnStateColor('normal'),
ec=lambda *a: tdToolsLib.uiUpdateAutoNameTag(
self, 'cgmDirectionModifier'),
w=75)
self.NameModifierTagField = MelTextField(
TagModifiersRow,
enable=False,
bgc=dictionary.returnStateColor('normal'),
ec=lambda *a: tdToolsLib.uiUpdateAutoNameTag(
self, 'cgmNameModifier'),
w=75)
self.ObjectTypeModifierTagField = MelTextField(
TagModifiersRow,
enable=False,
bgc=dictionary.returnStateColor('normal'),
ec=lambda *a: tdToolsLib.uiUpdateAutoNameTag(
self, 'cgmTypeModifier'),
w=75)
TagModifiersRow.layout()
mc.setParent(self.containerName)
guiFactory.lineSubBreak()
guiFactory.lineBreak()
#>>> Basic
mc.setParent(self.containerName)
guiFactory.header('On Selection')
guiFactory.lineSubBreak()
BasicRow = MelHLayout(self.containerName,
ut='cgmUISubTemplate',
padding=2)
guiFactory.doButton2(BasicRow, 'Name Object',
'tdToolsLib.uiNameObject(cgmTDToolsWin)',
"Attempts to name an object")
guiFactory.doButton2(
BasicRow, 'Update Name',
'tdToolsLib.doUpdateObjectName(cgmTDToolsWin)',
"Takes the name you've manually changed the object to, \n stores that to the cgmName tag then \n renames the object"
)
guiFactory.doButton2(
BasicRow, 'Name Heirarchy',
'tdToolsLib.doNameHeirarchy(cgmTDToolsWin)',
"Attempts to intelligently name a \n heirarchy of objects")
BasicRow.layout()
mc.setParent(self.containerName)
guiFactory.lineSubBreak()
guiFactory.lineBreak()
return self.containerName
class locinatorClass(BaseMelWindow):
from cgm.lib import guiFactory
guiFactory.initializeTemplates()
USE_Template = 'cgmUITemplate'
WINDOW_NAME = 'cgmLocinatorWindow'
WINDOW_TITLE = 'cgm.locinator - %s' % __version__
DEFAULT_SIZE = 180, 275
DEFAULT_MENU = None
RETAIN = True
MIN_BUTTON = True
MAX_BUTTON = False
FORCE_DEFAULT_SIZE = True #always resets the size of the window when its re-created
def __init__(self):
self.toolName = 'cgm.locinator'
self.description = 'This tool makes locators based on selection types and provides ways to update those locators over time'
self.author = 'Josh Burton'
self.owner = 'CG Monks'
self.website = 'www.cgmonks.com'
self.version = __version__
self.optionVars = []
self.currentFrameOnly = True
self.startFrame = ''
self.endFrame = ''
self.startFrameField = ''
self.endFrameField = ''
self.forceBoundingBoxState = False
self.forceEveryFrame = False
self.showHelp = False
self.helpBlurbs = []
self.oldGenBlurbs = []
self.showTimeSubMenu = False
self.timeSubMenu = []
#Menu
self.setupVariables()
self.UI_OptionsMenu = MelMenu(l='Options', pmc=self.buildOptionsMenu)
self.UI_BufferMenu = MelMenu(l='Buffer', pmc=self.buildBufferMenu)
self.UI_HelpMenu = MelMenu(l='Help', pmc=self.buildHelpMenu)
self.ShowHelpOption = mc.optionVar(q='cgmVar_LocinatorShowHelp')
#Tabs
tabs = MelTabLayout(self)
TabBasic = MelColumnLayout(tabs)
TabSpecial = MelColumnLayout(tabs)
TabMatch = MelColumnLayout(tabs)
n = 0
for tab in 'Basic', 'Special', 'Match':
tabs.setLabel(n, tab)
n += 1
self.buildBasicLayout(TabBasic)
self.buildSpecialLayout(TabSpecial)
self.buildMatchLayout(TabMatch)
self.show()
def setupVariables(self):
self.LocinatorUpdateObjectsOptionVar = OptionVarFactory(
'cgmVar_LocinatorUpdateMode', defaultValue=0)
guiFactory.appendOptionVarList(self, 'cgmVar_LocinatorUpdateMode')
self.LocinatorUpdateObjectsBufferOptionVar = OptionVarFactory(
'cgmVar_LocinatorUpdateObjectsBuffer', defaultValue=[''])
guiFactory.appendOptionVarList(self,
'cgmVar_LocinatorUpdateObjectsBuffer')
self.DebugModeOptionVar = OptionVarFactory('cgmVar_LocinatorDebug',
defaultValue=0)
guiFactory.appendOptionVarList(self, self.DebugModeOptionVar.name)
self.SnapModeOptionVar = OptionVarFactory('cgmVar_SnapMatchMode',
defaultValue=0)
guiFactory.appendOptionVarList(self, self.SnapModeOptionVar.name)
#Old method...clean up at some point
if not mc.optionVar(ex='cgmVar_ForceBoundingBoxState'):
mc.optionVar(iv=('cgmVar_ForceBoundingBoxState', 0))
if not mc.optionVar(ex='cgmVar_LocinatorShowHelp'):
mc.optionVar(iv=('cgmVar_LocinatorShowHelp', 0))
if not mc.optionVar(ex='cgmVar_LocinatorCurrentFrameOnly'):
mc.optionVar(iv=('cgmVar_LocinatorCurrentFrameOnly', 0))
if not mc.optionVar(ex='cgmVar_LocinatorBakingMode'):
mc.optionVar(iv=('cgmVar_LocinatorBakingMode', 0))
guiFactory.appendOptionVarList(self, 'cgmVar_LocinatorShowHelp')
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Menus
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def buildOptionsMenu(self, *a):
self.UI_OptionsMenu.clear()
#>>>Match Mode
MatchModeMenu = MelMenuItem(self.UI_OptionsMenu,
l='Match Mode',
subMenu=True)
self.MatchModeOptions = ['parent', 'point', 'orient']
self.MatchModeCollection = MelRadioMenuCollection()
self.MatchModeCollectionChoices = []
self.SnapModeOptionVar.update() #Incase another tool changed
self.matchMode = self.SnapModeOptionVar.value
for c, item in enumerate(self.MatchModeOptions):
if self.matchMode == c:
rbValue = True
else:
rbValue = False
self.MatchModeCollectionChoices.append(
self.MatchModeCollection.createButton(
MatchModeMenu,
label=item,
rb=rbValue,
command=Callback(self.SnapModeOptionVar.set, c)))
# Placement Menu
PlacementMenu = MelMenuItem(self.UI_OptionsMenu,
l='Placement',
subMenu=True)
PlacementMenuCollection = MelRadioMenuCollection()
if mc.optionVar(q='cgmVar_ForceBoundingBoxState') == 0:
cgmOption = False
pivotOption = True
else:
cgmOption = True
pivotOption = False
PlacementMenuCollection.createButton(
PlacementMenu,
l='Bounding Box Center',
c=lambda *a: mc.optionVar(iv=('cgmVar_ForceBoundingBoxState', 1)),
rb=cgmOption)
PlacementMenuCollection.createButton(
PlacementMenu,
l='Pivot',
c=lambda *a: mc.optionVar(iv=('cgmVar_ForceBoundingBoxState', 0)),
rb=pivotOption)
# Tagging options
AutoloadMenu = MelMenuItem(self.UI_OptionsMenu,
l='Tagging',
subMenu=True)
if not mc.optionVar(ex='cgmVar_TaggingUpdateRO'):
mc.optionVar(iv=('cgmVar_TaggingUpdateRO', 1))
guiFactory.appendOptionVarList(self, 'cgmVar_TaggingUpdateRO')
RenameOnUpdateState = mc.optionVar(q='cgmVar_TaggingUpdateRO')
MelMenuItem(AutoloadMenu,
l="Update Rotation Order",
cb=mc.optionVar(q='cgmVar_TaggingUpdateRO'),
c=lambda *a: guiFactory.doToggleIntOptionVariable(
'cgmVar_TaggingUpdateRO'))
# Update Mode
UpdateMenu = MelMenuItem(self.UI_OptionsMenu,
l='Update Mode',
subMenu=True)
UpdateMenuCollection = MelRadioMenuCollection()
if self.LocinatorUpdateObjectsOptionVar.value == 0:
slMode = True
bufferMode = False
else:
slMode = False
bufferMode = True
UpdateMenuCollection.createButton(
UpdateMenu,
l='Selected',
c=lambda *a: self.LocinatorUpdateObjectsOptionVar.set(0),
rb=slMode)
UpdateMenuCollection.createButton(
UpdateMenu,
l='Buffer',
c=lambda *a: self.LocinatorUpdateObjectsOptionVar.set(1),
rb=bufferMode)
MelMenuItemDiv(self.UI_OptionsMenu)
MelMenuItem(self.UI_OptionsMenu, l="Reset", c=lambda *a: self.reset())
def reset(self):
Callback(guiFactory.resetGuiInstanceOptionVars(self.optionVars, run))
def reload(self):
run()
def buildBufferMenu(self, *a):
self.UI_BufferMenu.clear()
MelMenuItem(self.UI_BufferMenu,
l="Define",
c=lambda *a: locinatorLib.defineObjBuffer(
self.LocinatorUpdateObjectsBufferOptionVar))
MelMenuItem(self.UI_BufferMenu,
l="Add Selected",
c=lambda *a: locinatorLib.addSelectedToObjBuffer(
self.LocinatorUpdateObjectsBufferOptionVar))
MelMenuItem(self.UI_BufferMenu,
l="Remove Selected",
c=lambda *a: locinatorLib.removeSelectedFromObjBuffer(
self.LocinatorUpdateObjectsBufferOptionVar))
MelMenuItemDiv(self.UI_BufferMenu)
MelMenuItem(self.UI_BufferMenu,
l="Select Members",
c=lambda *a: locinatorLib.selectObjBufferMembers(
self.LocinatorUpdateObjectsBufferOptionVar))
MelMenuItem(self.UI_BufferMenu,
l="Clear",
c=lambda *a: locinatorLib.clearObjBuffer(
self.LocinatorUpdateObjectsBufferOptionVar))
def buildHelpMenu(self, *a):
self.UI_HelpMenu.clear()
MelMenuItem(self.UI_HelpMenu,
l="Show Help",
cb=self.ShowHelpOption,
c=lambda *a: self.do_showHelpToggle())
MelMenuItem(self.UI_HelpMenu,
l="Print Tools Help",
c=lambda *a: self.printHelp())
MelMenuItemDiv(self.UI_HelpMenu)
MelMenuItem(self.UI_HelpMenu, l="About", c=lambda *a: self.showAbout())
MelMenuItem(self.UI_HelpMenu,
l="Debug",
cb=self.DebugModeOptionVar.value,
c=lambda *a: self.DebugModeOptionVar.toggle())
def do_showHelpToggle(self):
guiFactory.toggleMenuShowState(self.ShowHelpOption, self.helpBlurbs)
mc.optionVar(iv=('cgmVar_LocinatorShowHelp', not self.ShowHelpOption))
self.ShowHelpOption = mc.optionVar(q='cgmVar_LocinatorShowHelp')
def do_showTimeSubMenuToggleOn(self):
guiFactory.toggleMenuShowState(1, self.timeSubMenu)
mc.optionVar(iv=('cgmVar_LocinatorCurrentFrameOnly', 1))
def do_showTimeSubMenuToggleOff(self):
guiFactory.toggleMenuShowState(0, self.timeSubMenu)
mc.optionVar(iv=('cgmVar_LocinatorCurrentFrameOnly', 0))
def showAbout(self):
window = mc.window(title="About",
iconName='About',
ut='cgmUITemplate',
resizeToFitChildren=True)
mc.columnLayout(adjustableColumn=True)
guiFactory.header(self.toolName, overrideUpper=True)
mc.text(label='>>>A Part of the cgmTools Collection<<<',
ut='cgmUIInstructionsTemplate')
guiFactory.headerBreak()
guiFactory.lineBreak()
descriptionBlock = guiFactory.textBlock(self.description)
guiFactory.lineBreak()
mc.text(label=('%s%s' % ('Written by: ', self.author)))
mc.text(label=('%s%s%s' % ('Copyright ', self.owner, ', 2011')))
guiFactory.lineBreak()
mc.text(label='Version: %s' % self.version)
mc.text(label='')
guiFactory.doButton(
'Visit Tool Webpage',
'import webbrowser;webbrowser.open(" http://www.cgmonks.com/tools/maya-tools/locinator/")'
)
guiFactory.doButton(
'Close', 'import maya.cmds as mc;mc.deleteUI(\"' + window +
'\", window=True)')
mc.setParent('..')
mc.showWindow(window)
def printHelp(self):
import locinatorLib
help(locinatorLib)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Layouts
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def buildPlaceHolder(self, parent):
self.containerName = MelColumnLayout(parent, ut='cgmUISubTemplate')
return self.containerName
def buildTimeSubMenu(self, parent):
self.containerName = MelColumnLayout(parent, ut='cgmUISubTemplate')
# Time Submenu
mc.setParent(self.containerName)
self.helpBlurbs.extend(
guiFactory.instructions(" Set your time range",
vis=self.ShowHelpOption))
timelineInfo = search.returnTimelineInfo()
# TimeInput Row
TimeInputRow = MelHSingleStretchLayout(self.containerName,
ut='cgmUISubTemplate')
self.timeSubMenu.append(TimeInputRow)
MelSpacer(TimeInputRow)
MelLabel(TimeInputRow, l='start')
self.startFrameField = MelIntField(TimeInputRow,
'cgmLocWinStartFrameField',
width=40,
value=timelineInfo['rangeStart'])
TimeInputRow.setStretchWidget(MelSpacer(TimeInputRow))
MelLabel(TimeInputRow, l='end')
self.endFrameField = MelIntField(TimeInputRow,
'cgmLocWinEndFrameField',
width=40,
value=timelineInfo['rangeEnd'])
MelSpacer(TimeInputRow)
TimeInputRow.layout()
MelSeparator(self.containerName,
ut='cgmUISubTemplate',
style='none',
height=5)
# Button Row
TimeButtonRow = MelHSingleStretchLayout(self.containerName,
padding=1,
ut='cgmUISubTemplate')
MelSpacer(TimeButtonRow, w=2)
currentRangeButton = guiFactory.doButton2(
TimeButtonRow, 'Current Range',
lambda *a: locinatorLib.setGUITimeRangeToCurrent(self),
'Sets the time range to the current slider range')
TimeButtonRow.setStretchWidget(MelSpacer(TimeButtonRow, w=2))
sceneRangeButton = guiFactory.doButton2(
TimeButtonRow, 'Scene Range',
lambda *a: locinatorLib.setGUITimeRangeToScene(self),
'Sets the time range to the current slider range')
MelSpacer(TimeButtonRow, w=2)
TimeButtonRow.layout()
#>>> Base Settings Flags
self.KeyingModeCollection = MelRadioCollection()
self.KeyingModeCollectionChoices = []
if not mc.optionVar(ex='cgmVar_LocinatorKeyingMode'):
mc.optionVar(iv=('cgmVar_LocinatorKeyingMode', 0))
guiFactory.appendOptionVarList(self, 'cgmVar_LocinatorKeyingMode')
KeysSettingsFlagsRow = MelHSingleStretchLayout(self.containerName,
ut='cgmUISubTemplate',
padding=2)
MelSpacer(KeysSettingsFlagsRow, w=2)
KeysSettingsFlagsRow.setStretchWidget(
MelLabel(KeysSettingsFlagsRow, l='Anim Option: ', align='right'))
self.keyingOptions = ['Keys', 'All']
for item in self.keyingOptions:
cnt = self.keyingOptions.index(item)
self.KeyingModeCollectionChoices.append(
self.KeyingModeCollection.createButton(
KeysSettingsFlagsRow,
label=self.keyingOptions[cnt],
onCommand=Callback(guiFactory.toggleOptionVarState,
self.keyingOptions[cnt],
self.keyingOptions,
'cgmVar_LocinatorKeyingMode', True)))
MelSpacer(KeysSettingsFlagsRow, w=5)
mc.radioCollection(self.KeyingModeCollection,
edit=True,
sl=(self.KeyingModeCollectionChoices[(mc.optionVar(
q='cgmVar_LocinatorKeyingMode'))]))
KeysSettingsFlagsRow.layout()
#>>> Base Settings Flags
self.KeyingTargetCollection = MelRadioCollection()
self.KeyingTargetCollectionChoices = []
if not mc.optionVar(ex='cgmVar_LocinatorKeyingTarget'):
mc.optionVar(iv=('cgmVar_LocinatorKeyingTarget', 0))
guiFactory.appendOptionVarList(self, 'cgmVar_LocinatorKeyingTarget')
BakeSettingsFlagsRow = MelHSingleStretchLayout(self.containerName,
ut='cgmUISubTemplate',
padding=2)
MelSpacer(BakeSettingsFlagsRow, w=2)
BakeSettingsFlagsRow.setStretchWidget(
MelLabel(BakeSettingsFlagsRow, l='From: ', align='right'))
MelSpacer(BakeSettingsFlagsRow)
self.keyTargetOptions = ['source', 'self']
for item in self.keyTargetOptions:
cnt = self.keyTargetOptions.index(item)
self.KeyingTargetCollectionChoices.append(
self.KeyingTargetCollection.createButton(
BakeSettingsFlagsRow,
label=self.keyTargetOptions[cnt],
onCommand=Callback(guiFactory.toggleOptionVarState,
self.keyTargetOptions[cnt],
self.keyTargetOptions,
'cgmVar_LocinatorKeyingTarget', True)))
MelSpacer(BakeSettingsFlagsRow, w=5)
mc.radioCollection(
self.KeyingTargetCollection,
edit=True,
sl=(self.KeyingTargetCollectionChoices[(mc.optionVar(
q='cgmVar_LocinatorKeyingTarget'))]))
BakeSettingsFlagsRow.layout()
return self.containerName
def buildBasicLayout(self, parent):
mc.setParent(parent)
guiFactory.header('Update')
#>>>Time Section
UpdateOptionRadioCollection = MelRadioCollection()
EveryFrameOption = mc.optionVar(q='cgmVar_LocinatorBakeState')
mc.setParent(parent)
guiFactory.lineSubBreak()
#>>> Time Menu Container
self.BakeModeOptionList = ['Current Frame', 'Bake']
cgmVar_Name = 'cgmVar_LocinatorBakeState'
guiFactory.appendOptionVarList(self, 'cgmVar_LocinatorBakeState')
if not mc.optionVar(ex=cgmVar_Name):
mc.optionVar(iv=(cgmVar_Name, 0))
#build our sub section options
self.ContainerList = []
#Mode Change row
ModeSetRow = MelHSingleStretchLayout(parent, ut='cgmUISubTemplate')
self.BakeModeRadioCollection = MelRadioCollection()
self.BakeModeChoiceList = []
MelSpacer(ModeSetRow, w=2)
self.BakeModeChoiceList.append(
self.BakeModeRadioCollection.createButton(
ModeSetRow,
label=self.BakeModeOptionList[0],
onCommand=Callback(guiFactory.toggleModeState,
self.BakeModeOptionList[0],
self.BakeModeOptionList, cgmVar_Name,
self.ContainerList, True)))
ModeSetRow.setStretchWidget(MelSpacer(ModeSetRow))
self.BakeModeChoiceList.append(
self.BakeModeRadioCollection.createButton(
ModeSetRow,
label=self.BakeModeOptionList[1],
onCommand=Callback(guiFactory.toggleModeState,
self.BakeModeOptionList[1],
self.BakeModeOptionList, cgmVar_Name,
self.ContainerList, True)))
ModeSetRow.layout()
#>>>
self.ContainerList.append(self.buildPlaceHolder(parent))
self.ContainerList.append(self.buildTimeSubMenu(parent))
mc.radioCollection(
self.BakeModeRadioCollection,
edit=True,
sl=self.BakeModeChoiceList[mc.optionVar(q=cgmVar_Name)])
#>>>
mc.setParent(parent)
guiFactory.doButton2(
parent, 'Do it!', lambda *a: locinatorLib.doUpdateLoc(self),
'Update a locator at a particular frame or through a timeline')
guiFactory.lineSubBreak()
#>>> Loc Me Section
guiFactory.lineBreak()
guiFactory.lineSubBreak()
guiFactory.doButton2(
parent, 'Just Loc Selected', lambda *a: locinatorLib.doLocMe(self),
'Create an updateable locator based off the selection and options')
def buildSpecialLayout(self, parent):
SpecialColumn = MelColumnLayout(parent)
#>>> Center Section
guiFactory.lineSubBreak()
guiFactory.doButton2(SpecialColumn, 'Locate Center',
lambda *a: locinatorLib.doLocCenter(self),
'Find the center point from a selection set')
#>>> Closest Point Section
guiFactory.lineSubBreak()
guiFactory.doButton2(
SpecialColumn, 'Locate Closest Point',
lambda *a: locinatorLib.doLocClosest(self),
'Select the proximity object(s), then the object to find point on. Accepted target object types are - nurbsCurves and surfaces and poly objects'
)
#>>> Curves Section
guiFactory.lineSubBreak()
guiFactory.doButton2(SpecialColumn, 'Loc CVs of curve',
lambda *a: locinatorLib.doLocCVsOfObject(),
"Locs the cv's at the cv coordinates")
guiFactory.lineSubBreak()
guiFactory.doButton2(SpecialColumn, 'Loc CVs on the curve',
lambda *a: locinatorLib.doLocCVsOnObject(),
"Locs cv's at closest point on the curve")
guiFactory.lineBreak()
#>>> Update Section
guiFactory.lineSubBreak()
guiFactory.doButton2(
SpecialColumn, 'Update Selected',
lambda *a: locinatorLib.doUpdateLoc(self),
"Only works with locators created with this tool")
def buildMatchLayout(self, parent):
MatchColumn = MelColumnLayout(parent)
#>>> Tag Section
guiFactory.lineSubBreak()
guiFactory.doButton2(
MatchColumn, 'Tag it', lambda *a: locinatorLib.doTagObjects(self),
"Tag the selected objects to the first locator in the selection set. After this relationship is set up, you can match objects to that locator."
)
#>>> Purge Section
guiFactory.lineSubBreak()
self.helpBlurbs.extend(
guiFactory.instructions(
" Purge all traces of cgmThinga tools from the object",
vis=self.ShowHelpOption))
guiFactory.doButton2(MatchColumn, 'Purge it',
lambda *a: locinatorLib.doPurgeCGMAttrs(self),
"Clean it")
guiFactory.lineBreak()
#>>> Update Section
guiFactory.lineSubBreak()
guiFactory.doButton2(
MatchColumn, 'Update Selected',
lambda *a: locinatorLib.doUpdateLoc(self),
"Only works with locators created with this tool")
class polyUniteClass(BaseMelWindow):
from cgm.lib import guiFactory
guiFactory.initializeTemplates()
USE_TEMPLATE = 'cgmUITemplate'
WINDOW_NAME = 'PolyUniteTool'
WINDOW_TITLE = 'cgm.polyUniteTool - %s' % __version__
DEFAULT_SIZE = 250, 150
DEFAULT_MENU = None
RETAIN = True
MIN_BUTTON = True
MAX_BUTTON = False
FORCE_DEFAULT_SIZE = True #always resets the size of the window when its re-created
def __init__(self):
import maya.mel as mel
import maya.cmds as mc
from cgm.lib import (guiFactory, search)
from cgm.tools.lib import (tdToolsLib, locinatorLib)
# Maya version check
if mayaVer >= 2011:
self.currentGen = True
else:
self.currentGen = False
# Basic variables
self.window = ''
self.activeTab = ''
self.toolName = 'cgmTDTools'
self.module = 'cgmTDTools'
self.winName = 'cgmTDToolsWin'
self.optionVars = []
self.showHelp = False
self.helpBlurbs = []
self.oldGenBlurbs = []
self.showTimeSubMenu = False
self.timeSubMenu = []
# About Window
self.description = 'Standalone PolyUnite tool'
self.author = 'Josh Burton'
self.owner = 'CG Monks'
self.website = 'www.cgmonks.com'
self.version = __version__
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Build
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#Menu
PolyUniteWindowColumn = MelColumn(self)
self.buildPolyUniteTool(PolyUniteWindowColumn)
self.show()
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Tab Layouts
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def buildPolyUniteTool(self, parent):
#Options
#clear our variables
if not mc.optionVar(ex='cgmVar_SourceObject'):
mc.optionVar(sv=('cgmVar_SourceObject', ''))
mc.setParent(parent)
guiFactory.header('PolyUnite')
PolyUniteColumn = MelColumn(parent)
LoadObjectUtilityRow = MelHSingleStretchLayout(PolyUniteColumn,
ut='cgmUISubTemplate',
padding=5)
MelSpacer(LoadObjectUtilityRow)
MelLabel(LoadObjectUtilityRow, l='Base Name:', align='right')
self.BaseNameField = MelTextField(
LoadObjectUtilityRow,
backgroundColor=[1, 1, 1],
w=60,
annotation="Base name for our various tools to use")
LoadObjectUtilityRow.setStretchWidget(self.BaseNameField)
MelSpacer(LoadObjectUtilityRow, w=5)
LoadObjectUtilityRow.layout()
mc.setParent(PolyUniteColumn)
guiFactory.lineSubBreak()
#Start LoadToField
LoadObjectTargetUtilityRow = MelHSingleStretchLayout(
PolyUniteColumn, ut='cgmUISubTemplate', padding=5)
MelSpacer(LoadObjectTargetUtilityRow, w=5)
MelLabel(LoadObjectTargetUtilityRow, l='Source:', align='right')
self.SourceObjectField = MelTextField(LoadObjectTargetUtilityRow,
w=125,
ut='cgmUIReservedTemplate',
editable=False)
MelSpacer(LoadObjectTargetUtilityRow, w=5)
LoadObjectTargetUtilityRow.layout()
mc.setParent(PolyUniteColumn)
guiFactory.lineSubBreak()
# Buttons
guiFactory.doButton2(
PolyUniteColumn, 'Load to Source',
lambda *a: tdToolsLib.doLoadPolyUnite(self),
"Attempts to load polyUnite and select the source shapes")
guiFactory.doButton2(
PolyUniteColumn, 'Build polyUnite',
lambda *a: tdToolsLib.doBuildPolyUnite(self),
"Builds a poly unite geo node from or \n selected objects (checks for mesh types)"
)
guiFactory.doButton2(
PolyUniteColumn, 'Remove polyUnite node',
lambda *a: tdToolsLib.doDeletePolyUniteNode(self),
"If a polyUnite node is loaded \n removes the polyUnite node but leaves \n the united geo"
)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Components
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def buildLoadObjectField(self, parent, optionVar):
#clear our variables
if not mc.optionVar(ex=optionVar):
mc.optionVar(sv=(optionVar, ''))
LoadObjectTargetUtilityRow = MelHSingleStretchLayout(
parent, ut='cgmUISubTemplate', padding=5)
MelSpacer(LoadObjectTargetUtilityRow, w=5)
MelLabel(LoadObjectTargetUtilityRow, l='Object:', align='right')
self.SourceObjectField = MelTextField(LoadObjectTargetUtilityRow,
w=125,
ut='cgmUIReservedTemplate',
editable=False)
if mc.optionVar(q=optionVar):
self.SourceObjectField(edit=True, text=mc.optionVar(q=optionVar))
guiFactory.doButton2(
LoadObjectTargetUtilityRow, '<<',
"guiFactory.doLoadSingleObjectToTextField(cgmTDToolsWin.SourceObjectField,'cgmVar_SourceObject')",
'Load to field')
MelLabel(LoadObjectTargetUtilityRow, l='Target:', align='right')
self.TargetObjectField = MelTextField(LoadObjectTargetUtilityRow,
w=125,
ut='cgmUIReservedTemplate',
editable=False)
LoadObjectTargetUtilityRow.setStretchWidget(self.BaseNameField)
guiFactory.doButton2(
LoadObjectTargetUtilityRow, '<<',
"guiFactory.doLoadMultipleObjectsToTextField(cgmTDToolsWin.TargetObjectField,False,'cgmVar_TargetObjects')",
'Load to field')
MelSpacer(LoadObjectTargetUtilityRow, w=5)
LoadObjectTargetUtilityRow.layout()
mc.setParent(parent)
guiFactory.lineSubBreak()
def buildLoadObjectTargetTool(self, parent, baseNameField=True):
#clear our variables
if not mc.optionVar(ex='cgmVar_SourceObject'):
mc.optionVar(sv=('cgmVar_SourceObject', ''))
if not mc.optionVar(ex='cgmVar_TargetObjects'):
mc.optionVar(sv=('cgmVar_TargetObjects', ''))
LoadObjectTargetUtilityRow = MelHSingleStretchLayout(
parent, ut='cgmUISubTemplate', padding=5)
MelSpacer(LoadObjectTargetUtilityRow, w=5)
if baseNameField:
MelLabel(LoadObjectTargetUtilityRow, l='Base Name:', align='right')
self.BaseNameField = MelTextField(
LoadObjectTargetUtilityRow,
backgroundColor=[1, 1, 1],
w=60,
annotation="Base name for our various tools to use")
MelLabel(LoadObjectTargetUtilityRow, l='Source:', align='right')
self.SourceObjectField = MelTextField(LoadObjectTargetUtilityRow,
w=125,
ut='cgmUIReservedTemplate',
editable=False)
if mc.optionVar(q='cgmVar_SourceObject'):
self.SourceObjectField(edit=True,
text=mc.optionVar(q='cgmVar_SourceObject'))
guiFactory.doButton2(
LoadObjectTargetUtilityRow, '<<',
"guiFactory.doLoadSingleObjectToTextField(cgmTDToolsWin.SourceObjectField,'cgmVar_SourceObject')",
'Load to field')
MelLabel(LoadObjectTargetUtilityRow, l='Target:', align='right')
self.TargetObjectField = MelTextField(LoadObjectTargetUtilityRow,
w=125,
ut='cgmUIReservedTemplate',
editable=False)
LoadObjectTargetUtilityRow.setStretchWidget(self.BaseNameField)
guiFactory.doButton2(
LoadObjectTargetUtilityRow, '<<',
"guiFactory.doLoadMultipleObjectsToTextField(cgmTDToolsWin.TargetObjectField,False,'cgmVar_TargetObjects')",
'Load to field')
MelSpacer(LoadObjectTargetUtilityRow, w=5)
LoadObjectTargetUtilityRow.layout()
mc.setParent(parent)
guiFactory.lineSubBreak()
class puppetBoxClass(BaseMelWindow):
from cgm.lib import guiFactory
guiFactory.initializeTemplates()
USE_Template = 'cgmUITemplate'
WINDOW_NAME = 'cgmPuppetBoxWindow'
WINDOW_TITLE = 'cgm.puppetBox'
DEFAULT_SIZE = 250, 400
DEFAULT_MENU = None
RETAIN = True
MIN_BUTTON = True
MAX_BUTTON = False
FORCE_DEFAULT_SIZE = False #always resets the size of the window when its re-created
global cgmPuppet
def __init__( self):
self.toolName = 'cgm.puppetBox'
self.description = 'This is a series of tools for working with cgm Sets'
self.author = 'Josh Burton'
self.owner = 'CG Monks'
self.website = 'www.cgmonks.com'
self.version = __version__
self.optionVars = []
self.scenePuppets = []
self.Puppet = False
self.PuppetBridge = {}
self.puppetStateOptions = ['define']
self.puppetStateOptions.extend(ModuleFactory.moduleStates)
#self.addModules = ['Spine','Leg','Arm','Limb','Finger','Foot','Neck','Head','Spine']
self.addModules = ['Segment']
self.moduleFrames = {}
self.moduleBaseNameFields = {}
self.moduleHandleFields = {}
self.moduleRollFields = {}
self.moduleCurveFields = {}
self.moduleStiffIndexFields = {}
self.moduleDirectionMenus = {}
self.modulePositionMenus = {}
self.moduleDirections = ['none','left','right']
self.modulePositions = ['none','front','rear','forward','back','top','bottom']
self.setModes = ['<<< All Loaded Sets >>>','<<< Active Sets >>>']
self.scenePuppets = modules.returnPuppetObjects()
self.UI_StateRows = {'define':[],'template':[],'skeleton':[],'rig':[]}
self.showHelp = False
self.helpBlurbs = []
self.oldGenBlurbs = []
#Menu
self.setupVariables()
self.UI_PuppetMenu = MelMenu( l='Puppet', pmc=self.buildPuppetMenu)
self.UI_AddModulesMenu = MelMenu( l='Add', pmc=self.buildAddModulesMenu)
self.UI_OptionsMenu = MelMenu( l='Options', pmc=self.buildOptionsMenu)
self.UI_HelpMenu = MelMenu( l='Help', pmc=self.buildHelpMenu)
self.ShowHelpOption = mc.optionVar( q='cgmVar_AnimToolsShowHelp' )
#GUI
self.Main_buildLayout(self)
if self.Puppet:
puppetBoxLib.updateUIPuppet(self)
if self.scenePuppets:
puppetBoxLib.activatePuppet(self,self.scenePuppets[0])
self.show()
def setupVariables(self):
self.PuppetModeOptionVar = OptionVarFactory('cgmVar_PuppetCreateMode',defaultValue = 0)
guiFactory.appendOptionVarList(self,self.PuppetModeOptionVar.name)
self.PuppetAimOptionVar = OptionVarFactory('cgmVar_PuppetAimAxis',defaultValue = 2)
guiFactory.appendOptionVarList(self,self.PuppetAimOptionVar.name)
self.PuppetUpOptionVar = OptionVarFactory('cgmVar_PuppetUpAxis',defaultValue = 1)
guiFactory.appendOptionVarList(self,self.PuppetUpOptionVar.name)
self.PuppetOutOptionVar = OptionVarFactory('cgmVar_PuppetOutAxis',defaultValue = 0)
guiFactory.appendOptionVarList(self,self.PuppetOutOptionVar.name)
self.ActiveObjectSetsOptionVar = OptionVarFactory('cgmVar_activeObjectSets',defaultValue = [''])
self.ActiveRefsOptionVar = OptionVarFactory('cgmVar_activeRefs',defaultValue = [''])
self.ActiveTypesOptionVar = OptionVarFactory('cgmVar_activeTypes',defaultValue = [''])
self.SetToolsModeOptionVar = OptionVarFactory('cgmVar_puppetBoxMode', defaultValue = 0)
self.KeyTypeOptionVar = OptionVarFactory('cgmVar_KeyType', defaultValue = 0)
self.ShowHelpOptionVar = OptionVarFactory('cgmVar_puppetBoxShowHelp', defaultValue = 0)
self.MaintainLocalSetGroupOptionVar = OptionVarFactory('cgmVar_MaintainLocalSetGroup', defaultValue = 1)
self.HideSetGroupOptionVar = OptionVarFactory('cgmVar_HideSetGroups', defaultValue = 1)
self.HideAnimLayerSetsOptionVar = OptionVarFactory('cgmVar_HideAnimLayerSets', defaultValue = 1)
self.HideMayaSetsOptionVar = OptionVarFactory('cgmVar_HideMayaSets', defaultValue = 1)
guiFactory.appendOptionVarList(self,self.ActiveObjectSetsOptionVar.name)
guiFactory.appendOptionVarList(self,self.ActiveRefsOptionVar.name)
guiFactory.appendOptionVarList(self,self.ActiveTypesOptionVar.name)
guiFactory.appendOptionVarList(self,self.SetToolsModeOptionVar.name)
guiFactory.appendOptionVarList(self,self.ShowHelpOptionVar.name)
guiFactory.appendOptionVarList(self,self.KeyTypeOptionVar.name)
guiFactory.appendOptionVarList(self,self.HideSetGroupOptionVar.name)
guiFactory.appendOptionVarList(self,self.MaintainLocalSetGroupOptionVar.name)
guiFactory.appendOptionVarList(self,self.HideAnimLayerSetsOptionVar.name)
guiFactory.appendOptionVarList(self,self.HideMayaSetsOptionVar.name)
def updateModulesUI(self):
def optionMenuSet(item):
print item
#puppetBoxLib.uiModuleSetCGMTag(self,tag,item,index)
"""
i = self.setModes.index(item)
self.SetToolsModeOptionVar.set( i )
self.setMode = i"""
#deleteExisting
self.ModuleListColumn.clear()
if self.Puppet:
for i,b in enumerate(self.Puppet.ModulesBuffer.bufferList):
# NEED to get colors
#Build label for Frame
self.moduleFrames[i] = MelFrameLayout(self.ModuleListColumn,l='',
collapse=True,
collapsable=True,
marginHeight=0,
marginWidth=0,
bgc = dictionary.guiDirectionColors['center'])
puppetBoxLib.uiModuleUpdateFrameLabel(self,i)
#Build Naming Row
tmpNameRow = MelFormLayout(self.moduleFrames[i], h=25,
)
tmpNameLabel = MelLabel(tmpNameRow,l='base:',align='right')
self.moduleBaseNameFields[i] = MelTextField(tmpNameRow,text=self.Puppet.Module[i].nameBase or '',
ec = Callback(puppetBoxLib.uiUpdateBaseName,self,i),
w=50,
h=20)
tmpDirLabel = MelLabel(tmpNameRow,l='dir:',align='right')
self.moduleDirectionMenus[i] = MelOptionMenu(tmpNameRow, cc = Callback(puppetBoxLib.uiModuleOptionMenuSet,self,self.moduleDirectionMenus,self.moduleDirections,'cgmDirection',i))
for cnt,o in enumerate(self.moduleDirections):
self.moduleDirectionMenus[i].append(o)
if o == self.Puppet.Module[i].ModuleNull.cgm['cgmDirection']:
self.moduleDirectionMenus[i](edit = True, select = cnt + 1)
tmpPosLabel = MelLabel(tmpNameRow,l='pos:',align='right')
self.modulePositionMenus[i] = MelOptionMenu(tmpNameRow,
cc = Callback(puppetBoxLib.uiModuleOptionMenuSet,self,self.modulePositionMenus,self.modulePositions,'cgmPosition',i))
for cnt,o in enumerate(self.modulePositions):
self.modulePositionMenus[i].append(o)
if o == self.Puppet.Module[i].ModuleNull.cgm['cgmPosition']:
self.modulePositionMenus[i](edit = True, select = cnt + 1)
mc.formLayout(tmpNameRow, edit = True,
af = [(tmpNameLabel, "left", 10),
(self.modulePositionMenus[i],"right",10)],
ac = [(self.moduleBaseNameFields[i],"left",5,tmpNameLabel),
(self.moduleBaseNameFields[i],"right",5,tmpDirLabel),
(tmpDirLabel,"right",5,self.moduleDirectionMenus[i]),
(self.moduleDirectionMenus[i],"right",5,tmpPosLabel),
(tmpPosLabel,"right",5,self.modulePositionMenus[i] ),
])
#>>>>>>>>>>>>>>>>>>>>>
if self.Puppet.Module[i].moduleClass == 'Limb':
#Build Int Settings Row
tmpIntRow = MelHSingleStretchLayout(self.moduleFrames[i], h=25,
)
tmpIntRow.setStretchWidget(MelSpacer(tmpIntRow,w=5))
MelLabel(tmpIntRow,l='Handles:')
self.moduleHandleFields[i] = MelIntField(tmpIntRow,
v = self.Puppet.Module[i].optionHandles.value,
bgc = dictionary.returnStateColor('normal'),
ec = Callback(puppetBoxLib.uiModuleUpdateIntAttrFromField,self,self.moduleHandleFields,'optionHandles',i),
h = 20, w = 35)
MelLabel(tmpIntRow,l='Roll:')
self.moduleRollFields[i] = MelIntField(tmpIntRow,
v = self.Puppet.Module[i].optionRollJoints.value,
bgc = dictionary.returnStateColor('normal'),
ec = Callback(puppetBoxLib.uiModuleUpdateIntAttrFromField,self,self.moduleRollFields,'optionRollJoints',i),
h = 20, w = 35)
MelLabel(tmpIntRow,l='Stiff Index:')
self.moduleStiffIndexFields[i] = MelIntField(tmpIntRow,
v = self.Puppet.Module[i].optionStiffIndex.value,
bgc = dictionary.returnStateColor('normal'),
ec = Callback(puppetBoxLib.uiModuleUpdateIntAttrFromField,self,self.moduleStiffIndexFields,'optionStiffIndex',i),
h = 20, w = 35)
MelLabel(tmpIntRow,l='Curve:')
self.moduleCurveFields[i] = MelIntField(tmpIntRow,
v = self.Puppet.Module[i].optionCurveDegree.value,
bgc = dictionary.returnStateColor('normal'),
ec = Callback(puppetBoxLib.uiModuleUpdateIntAttrFromField,self,self.moduleCurveFields,'optionCurveDegree',i),
h = 20, w = 35)
MelSpacer(tmpIntRow,w=10)
tmpIntRow.layout()
#PopUp Menu!
popUpMenu = MelPopupMenu(self.moduleFrames[i],button = 3)
MelMenuItem(popUpMenu,
label = "cls: %s"%self.Puppet.Module[i].moduleClass,
enable = False)
#Parent/MIrror
MelMenuItem(popUpMenu,
label = "Set Parent>",
enable = False)
MelMenuItem(popUpMenu,
label = "Set Mirror>",
enable = False)
if self.Puppet.Module[i].moduleClass == 'Limb':
MelMenuItem(popUpMenu,
label = 'FK',
cb = self.Puppet.Module[i].optionFK.value,
c = Callback(puppetBoxLib.uiModuleToggleBool,self,'optionFK',i))
MelMenuItem(popUpMenu,
label = 'IK',
cb = self.Puppet.Module[i].optionIK.value,
c = Callback(puppetBoxLib.uiModuleToggleBool,self,'optionIK',i))
MelMenuItem(popUpMenu,
label = 'Stretchy',
cb = self.Puppet.Module[i].optionStretchy.value,
c = Callback(puppetBoxLib.uiModuleToggleBool,self,'optionStretchy',i))
MelMenuItem(popUpMenu,
label = 'Bendy',
cb = self.Puppet.Module[i].optionBendy.value,
c = Callback(puppetBoxLib.uiModuleToggleBool,self,'optionBendy',i))
MelMenuItemDiv(popUpMenu)
# Object Aim Menu
ObjectAimMenu = MelMenuItem(popUpMenu, l='Aim:', subMenu=True)
self.ObjectAimCollection = MelRadioMenuCollection()
for index,axis in enumerate(dictionary.axisDirectionsByString):
if self.Puppet.Module[i].optionAimAxis.get() == index:
checkState = True
else:
checkState = False
self.ObjectAimCollection.createButton(ObjectAimMenu,l=axis,
c= Callback(puppetBoxLib.doSetAxisAndUpdateModule,self,functions.doSetAimAxis,self.Puppet.Module[i],index),
rb = checkState)
ObjectUpMenu = MelMenuItem(popUpMenu, l='Up:', subMenu=True)
self.ObjectUpCollection = MelRadioMenuCollection()
for index,axis in enumerate(dictionary.axisDirectionsByString):
if self.Puppet.Module[i].optionUpAxis.get() == index:
checkState = True
else:
checkState = False
self.ObjectUpCollection.createButton(ObjectUpMenu,l=axis,
c= Callback(puppetBoxLib.doSetAxisAndUpdateModule,self,functions.doSetUpAxis,self.Puppet.Module[i],index),
rb = checkState)
ObjectOutMenu = MelMenuItem(popUpMenu, l='Out:', subMenu=True)
self.ObjectOutCollection = MelRadioMenuCollection()
for index,axis in enumerate(dictionary.axisDirectionsByString):
if self.Puppet.Module[i].optionOutAxis.get() == index:
checkState = True
else:
checkState = False
self.ObjectOutCollection.createButton(ObjectOutMenu,l=axis,
c= Callback(puppetBoxLib.doSetAxisAndUpdateModule,self,functions.doSetOutAxis,self.Puppet.Module[i],index),
rb = checkState)
ObjectOutMenu = MelMenuItem(popUpMenu, l='Copy from Parent',
c= Callback(puppetBoxLib.doCopyAxisFromParent,self,self.Puppet.Module[i]))
MelMenuItemDiv(popUpMenu)
MelMenuItem(popUpMenu ,
label = 'Remove',
c = Callback(puppetBoxLib.doRemoveModule,self,i))
MelMenuItem(popUpMenu ,
label = 'Delete',
c = Callback(puppetBoxLib.doDeleteModule,self,i))
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Menus
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def buildPuppetMenu( self, *a ):
self.UI_PuppetMenu.clear()
#>>> Puppet Options
MelMenuItem( self.UI_PuppetMenu, l="New",
c=lambda *a:puppetBoxLib.doPuppetCreate(self))
#Build load menu
self.scenePuppets = modules.returnPuppetObjects()
loadMenu = MelMenuItem( self.UI_PuppetMenu, l='Pick Puppet:', subMenu=True)
if self.scenePuppets:
for i,m in enumerate(self.scenePuppets):
MelMenuItem( loadMenu, l="%s"%m,
c= Callback(puppetBoxLib.activatePuppet,self,m))
else:
MelMenuItem( loadMenu, l="None found")
if self.Puppet:
MelMenuItemDiv( self.UI_PuppetMenu )
MelMenuItem( self.UI_PuppetMenu, l="Initialize",
c=lambda *a:puppetBoxLib.initializePuppet(self))
if not self.Puppet.refState:
MelMenuItem( self.UI_PuppetMenu, l="Verify",
c=lambda *a:puppetBoxLib.verifyPuppet(self))
MelMenuItem( self.UI_PuppetMenu, l="Delete",
c=lambda *a:puppetBoxLib.deletePuppet(self))
#>>> Reset Options
MelMenuItemDiv( self.UI_PuppetMenu )
MelMenuItem( self.UI_PuppetMenu, l="Reload",
c=lambda *a: self.reload())
MelMenuItem( self.UI_PuppetMenu, l="Reset",
c=lambda *a: self.reset())
def buildAddModulesMenu( self, *a ):
self.UI_AddModulesMenu.clear()
for i,m in enumerate(self.addModules):
MelMenuItem( self.UI_AddModulesMenu, l="%s"%m,
c=lambda *a:puppetBoxLib.addModule(self,m))
MelMenuItemDiv( self.UI_AddModulesMenu )
def buildOptionsMenu( self, *a ):
self.UI_OptionsMenu.clear()
MelMenuItem( self.UI_OptionsMenu, l="Force module menu reload",
c=lambda *a:puppetBoxLib.uiForceModuleUpdateUI(self))
def reset(self):
Callback(guiFactory.resetGuiInstanceOptionVars(self.optionVars,run))
def reload(self):
run()
def buildHelpMenu( self, *a ):
self.UI_HelpMenu.clear()
MelMenuItem( self.UI_HelpMenu, l="Show Help",
cb=self.ShowHelpOptionVar.value,
c= lambda *a: self.do_showHelpToggle())
MelMenuItem( self.UI_HelpMenu, l="Print Set Report",
c=lambda *a: self.printReport() )
MelMenuItem( self.UI_HelpMenu, l="Print Tools Help",
c=lambda *a: self.printHelp() )
MelMenuItemDiv( self.UI_HelpMenu )
MelMenuItem( self.UI_HelpMenu, l="About",
c=lambda *a: self.showAbout() )
def do_showHelpToggle( self):
guiFactory.toggleMenuShowState(self.ShowHelpOptionVar.value,self.helpBlurbs)
self.ShowHelpOptionVar.toggle()
def showAbout(self):
window = mc.window( title="About", iconName='About', ut = 'cgmUITemplate',resizeToFitChildren=True )
mc.columnLayout( adjustableColumn=True )
guiFactory.header(self.toolName,overrideUpper = True)
mc.text(label='>>>A Part of the cgmTools Collection<<<', ut = 'cgmUIInstructionsTemplate')
guiFactory.headerBreak()
guiFactory.lineBreak()
descriptionBlock = guiFactory.textBlock(self.description)
guiFactory.lineBreak()
mc.text(label=('%s%s' %('Written by: ',self.author)))
mc.text(label=('%s%s%s' %('Copyright ',self.owner,', 2011')))
guiFactory.lineBreak()
mc.text(label='Version: %s' % self.version)
mc.text(label='')
guiFactory.doButton('Visit Tool Webpage', 'import webbrowser;webbrowser.open(" http://www.cgmonks.com/tools/maya-tools/puppetBox/")')
guiFactory.doButton('Close', 'import maya.cmds as mc;mc.deleteUI(\"' + window + '\", window=True)')
mc.setParent( '..' )
mc.showWindow( window )
def printHelp(self):
help(puppetBoxLib)
def printReport(self):
puppetBoxLib.printReport(self)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Layouts
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def Main_buildLayout(self,parent):
def modeSet( item ):
i = self.setModes.index(item)
self.SetToolsModeOptionVar.set( i )
self.setMode = i
MainForm = MelFormLayout(parent)
TopSection = MelColumnLayout(MainForm)
SetHeader = guiFactory.header('Puppet')
#>>> Top Section
#Report
self.puppetReport = MelLabel(TopSection,
bgc = dictionary.returnStateColor('help'),
align = 'center',
label = '...',
h=20)
MelSeparator(TopSection,ut='cgmUITemplate',h=5)
#Edit name and state mode buttons
MasterPuppetRow = MelHSingleStretchLayout(TopSection,padding = 5)
MelSpacer(MasterPuppetRow,w=5)
self.MasterPuppetTF = MelTextField(MasterPuppetRow,
bgc = [1,1,1],
ec = lambda *a:puppetBoxLib.updatePuppetName(self))
MasterPuppetRow.setStretchWidget(self.MasterPuppetTF)
self.puppetStateButtonsDict = {}
for i,s in enumerate(self.puppetStateOptions):
self.puppetStateButtonsDict[i] = guiFactory.doButton2(MasterPuppetRow,s.capitalize(),
"print '%s'"%s,
enable = False)
MelSpacer(MasterPuppetRow,w=20)
MasterPuppetRow.layout()
#MelSeparator(TopSection,ut='cgmUITemplate',h=2)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Define State Rows
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#Initial State Mode Row
self.PuppetModeCollection = MelRadioCollection()
self.PuppetModeCollectionChoices = []
self.InitialStateModeRow = MelHSingleStretchLayout(TopSection,padding = 2,vis=False)
MelSpacer(self.InitialStateModeRow,w=5)
MelLabel(self.InitialStateModeRow,l='Template Modes')
Spacer = MelSeparator(self.InitialStateModeRow,w=10)
for i,item in enumerate(CharacterTypes):
self.PuppetModeCollectionChoices.append(self.PuppetModeCollection.createButton(self.InitialStateModeRow,label=item,
onCommand = Callback(puppetBoxLib.setPuppetBaseMode,self,i)))
MelSpacer(self.InitialStateModeRow,w=3)
self.InitialStateModeRow.setStretchWidget( Spacer )
MelSpacer(self.InitialStateModeRow,w=2)
self.InitialStateModeRow.layout()
mc.radioCollection(self.PuppetModeCollection ,edit=True,sl= (self.PuppetModeCollectionChoices[ (self.PuppetModeOptionVar.value) ]))
self.UI_StateRows['define'].append(self.InitialStateModeRow)
self.AxisFrame = MelFrameLayout(TopSection,label = 'Axis',vis=False,
collapse=True,
collapsable=True,
ut = 'cgmUIHeaderTemplate')
self.UI_StateRows['define'].append(self.AxisFrame)
MelSeparator(TopSection,style='none',h=5)
#Aim Axis Mode Row
self.AimAxisCollection = MelRadioCollection()
self.AimAxisCollectionChoices = []
self.AimAxisRow = MelHSingleStretchLayout(self.AxisFrame,padding = 2,vis=False)
MelSpacer(self.AimAxisRow,w=5)
MelLabel(self.AimAxisRow,l='Aim ')
Spacer = MelSeparator(self.AimAxisRow,w=10)
for i,item in enumerate(axisDirectionsByString):
self.AimAxisCollectionChoices.append(self.AimAxisCollection.createButton(self.AimAxisRow,label=item,
onCommand = Callback(puppetBoxLib.setPuppetAxisAim,self,i)))
MelSpacer(self.AimAxisRow,w=3)
self.AimAxisRow.setStretchWidget( Spacer )
MelSpacer(self.AimAxisRow,w=2)
self.AimAxisRow.layout()
#Up Axis Mode Row
self.UpAxisCollection = MelRadioCollection()
self.UpAxisCollectionChoices = []
self.UpAxisRow = MelHSingleStretchLayout(self.AxisFrame,padding = 2,vis=False)
MelSpacer(self.UpAxisRow,w=5)
MelLabel(self.UpAxisRow,l='Up ')
Spacer = MelSeparator(self.UpAxisRow,w=10)
for i,item in enumerate(axisDirectionsByString):
self.UpAxisCollectionChoices.append(self.UpAxisCollection.createButton(self.UpAxisRow,label=item,
onCommand = Callback(puppetBoxLib.setPuppetAxisUp,self,i)))
MelSpacer(self.UpAxisRow,w=3)
self.UpAxisRow.setStretchWidget( Spacer )
MelSpacer(self.UpAxisRow,w=2)
self.UpAxisRow.layout()
#Out Axis Mode Row
self.OutAxisCollection = MelRadioCollection()
self.OutAxisCollectionChoices = []
self.OutAxisRow = MelHSingleStretchLayout(self.AxisFrame,padding = 2,vis=False)
MelSpacer(self.OutAxisRow,w=5)
MelLabel(self.OutAxisRow,l='Out ')
Spacer = MelSeparator(self.OutAxisRow,w=10)
for i,item in enumerate(axisDirectionsByString):
self.OutAxisCollectionChoices.append(self.OutAxisCollection.createButton(self.OutAxisRow,label=item,
onCommand = Callback(puppetBoxLib.setPuppetAxisOut,self,i)))
MelSpacer(self.OutAxisRow,w=3)
self.OutAxisRow.setStretchWidget( Spacer )
MelSpacer(self.OutAxisRow,w=2)
self.OutAxisRow.layout()
#Set toggles on menu
mc.radioCollection(self.AimAxisCollection ,edit=True,sl= (self.AimAxisCollectionChoices[ (self.PuppetAimOptionVar.value) ]))
mc.radioCollection(self.UpAxisCollection ,edit=True,sl= (self.UpAxisCollectionChoices[ (self.PuppetUpOptionVar.value) ]))
mc.radioCollection(self.OutAxisCollection ,edit=True,sl= (self.OutAxisCollectionChoices[ (self.PuppetOutOptionVar.value) ]))
#Initial State Button Row
self.InitialStateButtonRow = MelHLayout(TopSection, h = 20,vis=False,padding = 5)
guiFactory.doButton2(self.InitialStateButtonRow,'Add Geo',
lambda *a:puppetBoxLib.doAddGeo(self))
guiFactory.doButton2(self.InitialStateButtonRow,'Build Size Template',
lambda *a:puppetBoxLib.doBuildSizeTemplate(self))
self.InitialStateButtonRow.layout()
self.UI_StateRows['define'].append(self.InitialStateButtonRow)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Multi Module
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#>>> All Sets menu
AllModulesRow = MelFormLayout(MainForm,height = 20)
activeState = True
i = 1
tmpActive = MelCheckBox(AllModulesRow,
annotation = 'Sets all sets active',
value = activeState,
onCommand = Callback(puppetBoxLib.doSetAllSetsAsActive,self),
offCommand = Callback(puppetBoxLib.doSetAllSetsAsInactive,self))
tmpSel = guiFactory.doButton2(AllModulesRow,
' s ',
'Select All Loaded/Active Sets')
# Mode toggle box
self.ModuleModeOptionMenu = MelOptionMenu(AllModulesRow,
cc = modeSet)
tmpKey = guiFactory.doButton2(AllModulesRow,
' k ',
'Key All Sets')
tmpDeleteKey = guiFactory.doButton2(AllModulesRow,
' d ',
'Delete All Set Keys')
tmpReset = guiFactory.doButton2(AllModulesRow,
' r ',
'Reset All Set Keys')
mc.formLayout(AllModulesRow, edit = True,
af = [(tmpActive, "left", 10),
(tmpReset,"right",10)],
ac = [(tmpSel,"left",0,tmpActive),
(self.ModuleModeOptionMenu,"left",4,tmpSel),
(self.ModuleModeOptionMenu,"right",4,tmpKey),
(tmpKey,"right",2,tmpDeleteKey),
(tmpDeleteKey,"right",2,tmpReset)
])
#>>> Sets building section
allPopUpMenu = MelPopupMenu(self.ModuleModeOptionMenu ,button = 3)
allCategoryMenu = MelMenuItem(allPopUpMenu,
label = 'Make Type:',
sm = True)
#>>> Sets building section
ModuleListScroll = MelScrollLayout(MainForm,cr = 1, ut = 'cgmUISubTemplate')
ModuleMasterForm = MelFormLayout(ModuleListScroll)
self.ModuleListColumn = MelColumnLayout(ModuleMasterForm,ut = 'cgmUIInstructionsTemplate', adj = True, rowSpacing = 2)
self.helpInfo = MelLabel(MainForm,
h=20,
l = "Add a Puppet",
ut = 'cgmUIInstructionsTemplate',
al = 'center',
ww = True,vis = self.ShowHelpOptionVar.value)
self.helpBlurbs.extend([self.helpInfo ])
VerifyRow = guiFactory.doButton2(MainForm,
'Check Puppet',
'Create new buffer from selected buffer')
ModuleMasterForm(edit = True,
af = [(self.ModuleListColumn,"top",0),
(self.ModuleListColumn,"left",0),
(self.ModuleListColumn,"right",0),
(self.ModuleListColumn,"bottom",0)])
MainForm(edit = True,
af = [(TopSection,"top",0),
(TopSection,"left",0),
(TopSection,"right",0),
(AllModulesRow,"left",0),
(AllModulesRow,"right",0),
(ModuleListScroll,"left",0),
(ModuleListScroll,"right",0),
(ModuleListScroll,"left",0),
(ModuleListScroll,"right",0),
(self.helpInfo,"left",8),
(self.helpInfo,"right",8),
(VerifyRow,"left",4),
(VerifyRow,"right",4),
(VerifyRow,"bottom",4)],
ac = [(AllModulesRow,"top",2,TopSection),
(ModuleListScroll,"top",2,AllModulesRow),
(ModuleListScroll,"bottom",0,self.helpInfo),
(self.helpInfo,"bottom",0,VerifyRow)],
attachNone = [(VerifyRow,"top")])
class animToolsClass(BaseMelWindow):
from cgm.lib import guiFactory
guiFactory.initializeTemplates()
USE_Template = 'cgmUITemplate'
WINDOW_NAME = 'cgmAnimToolsWindow'
WINDOW_TITLE = 'cgm.animTools - %s'%__version__
DEFAULT_SIZE = 180, 350
DEFAULT_MENU = None
RETAIN = True
MIN_BUTTON = True
MAX_BUTTON = False
FORCE_DEFAULT_SIZE = True #always resets the size of the window when its re-created
def __init__( self):
self.toolName = 'cgm.animTools'
self.description = 'This is a series of tools for basic animation functions'
self.author = 'Josh Burton'
self.owner = 'CG Monks'
self.website = 'www.cgmonks.com'
self.version = __version__
self.optionVars = []
self.currentFrameOnly = True
self.startFrame = ''
self.endFrame = ''
self.startFrameField = ''
self.endFrameField = ''
self.forceBoundingBoxState = False
self.forceEveryFrame = False
self.showHelp = False
self.helpBlurbs = []
self.oldGenBlurbs = []
self.showTimeSubMenu = False
self.timeSubMenu = []
#Menu
self.setupVariables()
self.UI_OptionsMenu = MelMenu( l='Options', pmc=self.buildOptionsMenu)
self.UI_BufferMenu = MelMenu( l = 'Buffer', pmc=self.buildBufferMenu)
self.UI_HelpMenu = MelMenu( l='Help', pmc=self.buildHelpMenu)
self.ShowHelpOption = mc.optionVar( q='cgmVar_AnimToolsShowHelp' )
#Tabs
tabs = MelTabLayout( self )
MatchTab = MelColumnLayout(tabs)
SnapTab = MelColumnLayout( tabs )
KeysTab = MelColumnLayout( tabs )
n = 0
for tab in 'Match','Snap','Keys':
tabs.setLabel(n,tab)
n+=1
self.Match_buildLayout(MatchTab)
self.Snap_buildLayout(SnapTab)
self.Keys_buildLayout(KeysTab)
self.show()
def setupVariables(self):
self.LocinatorUpdateObjectsOptionVar = OptionVarFactory('cgmVar_AnimToolsUpdateMode',defaultValue = 0)
guiFactory.appendOptionVarList(self,self.LocinatorUpdateObjectsOptionVar.name)
self.LocinatorUpdateObjectsBufferOptionVar = OptionVarFactory('cgmVar_LocinatorUpdateObjectsBuffer',defaultValue = [''])
guiFactory.appendOptionVarList(self,self.LocinatorUpdateObjectsBufferOptionVar.name)
self.DebugModeOptionVar = OptionVarFactory('cgmVar_AnimToolsDebug',defaultValue=0)
guiFactory.appendOptionVarList(self,self.DebugModeOptionVar.name)
#Old method...clean up at some point
if not mc.optionVar( ex='cgmVar_ForceBoundingBoxState' ):
mc.optionVar( iv=('cgmVar_ForceBoundingBoxState', 0) )
if not mc.optionVar( ex='cgmVar_ForceEveryFrame' ):
mc.optionVar( iv=('cgmVar_ForceEveryFrame', 0) )
if not mc.optionVar( ex='cgmVar_animToolsShowHelp' ):
mc.optionVar( iv=('cgmVar_animToolsShowHelp', 0) )
if not mc.optionVar( ex='cgmVar_CurrentFrameOnly' ):
mc.optionVar( iv=('cgmVar_CurrentFrameOnly', 0) )
if not mc.optionVar( ex='cgmVar_animToolsShowHelp' ):
mc.optionVar( iv=('cgmVar_animToolsShowHelp', 0) )
guiFactory.appendOptionVarList(self,'cgmVar_animToolsShowHelp')
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Menus
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def buildOptionsMenu( self, *a ):
self.UI_OptionsMenu.clear()
# Placement Menu
PlacementMenu = MelMenuItem( self.UI_OptionsMenu, l='Placement', subMenu=True)
PlacementMenuCollection = MelRadioMenuCollection()
if mc.optionVar( q='cgmVar_ForceBoundingBoxState' ) == 0:
cgmOption = False
pivotOption = True
else:
cgmOption = True
pivotOption = False
PlacementMenuCollection.createButton(PlacementMenu,l='Bounding Box Center',
c=lambda *a: mc.optionVar( iv=('cgmVar_ForceBoundingBoxState', 1)),
rb=cgmOption )
PlacementMenuCollection.createButton(PlacementMenu,l='Pivot',
c=lambda *a: mc.optionVar( iv=('cgmVar_ForceBoundingBoxState', 0)),
rb=pivotOption )
# Tagging options
AutoloadMenu = MelMenuItem( self.UI_OptionsMenu, l='Tagging', subMenu=True)
if not mc.optionVar( ex='cgmVar_TaggingUpdateRO' ):
mc.optionVar( iv=('cgmVar_TaggingUpdateRO', 1) )
guiFactory.appendOptionVarList(self,'cgmVar_TaggingUpdateRO')
RenameOnUpdateState = mc.optionVar( q='cgmVar_TaggingUpdateRO' )
MelMenuItem( AutoloadMenu, l="Update Rotation Order",
cb= mc.optionVar( q='cgmVar_TaggingUpdateRO' ),
c= lambda *a: guiFactory.doToggleIntOptionVariable('cgmVar_TaggingUpdateRO'))
# Update Mode
UpdateMenu = MelMenuItem( self.UI_OptionsMenu, l='Update Mode', subMenu=True)
UpdateMenuCollection = MelRadioMenuCollection()
if self.LocinatorUpdateObjectsOptionVar.value == 0:
slMode = True
bufferMode = False
else:
slMode = False
bufferMode = True
UpdateMenuCollection.createButton(UpdateMenu,l='Selected',
c=lambda *a: self.LocinatorUpdateObjectsOptionVar.set(0),
rb=slMode )
UpdateMenuCollection.createButton(UpdateMenu,l='Buffer',
c=lambda *a:self.LocinatorUpdateObjectsOptionVar.set(1),
rb=bufferMode )
MelMenuItemDiv( self.UI_OptionsMenu )
MelMenuItem( self.UI_OptionsMenu, l="Reset",
c=lambda *a: guiFactory.resetGuiInstanceOptionVars(self.optionVars,run))
def buildBufferMenu( self, *a ):
self.UI_BufferMenu.clear()
MelMenuItem( self.UI_BufferMenu, l="Define",
c= lambda *a: locinatorLib.defineObjBuffer(self.LocinatorUpdateObjectsBufferOptionVar))
MelMenuItem( self.UI_BufferMenu, l="Add Selected",
c= lambda *a: locinatorLib.addSelectedToObjBuffer(self.LocinatorUpdateObjectsBufferOptionVar))
MelMenuItem( self.UI_BufferMenu, l="Remove Selected",
c= lambda *a: locinatorLib.removeSelectedFromObjBuffer(self.LocinatorUpdateObjectsBufferOptionVar))
MelMenuItemDiv( self.UI_BufferMenu )
MelMenuItem( self.UI_BufferMenu, l="Select Members",
c= lambda *a: locinatorLib.selectObjBufferMembers(self.LocinatorUpdateObjectsBufferOptionVar))
MelMenuItem( self.UI_BufferMenu, l="Clear",
c= lambda *a: locinatorLib.clearObjBuffer(self.LocinatorUpdateObjectsBufferOptionVar))
def buildHelpMenu( self, *a ):
self.UI_HelpMenu.clear()
MelMenuItem( self.UI_HelpMenu, l="Show Help",
cb=self.ShowHelpOption,
c= lambda *a: self.do_showHelpToggle())
MelMenuItem( self.UI_HelpMenu, l="Print Tools Help",
c=lambda *a: self.printHelp() )
MelMenuItemDiv( self.UI_HelpMenu )
MelMenuItem( self.UI_HelpMenu, l="About",
c=lambda *a: self.showAbout() )
MelMenuItem( self.UI_HelpMenu, l="Debug",
cb=self.DebugModeOptionVar.value,
c= lambda *a: self.DebugModeOptionVar.toggle())
def do_showHelpToggle( self):
guiFactory.toggleMenuShowState(self.ShowHelpOption,self.helpBlurbs)
mc.optionVar( iv=('cgmVar_animToolsShowHelp', not self.ShowHelpOption))
self.ShowHelpOption = mc.optionVar( q='cgmVar_animToolsShowHelp' )
def do_showTimeSubMenuToggleOn( self):
guiFactory.toggleMenuShowState(1,self.timeSubMenu)
mc.optionVar( iv=('cgmVar_CurrentFrameOnly', 1))
def do_showTimeSubMenuToggleOff( self):
guiFactory.toggleMenuShowState(0,self.timeSubMenu)
mc.optionVar( iv=('cgmVar_CurrentFrameOnly', 0))
def showAbout(self):
window = mc.window( title="About", iconName='About', ut = 'cgmUITemplate',resizeToFitChildren=True )
mc.columnLayout( adjustableColumn=True )
guiFactory.header(self.toolName,overrideUpper = True)
mc.text(label='>>>A Part of the cgmTools Collection<<<', ut = 'cgmUIInstructionsTemplate')
guiFactory.headerBreak()
guiFactory.lineBreak()
descriptionBlock = guiFactory.textBlock(self.description)
guiFactory.lineBreak()
mc.text(label=('%s%s' %('Written by: ',self.author)))
mc.text(label=('%s%s%s' %('Copyright ',self.owner,', 2011')))
guiFactory.lineBreak()
mc.text(label='Version: %s' % self.version)
mc.text(label='')
guiFactory.doButton('Visit Tool Webpage', 'import webbrowser;webbrowser.open(" http://www.cgmonks.com/tools/maya-tools/animTools/")')
guiFactory.doButton('Close', 'import maya.cmds as mc;mc.deleteUI(\"' + window + '\", window=True)')
mc.setParent( '..' )
mc.showWindow( window )
def printHelp(self):
import animToolsLib
help(animToolsLib)
def do_everyFrameToggle( self):
EveryFrameOption = mc.optionVar( q='cgmVar_ForceEveryFrame' )
guiFactory.toggleMenuShowState(EveryFrameOption,self.timeSubMenu)
mc.optionVar( iv=('cgmVar_ForceEveryFrame', not EveryFrameOption))
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Layouts
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def buildPlaceHolder(self,parent):
self.containerName = MelColumnLayout(parent,ut='cgmUISubTemplate')
return self.containerName
def buildTimeSubMenu(self,parent):
self.containerName = MelColumnLayout(parent,ut='cgmUISubTemplate')
# Time Submenu
mc.setParent(self.containerName)
self.helpBlurbs.extend(guiFactory.instructions(" Set your time range",vis = self.ShowHelpOption))
timelineInfo = search.returnTimelineInfo()
# TimeInput Row
TimeInputRow = MelHSingleStretchLayout(self.containerName,ut='cgmUISubTemplate')
self.timeSubMenu.append( TimeInputRow )
MelSpacer(TimeInputRow)
MelLabel(TimeInputRow,l='start')
self.startFrameField = MelIntField(TimeInputRow,'cgmLocWinStartFrameField',
width = 40,
value= timelineInfo['rangeStart'])
TimeInputRow.setStretchWidget( MelSpacer(TimeInputRow) )
MelLabel(TimeInputRow,l='end')
self.endFrameField = MelIntField(TimeInputRow,'cgmLocWinEndFrameField',
width = 40,
value= timelineInfo['rangeEnd'])
MelSpacer(TimeInputRow)
TimeInputRow.layout()
MelSeparator(self.containerName,ut = 'cgmUISubTemplate',style='none',height = 5)
# Button Row
TimeButtonRow = MelHSingleStretchLayout(self.containerName,padding = 1, ut='cgmUISubTemplate')
MelSpacer(TimeButtonRow,w=2)
currentRangeButton = guiFactory.doButton2(TimeButtonRow,'Current Range',
lambda *a: locinatorLib.setGUITimeRangeToCurrent(self),
'Sets the time range to the current slider range')
TimeButtonRow.setStretchWidget( MelSpacer(TimeButtonRow,w=2) )
sceneRangeButton = guiFactory.doButton2(TimeButtonRow,'Scene Range',
lambda *a: locinatorLib.setGUITimeRangeToScene(self),
'Sets the time range to the current slider range')
MelSpacer(TimeButtonRow,w=2)
TimeButtonRow.layout()
#>>> Base Settings Flags
self.KeyingModeCollection = MelRadioCollection()
self.KeyingModeCollectionChoices = []
if not mc.optionVar( ex='cgmVar_AnimToolsKeyingMode' ):
mc.optionVar( iv=('cgmVar_AnimToolsKeyingMode', 0) )
guiFactory.appendOptionVarList(self,'cgmVar_AnimToolsKeyingMode')
KeysSettingsFlagsRow = MelHSingleStretchLayout(self.containerName,ut='cgmUISubTemplate',padding = 2)
MelSpacer(KeysSettingsFlagsRow,w=2)
KeysSettingsFlagsRow.setStretchWidget( MelLabel(KeysSettingsFlagsRow,l='Anim Option: ',align='right') )
self.keyingOptions = ['Keys','All']
for item in self.keyingOptions:
cnt = self.keyingOptions.index(item)
self.KeyingModeCollectionChoices.append(self.KeyingModeCollection.createButton(KeysSettingsFlagsRow,label=self.keyingOptions[cnt],
onCommand = Callback(guiFactory.toggleOptionVarState,self.keyingOptions[cnt],self.keyingOptions,'cgmVar_AnimToolsKeyingMode',True)))
MelSpacer(KeysSettingsFlagsRow,w=5)
mc.radioCollection(self.KeyingModeCollection ,edit=True,sl= (self.KeyingModeCollectionChoices[ (mc.optionVar(q='cgmVar_AnimToolsKeyingMode')) ]))
KeysSettingsFlagsRow.layout()
#>>> Base Settings Flags
self.KeyingTargetCollection = MelRadioCollection()
self.KeyingTargetCollectionChoices = []
if not mc.optionVar( ex='cgmVar_AnimToolsKeyingTarget' ):
mc.optionVar( iv=('cgmVar_AnimToolsKeyingTarget', 0) )
guiFactory.appendOptionVarList(self,'cgmVar_AnimToolsKeyingTarget')
BakeSettingsFlagsRow = MelHSingleStretchLayout(self.containerName,ut='cgmUISubTemplate',padding = 2)
MelSpacer(BakeSettingsFlagsRow,w=2)
BakeSettingsFlagsRow.setStretchWidget( MelLabel(BakeSettingsFlagsRow,l='From: ',align='right') )
MelSpacer(BakeSettingsFlagsRow)
self.keyTargetOptions = ['source','self']
for item in self.keyTargetOptions:
cnt = self.keyTargetOptions.index(item)
self.KeyingTargetCollectionChoices.append(self.KeyingTargetCollection.createButton(BakeSettingsFlagsRow,label=self.keyTargetOptions[cnt],
onCommand = Callback(guiFactory.toggleOptionVarState,self.keyTargetOptions[cnt],self.keyTargetOptions,'cgmVar_AnimToolsKeyingTarget',True)))
MelSpacer(BakeSettingsFlagsRow,w=5)
mc.radioCollection(self.KeyingTargetCollection ,edit=True,sl= (self.KeyingTargetCollectionChoices[ (mc.optionVar(q='cgmVar_AnimToolsKeyingTarget')) ]))
BakeSettingsFlagsRow.layout()
return self.containerName
def Match_buildLayout(self,parent):
mc.setParent(parent)
guiFactory.header('Update')
#>>>Match Mode
self.MatchModeCollection = MelRadioCollection()
self.MatchModeCollectionChoices = []
if not mc.optionVar( ex='cgmVar_AnimToolsMatchMode' ):
mc.optionVar( iv=('cgmVar_AnimToolsMatchMode', 0) )
guiFactory.appendOptionVarList(self,'cgmVar_AnimToolsMatchMode')
#MatchModeFlagsRow = MelHLayout(parent,ut='cgmUISubTemplate',padding = 2)
MatchModeFlagsRow = MelHSingleStretchLayout(parent,ut='cgmUIReservedTemplate',padding = 2)
MelSpacer(MatchModeFlagsRow,w=2)
self.MatchModeOptions = ['parent','point','orient']
for item in self.MatchModeOptions:
cnt = self.MatchModeOptions.index(item)
self.MatchModeCollectionChoices.append(self.MatchModeCollection.createButton(MatchModeFlagsRow,label=self.MatchModeOptions[cnt],
onCommand = Callback(guiFactory.toggleOptionVarState,self.MatchModeOptions[cnt],self.MatchModeOptions,'cgmVar_AnimToolsMatchMode',True)))
MelSpacer(MatchModeFlagsRow,w=3)
MatchModeFlagsRow.setStretchWidget( self.MatchModeCollectionChoices[-1] )
MelSpacer(MatchModeFlagsRow,w=2)
MatchModeFlagsRow.layout()
mc.radioCollection(self.MatchModeCollection ,edit=True,sl= (self.MatchModeCollectionChoices[ (mc.optionVar(q='cgmVar_AnimToolsMatchMode')) ]))
#>>>Time Section
UpdateOptionRadioCollection = MelRadioCollection()
#>>> Time Menu Container
self.BakeModeOptionList = ['Current Frame','Bake']
cgmVar_Name = 'cgmVar_AnimToolsBakeState'
if not mc.optionVar( ex=cgmVar_Name ):
mc.optionVar( iv=(cgmVar_Name, 0) )
EveryFrameOption = mc.optionVar( q='cgmVar_AnimToolsBakeState' )
guiFactory.appendOptionVarList(self,'cgmVar_AnimToolsBakeState')
#build our sub section options
self.ContainerList = []
#Mode Change row
ModeSetRow = MelHSingleStretchLayout(parent,ut='cgmUISubTemplate')
self.BakeModeRadioCollection = MelRadioCollection()
self.BakeModeChoiceList = []
MelSpacer(ModeSetRow,w=2)
self.BakeModeChoiceList.append(self.BakeModeRadioCollection.createButton(ModeSetRow,label=self.BakeModeOptionList[0],
onCommand = Callback(guiFactory.toggleModeState,self.BakeModeOptionList[0],self.BakeModeOptionList,cgmVar_Name,self.ContainerList,True)))
ModeSetRow.setStretchWidget( MelSpacer(ModeSetRow) )
self.BakeModeChoiceList.append(self.BakeModeRadioCollection.createButton(ModeSetRow,label=self.BakeModeOptionList[1],
onCommand = Callback(guiFactory.toggleModeState,self.BakeModeOptionList[1],self.BakeModeOptionList,cgmVar_Name,self.ContainerList,True)))
ModeSetRow.layout()
#>>>
self.ContainerList.append( self.buildPlaceHolder(parent) )
self.ContainerList.append( self.buildTimeSubMenu( parent) )
mc.radioCollection(self.BakeModeRadioCollection,edit=True, sl=self.BakeModeChoiceList[mc.optionVar(q=cgmVar_Name)])
#>>>
mc.setParent(parent)
guiFactory.doButton2(parent,'Do it!',
lambda *a: locinatorLib.doUpdateLoc(self),
'Update an obj or locator at a particular frame or through a timeline')
guiFactory.lineSubBreak()
#>>> Loc Me Section
guiFactory.lineBreak()
guiFactory.lineSubBreak()
guiFactory.doButton2(parent,'Just Loc Selected',
lambda *a: locinatorLib.doLocMe(self),
'Create an updateable locator based off the selection and options')
#>>> Tag Section
guiFactory.lineSubBreak()
guiFactory.doButton2(parent,'Tag it',
lambda *a: locinatorLib.doTagObjects(self),
"Tag the selected objects to the first locator in the selection set. After this relationship is set up, you can match objects to that locator.")
def Keys_buildLayout(self,parent):
SpecialColumn = MelColumnLayout(parent)
#>>> Center Section
guiFactory.header('Tangents')
guiFactory.lineSubBreak()
guiFactory.doButton2(SpecialColumn,'autoTangent',
lambda *a: mel.eval('autoTangent'),
'Fantastic script courtesy of Michael Comet')
guiFactory.lineBreak()
guiFactory.header('Breakdowns')
guiFactory.lineSubBreak()
guiFactory.doButton2(SpecialColumn,'tweenMachine',
lambda *a: mel.eval('tweenMachine'),
'Breakdown tool courtesy of Justin Barrett')
guiFactory.lineSubBreak()
guiFactory.doButton2(SpecialColumn,'breakdownDragger',
lambda *a: animToolsLib.ml_breakdownDraggerCall(),
'Breakdown tool courtesy of Morgan Loomis')
guiFactory.lineBreak()
guiFactory.header('Utilities')
guiFactory.lineSubBreak()
guiFactory.doButton2(SpecialColumn,'arcTracr',
lambda *a: animToolsLib.ml_arcTracerCall(),
'Path tracing tool courtesy of Morgan Loomis')
guiFactory.lineSubBreak()
guiFactory.doButton2(SpecialColumn,'copy Anim',
lambda *a: animToolsLib.ml_copyAnimCall(),
'Animation copy tool courtesy of Morgan Loomis')
guiFactory.lineSubBreak()
guiFactory.doButton2(SpecialColumn,'convert Rotation Order',
lambda *a: animToolsLib.ml_convertRotationOrderCall(),
'Rotation Order Conversion tool courtesy of Morgan Loomis')
guiFactory.lineSubBreak()
guiFactory.doButton2(SpecialColumn,'stopwatch',
lambda *a: animToolsLib.ml_stopwatchCall(),
'Stop Watch tool courtesy of Morgan Loomis')
def Snap_buildLayout(self,parent):
SnapColumn = MelColumnLayout(parent)
#>>> Snap Section
guiFactory.lineSubBreak()
guiFactory.doButton2(SnapColumn,'Parent Snap',
lambda *a: tdToolsLib.doParentSnap(),
"Basic Parent Snap")
guiFactory.lineSubBreak()
guiFactory.doButton2(SnapColumn,'Point Snap',
lambda *a: tdToolsLib.doPointSnap(),
"Basic Point Snap")
guiFactory.lineSubBreak()
guiFactory.doButton2(SnapColumn,'Orient Snap',
lambda *a: tdToolsLib.doOrientSnap(),
"Basic Orient Snap")
class attrToolsClass(BaseMelWindow):
from cgm.lib import guiFactory
guiFactory.initializeTemplates()
USE_Template = 'cgmUITemplate'
WINDOW_NAME = 'attrTools'
WINDOW_TITLE = 'cgm.attrTools'
DEFAULT_SIZE = 375, 350
DEFAULT_MENU = None
RETAIN = True
MIN_BUTTON = True
MAX_BUTTON = False
FORCE_DEFAULT_SIZE = True #always resets the size of the window when its re-created
def __init__(self):
# Basic variables
self.window = ''
self.activeTab = ''
self.toolName = 'attrTools'
self.module = 'tdTools'
self.winName = 'attrToolsWin'
self.optionVars = []
self.showHelp = False
self.helpBlurbs = []
self.oldGenBlurbs = []
self.showTimeSubMenu = False
self.timeSubMenu = []
self.setupVariables()
self.loadAttrs = []
# About Window
self.description = 'Tools for working with attributes'
self.author = 'Josh Burton'
self.owner = 'CG Monks'
self.website = 'www.cgmonks.com'
self.version = __version__
# About Window
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Build
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#Menu
self.UI_OptionsMenu = MelMenu(l='Options', pmc=self.buildOptionsMenu)
self.UI_HelpMenu = MelMenu(l='Help', pmc=self.buildHelpMenu)
WindowForm = MelColumnLayout(self)
self.buildAttributeTool(WindowForm)
if mc.ls(sl=True):
attrToolsLib.uiLoadSourceObject(self)
self.show()
def setupVariables(self):
self.SortModifyOptionVar = OptionVarFactory(
'cgmVar_attrToolsSortModfiy', defaultValue=0)
guiFactory.appendOptionVarList(self, self.SortModifyOptionVar.name)
self.HideTransformsOptionVar = OptionVarFactory(
'cgmVar_attrToolsHideTransform', defaultValue=0)
guiFactory.appendOptionVarList(self, self.HideTransformsOptionVar.name)
self.HideUserDefinedOptionVar = OptionVarFactory(
'cgmVar_attrToolsHideUserDefined', defaultValue=0)
guiFactory.appendOptionVarList(self,
self.HideUserDefinedOptionVar.name)
self.HideParentAttrsOptionVar = OptionVarFactory(
'cgmVar_attrToolsHideParentAttrs', defaultValue=0)
guiFactory.appendOptionVarList(self,
self.HideParentAttrsOptionVar.name)
self.HideCGMAttrsOptionVar = OptionVarFactory(
'cgmVar_attrToolsHideCGMAttrs', defaultValue=1)
guiFactory.appendOptionVarList(self, self.HideCGMAttrsOptionVar.name)
self.HideNonstandardOptionVar = OptionVarFactory(
'cgmVar_attrToolsHideNonStandard', defaultValue=1)
guiFactory.appendOptionVarList(self,
self.HideNonstandardOptionVar.name)
self.ShowHelpOptionVar = OptionVarFactory('cgmVar_attrToolsShowHelp',
defaultValue=0)
guiFactory.appendOptionVarList(self, self.ShowHelpOptionVar.name)
self.SourceObjectOptionVar = OptionVarFactory(
'cgmVar_AttributeSourceObject', defaultValue='')
guiFactory.appendOptionVarList(self, self.SourceObjectOptionVar.name)
self.CopyAttrModeOptionVar = OptionVarFactory(
'cgmVar_CopyAttributeMode', defaultValue=0)
guiFactory.appendOptionVarList(self, self.CopyAttrModeOptionVar.name)
self.CopyAttrOptionsOptionVar = OptionVarFactory(
'cgmVar_CopyAttributeOptions', defaultValue=1)
guiFactory.appendOptionVarList(self,
self.CopyAttrOptionsOptionVar.name)
self.TransferValueOptionVar = OptionVarFactory(
'cgmVar_AttributeTransferValueState', defaultValue=1)
guiFactory.appendOptionVarList(self, self.TransferValueOptionVar.name)
self.TransferIncomingOptionVar = OptionVarFactory(
'cgmVar_AttributeTransferInConnectionState', defaultValue=1)
guiFactory.appendOptionVarList(self,
self.TransferIncomingOptionVar.name)
self.TransferOutgoingOptionVar = OptionVarFactory(
'cgmVar_AttributeTransferOutConnectionState', defaultValue=1)
guiFactory.appendOptionVarList(self,
self.TransferOutgoingOptionVar.name)
self.TransferKeepSourceOptionVar = OptionVarFactory(
'cgmVar_AttributeTransferKeepSourceState', defaultValue=1)
guiFactory.appendOptionVarList(self,
self.TransferKeepSourceOptionVar.name)
self.TransferConvertStateOptionVar = OptionVarFactory(
'cgmVar_AttributeTransferConvertState', defaultValue=1)
guiFactory.appendOptionVarList(self,
self.TransferConvertStateOptionVar.name)
self.TransferDriveSourceStateOptionVar = OptionVarFactory(
'cgmVar_AttributeTransferConnectToSourceState', defaultValue=0)
guiFactory.appendOptionVarList(
self, self.TransferDriveSourceStateOptionVar.name)
self.CreateAttrTypeOptionVar = OptionVarFactory(
'cgmVar_AttrCreateType', defaultValue='')
guiFactory.appendOptionVarList(self, self.CreateAttrTypeOptionVar.name)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Menus
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def buildHelpMenu(self, *a):
self.UI_HelpMenu.clear()
MelMenuItem(self.UI_HelpMenu,
l="Print Tools Help",
c=lambda *a: self.printHelp())
MelMenuItemDiv(self.UI_HelpMenu)
MelMenuItem(self.UI_HelpMenu, l="About", c=lambda *a: self.showAbout())
def buildOptionsMenu(self, *a):
self.UI_OptionsMenu.clear()
#>>> Grouping Options
HidingMenu = MelMenuItem(self.UI_OptionsMenu,
l='Autohide:',
subMenu=True)
MelMenuItem(
self.UI_OptionsMenu,
l="Sort Modify",
cb=self.SortModifyOptionVar.value,
annotation=
"Sort the list of attributes in/nthe modify section alphabetically",
c=lambda *a: attrToolsLib.uiToggleOptionCB(
self, self.SortModifyOptionVar))
#guiFactory.appendOptionVarList(self,'cgmVar_MaintainLocalSetGroup')
MelMenuItem(HidingMenu,
l="Transforms",
cb=self.HideTransformsOptionVar.value,
c=lambda *a: attrToolsLib.uiToggleOptionCB(
self, self.HideTransformsOptionVar))
MelMenuItem(HidingMenu,
l="User Defined",
cb=self.HideUserDefinedOptionVar.value,
c=lambda *a: attrToolsLib.uiToggleOptionCB(
self, self.HideUserDefinedOptionVar))
MelMenuItem(HidingMenu,
l="Parent Attributes",
cb=self.HideParentAttrsOptionVar.value,
c=lambda *a: attrToolsLib.uiToggleOptionCB(
self, self.HideParentAttrsOptionVar))
MelMenuItem(HidingMenu,
l="CGM Attributes",
cb=self.HideCGMAttrsOptionVar.value,
c=lambda *a: attrToolsLib.uiToggleOptionCB(
self, self.HideCGMAttrsOptionVar))
MelMenuItem(HidingMenu,
l="Nonstandard",
cb=self.HideNonstandardOptionVar.value,
c=lambda *a: attrToolsLib.uiToggleOptionCB(
self, self.HideNonstandardOptionVar))
#>>> Reset Options
MelMenuItemDiv(self.UI_OptionsMenu)
MelMenuItem(self.UI_OptionsMenu,
l="Reload",
c=lambda *a: self.reload())
MelMenuItem(self.UI_OptionsMenu, l="Reset", c=lambda *a: self.reset())
def showAbout(self):
window = mc.window(title="About",
iconName='About',
ut='cgmUITemplate',
resizeToFitChildren=True)
mc.columnLayout(adjustableColumn=True)
guiFactory.header(self.toolName, overrideUpper=True)
mc.text(label='>>>A Part of the cgmTools Collection<<<',
ut='cgmUIInstructionsTemplate')
guiFactory.headerBreak()
guiFactory.lineBreak()
descriptionBlock = guiFactory.textBlock(self.description)
guiFactory.lineBreak()
mc.text(label=('%s%s' % ('Written by: ', self.author)))
mc.text(label=('%s%s%s' % ('Copyright ', self.owner, ', 2011')))
guiFactory.lineBreak()
mc.text(label='Version: %s' % self.version)
mc.text(label='')
guiFactory.doButton(
'Visit Website',
'import webbrowser;webbrowser.open("http://www.cgmonks.com/tools/maya-tools/attrtools/")'
)
guiFactory.doButton(
'Close', 'import maya.cmds as mc;mc.deleteUI(\"' + window +
'\", window=True)')
mc.setParent('..')
mc.showWindow(window)
def printHelp(self):
from cgm.tools.lib import attrToolsLib
help(attrToolsLib)
def reset(self):
Callback(guiFactory.resetGuiInstanceOptionVars(self.optionVars, run))
def reload(self):
run()
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Tools
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def buildAttributeTool(self, parent, vis=True):
OptionList = ['Tools', 'Manager', 'Utilities']
RadioCollectionName = 'AttributeMode'
RadioOptionList = 'AttributeModeSelectionChoicesList'
ShowHelpOption = mc.optionVar(q='cgmVar_TDToolsShowHelp')
self.AttributeModeOptionVar = OptionVarFactory(
'cgmVar_AttributeMode', defaultValue=OptionList[0])
MelSeparator(parent, ut='cgmUIHeaderTemplate', h=5)
#Mode Change row
self.ModeSetRow = MelHLayout(parent, ut='cgmUISubTemplate', padding=0)
MelLabel(self.ModeSetRow, label='Choose Mode: ', align='right')
self.RadioCollectionName = MelRadioCollection()
self.RadioOptionList = []
#build our sub section options
self.ContainerList = []
self.ContainerList.append(
self.buildAttributeEditingTool(parent, vis=False))
self.ContainerList.append(
self.buildAttributeManagerTool(parent, vis=False))
self.ContainerList.append(
self.buildAttributeUtilitiesTool(parent, vis=False))
for item in OptionList:
self.RadioOptionList.append(
self.RadioCollectionName.createButton(
self.ModeSetRow,
label=item,
onCommand=Callback(guiFactory.toggleModeState, item,
OptionList,
self.AttributeModeOptionVar.name,
self.ContainerList)))
self.ModeSetRow.layout()
mc.radioCollection(self.RadioCollectionName,
edit=True,
sl=self.RadioOptionList[OptionList.index(
self.AttributeModeOptionVar.value)])
def buildAttributeEditingTool(self, parent, vis=True):
#Container
containerName = 'Attributes Constainer'
self.containerName = MelColumn(parent, vis=vis)
###Create
mc.setParent(self.containerName)
guiFactory.header('Create')
guiFactory.lineSubBreak()
#>>>Create Row
attrCreateRow = MelHSingleStretchLayout(self.containerName,
ut='cgmUISubTemplate',
padding=5)
MelSpacer(attrCreateRow)
MelLabel(attrCreateRow, l='Names:', align='right')
self.AttrNamesTextField = MelTextField(
attrCreateRow,
backgroundColor=[1, 1, 1],
h=20,
ec=lambda *a: attrToolsLib.doAddAttributesToSelected(self),
annotation=
"Names for the attributes. Create multiple with a ';'. \n Message nodes try to connect to the last object in a selection \n For example: 'Test1;Test2;Test3'"
)
guiFactory.doButton2(
attrCreateRow, 'Add',
lambda *a: attrToolsLib.doAddAttributesToSelected(self),
"Add the attribute names from the text field")
MelSpacer(attrCreateRow, w=2)
attrCreateRow.setStretchWidget(self.AttrNamesTextField)
attrCreateRow.layout()
#>>> modify Section
self.buildAttrTypeRow(self.containerName)
MelSeparator(self.containerName, ut='cgmUIHeaderTemplate', h=2)
MelSeparator(self.containerName, ut='cgmUITemplate', h=10)
###Modify
mc.setParent(self.containerName)
guiFactory.header('Modify')
AttrReportRow = MelHLayout(self.containerName,
ut='cgmUIInstructionsTemplate',
h=20)
self.AttrReportField = MelLabel(
AttrReportRow,
bgc=dictionary.returnStateColor('help'),
align='center',
label='...',
h=20)
AttrReportRow.layout()
MelSeparator(self.containerName, ut='cgmUISubTemplate', h=5)
#>>> Load To Field
LoadAttributeObjectRow = MelHSingleStretchLayout(self.containerName,
ut='cgmUISubTemplate',
padding=5)
MelSpacer(LoadAttributeObjectRow, w=5)
guiFactory.doButton2(LoadAttributeObjectRow, '>>',
lambda *a: attrToolsLib.uiLoadSourceObject(self),
'Load to field')
self.SourceObjectField = MelTextField(LoadAttributeObjectRow,
w=125,
h=20,
ut='cgmUIReservedTemplate',
editable=False)
LoadAttributeObjectRow.setStretchWidget(self.SourceObjectField)
MelLabel(LoadAttributeObjectRow, l=' . ')
self.ObjectAttributesOptionMenu = MelOptionMenu(LoadAttributeObjectRow,
w=100)
self.DeleteAttrButton = guiFactory.doButton2(
LoadAttributeObjectRow,
'X',
lambda *a: attrToolsLib.uiDeleteAttr(
self, self.ObjectAttributesOptionMenu),
'Delete attribute',
w=25,
en=False)
MelSpacer(LoadAttributeObjectRow, w=5)
LoadAttributeObjectRow.layout()
#>>> Standard Flags
BasicAttrFlagsRow = MelHLayout(self.containerName,
ut='cgmUISubTemplate',
padding=2)
MelSpacer(BasicAttrFlagsRow, w=5)
self.KeyableAttrCB = MelCheckBox(BasicAttrFlagsRow,
label='Keyable',
en=False)
MelSpacer(BasicAttrFlagsRow, w=5)
self.HiddenAttrCB = MelCheckBox(BasicAttrFlagsRow,
label='Hidden',
en=False)
MelSpacer(BasicAttrFlagsRow, w=5)
self.LockedAttrCB = MelCheckBox(BasicAttrFlagsRow,
label='Locked',
en=False)
MelSpacer(BasicAttrFlagsRow, w=5)
BasicAttrFlagsRow.layout()
#>>> Name Row
self.EditNameSettingsRow = MelHSingleStretchLayout(
self.containerName, ut='cgmUISubTemplate')
self.EditNameSettingsRow.setStretchWidget(
MelSpacer(self.EditNameSettingsRow, w=5))
NameLabel = MelLabel(self.EditNameSettingsRow, label='Name: ')
self.NameField = MelTextField(
self.EditNameSettingsRow,
en=False,
bgc=dictionary.returnStateColor('normal'),
ec=lambda *a: attrToolsLib.uiRenameAttr(self),
h=20,
w=75)
NiceNameLabel = MelLabel(self.EditNameSettingsRow, label='Nice: ')
self.NiceNameField = MelTextField(
self.EditNameSettingsRow,
en=False,
bgc=dictionary.returnStateColor('normal'),
ec=lambda *a: attrToolsLib.uiUpdateNiceName(self),
h=20,
w=75)
AliasLabel = MelLabel(self.EditNameSettingsRow, label='Alias: ')
self.AliasField = MelTextField(
self.EditNameSettingsRow,
en=False,
bgc=dictionary.returnStateColor('normal'),
ec=lambda *a: attrToolsLib.uiUpdateAlias(self),
h=20,
w=75)
MelSpacer(self.EditNameSettingsRow, w=5)
self.EditNameSettingsRow.layout()
"""mc.formLayout(self.EditNameSettingsRow, edit = True,
af = [(NameLabel, "left", 5),
(self.AliasField,"right",5)],
ac = [(self.NameField,"left",2,NameLabel),
(NiceNameLabel,"left",2,self.NameField),
(self.NiceNameField,"left",2,NiceNameLabel),
(AliasLabel,"left",2,self.NiceNameField),
(self.AliasField,"left",2,AliasLabel),
])"""
#>>> Int Row
#self.EditDigitSettingsRow = MelFormLayout(self.containerName,ut='cgmUISubTemplate',vis = False)
self.EditDigitSettingsRow = MelHSingleStretchLayout(
self.containerName, ut='cgmUISubTemplate', vis=False)
self.EditDigitSettingsRow.setStretchWidget(
MelSpacer(self.EditDigitSettingsRow, w=5))
MinLabel = MelLabel(self.EditDigitSettingsRow, label='Min:')
self.MinField = MelTextField(
self.EditDigitSettingsRow,
bgc=dictionary.returnStateColor('normal'),
ec=lambda *a: attrToolsLib.uiUpdateMinValue(self),
h=20,
w=35)
MaxLabel = MelLabel(self.EditDigitSettingsRow, label='Max:')
self.MaxField = MelTextField(
self.EditDigitSettingsRow,
bgc=dictionary.returnStateColor('normal'),
ec=lambda *a: attrToolsLib.uiUpdateMaxValue(self),
h=20,
w=35)
DefaultLabel = MelLabel(self.EditDigitSettingsRow, label='dv:')
self.DefaultField = MelTextField(
self.EditDigitSettingsRow,
bgc=dictionary.returnStateColor('normal'),
ec=lambda *a: attrToolsLib.uiUpdateDefaultValue(self),
h=20,
w=35)
SoftMinLabel = MelLabel(self.EditDigitSettingsRow, label='sMin:')
self.SoftMinField = MelTextField(
self.EditDigitSettingsRow,
bgc=dictionary.returnStateColor('normal'),
ec=lambda *a: attrToolsLib.uiUpdateSoftMinValue(self),
h=20,
w=35)
SoftMaxLabel = MelLabel(self.EditDigitSettingsRow, label='sMax:')
self.SoftMaxField = MelTextField(
self.EditDigitSettingsRow,
bgc=dictionary.returnStateColor('normal'),
ec=lambda *a: attrToolsLib.uiUpdateSoftMaxValue(self),
h=20,
w=35)
MelSpacer(self.EditDigitSettingsRow, w=5)
self.EditDigitSettingsRow.layout()
"""mc.formLayout(self.EditDigitSettingsRow, edit = True,
af = [(MinLabel, "left", 20),
(self.SoftMinField,"right",20)],
ac = [(self.MinField,"left",2,MinLabel),
(MaxLabel,"left",2,self.MinField),
(self.MaxField,"left",2,MaxLabel),
(DefaultLabel,"left",2,self.MaxField),
(self.DefaultField,"left",2,DefaultLabel),
(SoftMaxLabel,"left",2,self.DefaultField),
(self.SoftMaxField,"left",2,SoftMaxLabel),
(SoftMinLabel,"left",2,self.SoftMaxField),
(self.SoftMinField,"left",2,SoftMinLabel)
])"""
#>>> Enum
self.EditEnumRow = MelHSingleStretchLayout(self.containerName,
ut='cgmUISubTemplate',
padding=5,
vis=False)
MelSpacer(self.EditEnumRow, w=10)
MelLabel(self.EditEnumRow, label='Enum: ')
self.EnumField = MelTextField(
self.EditEnumRow,
annotation=
"Options divided by ':'. \n Set values with '=' \n For example: 'off:on=1:maybe=23'",
bgc=dictionary.returnStateColor('normal'),
h=20,
w=75)
MelSpacer(self.EditEnumRow, w=10)
self.EditEnumRow.setStretchWidget(self.EnumField)
self.EditEnumRow.layout()
#>>> String
self.EditStringRow = MelHSingleStretchLayout(self.containerName,
ut='cgmUISubTemplate',
padding=5,
vis=False)
MelSpacer(self.EditStringRow, w=10)
MelLabel(self.EditStringRow, label='String: ')
self.StringField = MelTextField(
self.EditStringRow,
h=20,
bgc=dictionary.returnStateColor('normal'),
w=75)
MelSpacer(self.EditStringRow, w=10)
self.EditStringRow.setStretchWidget(self.StringField)
self.EditStringRow.layout()
#>>> Message
self.EditMessageRow = MelHSingleStretchLayout(self.containerName,
ut='cgmUISubTemplate',
padding=5,
vis=False)
MelSpacer(self.EditMessageRow, w=10)
MelLabel(self.EditMessageRow, label='Message: ')
self.MessageField = MelTextField(
self.EditMessageRow,
h=20,
enable=False,
bgc=dictionary.returnStateColor('locked'),
ec=lambda *a: tdToolsLib.uiUpdateAutoNameTag(self, 'cgmPosition'),
w=75)
self.LoadMessageButton = guiFactory.doButton2(
self.EditMessageRow, '<<',
lambda *a: attrToolsLib.uiUpdateMessage(self), 'Load to message')
MelSpacer(self.EditMessageRow, w=10)
self.EditMessageRow.setStretchWidget(self.MessageField)
self.EditMessageRow.layout()
#>>> Conversion
self.buildAttrConversionRow(self.containerName)
self.AttrConvertRow(e=True, vis=False)
#>>> Connect Report
self.ConnectionReportRow = MelHLayout(self.containerName,
ut='cgmUIInstructionsTemplate',
h=20,
vis=False)
self.ConnectionReportField = MelLabel(
self.ConnectionReportRow,
vis=False,
bgc=dictionary.returnStateColor('help'),
align='center',
label='...',
h=20)
self.ConnectionReportRow.layout()
self.ConnectedPopUpMenu = MelPopupMenu(self.ConnectionReportRow,
button=3)
MelSeparator(self.containerName, ut='cgmUIHeaderTemplate', h=2)
mc.setParent(self.containerName)
guiFactory.lineBreak()
return self.containerName
def buildAttrTypeRow(self, parent):
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Attr type row
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
self.attrTypes = [
'string', 'float', 'int', 'double3', 'bool', 'enum', 'message'
]
attrShortTypes = [
'str', 'float', 'int', '[000]', 'bool', 'enum', 'msg'
]
self.CreateAttrTypeRadioCollection = MelRadioCollection()
self.CreateAttrTypeRadioCollectionChoices = []
#build our sub section options
AttrTypeRow = MelHLayout(self.containerName,
ut='cgmUISubTemplate',
padding=5)
for cnt, item in enumerate(self.attrTypes):
self.CreateAttrTypeRadioCollectionChoices.append(
self.CreateAttrTypeRadioCollection.createButton(
AttrTypeRow,
label=attrShortTypes[cnt],
onCommand=Callback(self.CreateAttrTypeOptionVar.set,
item)))
MelSpacer(AttrTypeRow, w=2)
if self.CreateAttrTypeOptionVar.value:
mc.radioCollection(self.CreateAttrTypeRadioCollection,
edit=True,
sl=(self.CreateAttrTypeRadioCollectionChoices[
self.attrTypes.index(
self.CreateAttrTypeOptionVar.value)]))
AttrTypeRow.layout()
def buildAttrConversionRow(self, parent):
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Attr type row
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
self.attrConvertTypes = [
'string', 'float', 'int', 'bool', 'enum', 'message'
]
self.attrConvertShortTypes = [
'str', 'float', 'int', 'bool', 'enum', 'msg'
]
self.ConvertAttrTypeRadioCollection = MelRadioCollection()
self.ConvertAttrTypeRadioCollectionChoices = []
self.ConvertAttrTypeOptionVar = OptionVarFactory(
'cgmVar_ActiveAttrConversionState', 'int')
guiFactory.appendOptionVarList(self,
self.ConvertAttrTypeOptionVar.name)
self.ConvertAttrTypeOptionVar.set(0)
#build our sub section options
self.AttrConvertRow = MelHLayout(self.containerName,
ut='cgmUISubTemplate',
padding=5)
for cnt, item in enumerate(self.attrConvertTypes):
self.ConvertAttrTypeRadioCollectionChoices.append(
self.ConvertAttrTypeRadioCollection.createButton(
self.AttrConvertRow,
label=self.attrConvertShortTypes[cnt],
onCommand=Callback(attrToolsLib.uiConvertLoadedAttr, self,
item)))
MelSpacer(self.AttrConvertRow, w=2)
self.AttrConvertRow.layout()
def buildAttributeManagerTool(self, parent, vis=True):
self.ManageForm = MelFormLayout(self.Get(), ut='cgmUITemplate')
ManageHeader = guiFactory.header('Manage Attributes')
#>>> Manager load frow
ManagerLoadObjectRow = MelHSingleStretchLayout(self.ManageForm,
padding=5)
MelSpacer(ManagerLoadObjectRow, w=5)
guiFactory.doButton2(ManagerLoadObjectRow, '>>',
lambda *a: attrToolsLib.uiLoadSourceObject(self),
'Load to field')
self.ManagerSourceObjectField = MelTextField(
ManagerLoadObjectRow,
w=125,
h=20,
ut='cgmUIReservedTemplate',
editable=False)
ManagerLoadObjectRow.setStretchWidget(self.ManagerSourceObjectField)
MelSpacer(ManagerLoadObjectRow, w=5)
ManagerLoadObjectRow.layout()
#>>> Attribute List
self.ManageAttrList = MelObjectScrollList(self.ManageForm,
allowMultiSelection=True)
#>>> Reorder Button
ReorderButtonsRow = MelHLayout(self.ManageForm, padding=5)
guiFactory.doButton2(
ReorderButtonsRow, 'Move Up',
lambda *a: attrToolsLib.uiReorderAttributes(self, 0),
'Create new buffer from selected buffer')
guiFactory.doButton2(
ReorderButtonsRow, 'Move Down',
lambda *a: attrToolsLib.uiReorderAttributes(self, 1),
'Create new buffer from selected buffer')
ReorderButtonsRow.layout()
#>>>Transfer Options
self.TransferModeCollection = MelRadioCollection()
self.TransferModeCollectionChoices = []
TransferModeFlagsRow = MelHSingleStretchLayout(self.ManageForm,
padding=2)
MelLabel(TransferModeFlagsRow, l='Modes')
Spacer = MelSeparator(TransferModeFlagsRow, w=10)
self.TransferModeOptions = ['Connect', 'Copy', 'Transfer']
for i, item in enumerate(self.TransferModeOptions):
self.TransferModeCollectionChoices.append(
self.TransferModeCollection.createButton(
TransferModeFlagsRow,
label=item,
onCommand=Callback(self.CopyAttrModeOptionVar.set, i)))
MelSpacer(TransferModeFlagsRow, w=3)
TransferModeFlagsRow.setStretchWidget(Spacer)
MelSpacer(TransferModeFlagsRow, w=2)
TransferModeFlagsRow.layout()
mc.radioCollection(self.TransferModeCollection,
edit=True,
sl=(self.TransferModeCollectionChoices[(
self.CopyAttrModeOptionVar.value)]))
#>>>Transfer Options
self.TransferOptionsCollection = MelRadioCollection()
self.TransferOptionsCollectionChoices = []
TransferOptionsFlagsRow = MelHSingleStretchLayout(self.ManageForm,
padding=0)
Spacer = MelSpacer(TransferOptionsFlagsRow)
TransferOptionsFlagsRow.setStretchWidget(Spacer)
self.ConvertCB = MelCheckBox(
TransferOptionsFlagsRow,
label='Convert',
annotation="Converts if necessary to finish the copy process",
value=self.TransferConvertStateOptionVar.value,
onCommand=Callback(self.TransferConvertStateOptionVar.set, 1),
offCommand=Callback(self.TransferConvertStateOptionVar.set, 0))
self.ValueCB = MelCheckBox(
TransferOptionsFlagsRow,
label='Value',
annotation="Copy values",
value=self.TransferValueOptionVar.value,
onCommand=Callback(self.TransferValueOptionVar.set, 1),
offCommand=Callback(self.TransferValueOptionVar.set, 0))
self.IncomingCB = MelCheckBox(
TransferOptionsFlagsRow,
label='In',
annotation="Copy or transfer incoming connections",
value=self.TransferIncomingOptionVar.value,
onCommand=Callback(self.TransferIncomingOptionVar.set, 1),
offCommand=Callback(self.TransferIncomingOptionVar.set, 0))
self.OutgoingCB = MelCheckBox(
TransferOptionsFlagsRow,
label='Out',
annotation="Copy or transfer incoming connections",
value=self.TransferOutgoingOptionVar.value,
onCommand=Callback(self.TransferOutgoingOptionVar.set, 1),
offCommand=Callback(self.TransferOutgoingOptionVar.set, 0))
self.KeepSourceCB = MelCheckBox(
TransferOptionsFlagsRow,
label='Keep',
annotation="Keep source connections when copying",
value=self.TransferKeepSourceOptionVar.value,
onCommand=Callback(self.TransferKeepSourceOptionVar.set, 1),
offCommand=Callback(self.TransferKeepSourceOptionVar.set, 0))
self.DriveSourceCB = MelCheckBox(
TransferOptionsFlagsRow,
label='Drive',
annotation=
"Connect the source attr \nto selected or created attribute",
value=self.TransferDriveSourceStateOptionVar.value,
onCommand=Callback(self.TransferDriveSourceStateOptionVar.set, 1),
offCommand=Callback(self.TransferDriveSourceStateOptionVar.set, 0))
self.AttrOptionsCB = MelCheckBox(
TransferOptionsFlagsRow,
label='Options',
annotation=
"Copies the attributes basic flags\n(locked,keyable,hidden)",
value=self.CopyAttrOptionsOptionVar.value,
onCommand=Callback(self.CopyAttrOptionsOptionVar.set, 1),
offCommand=Callback(self.TransferDriveSourceStateOptionVar.set, 0))
TransferOptionsFlagsRow.layout()
BottomButtonRow = guiFactory.doButton2(
self.ManageForm, 'Connect/Copy/Transfer',
lambda *a: attrToolsLib.uiTransferAttributes(self),
'Create new buffer from selected buffer')
self.ManageForm(
edit=True,
af=[(ManageHeader, "top", 0), (ManageHeader, "left", 0),
(ManageHeader, "right", 0), (self.ManageAttrList, "left", 0),
(self.ManageAttrList, "right", 0),
(ManagerLoadObjectRow, "left", 5),
(ManagerLoadObjectRow, "right", 5),
(ReorderButtonsRow, "left", 0),
(ReorderButtonsRow, "right", 0),
(TransferModeFlagsRow, "left", 5),
(TransferModeFlagsRow, "right", 5),
(BottomButtonRow, "left", 5), (BottomButtonRow, "right", 5),
(TransferOptionsFlagsRow, "left", 2),
(TransferOptionsFlagsRow, "right", 2),
(TransferOptionsFlagsRow, "bottom", 4)],
ac=[(ManagerLoadObjectRow, "top", 5, ManageHeader),
(self.ManageAttrList, "top", 5, ManagerLoadObjectRow),
(self.ManageAttrList, "bottom", 5, ReorderButtonsRow),
(ReorderButtonsRow, "bottom", 5, BottomButtonRow),
(BottomButtonRow, "bottom", 5, TransferModeFlagsRow),
(TransferModeFlagsRow, "bottom", 5, TransferOptionsFlagsRow)],
attachNone=[(TransferOptionsFlagsRow, "top")])
#Build pop up for attribute list field
popUpMenu = MelPopupMenu(self.ManageAttrList, button=3)
MelMenuItem(popUpMenu,
label='Make Keyable',
c=lambda *a: attrToolsLib.uiManageAttrsKeyable(self))
MelMenuItem(popUpMenu,
label='Make Unkeyable',
c=lambda *a: attrToolsLib.uiManageAttrsUnkeyable(self))
MelMenuItemDiv(popUpMenu)
MelMenuItem(popUpMenu,
label='Hide',
c=lambda *a: attrToolsLib.uiManageAttrsHide(self))
MelMenuItem(popUpMenu,
label='Unhide',
c=lambda *a: attrToolsLib.uiManageAttrsUnhide(self))
MelMenuItemDiv(popUpMenu)
MelMenuItem(popUpMenu,
label='Lock',
c=lambda *a: attrToolsLib.uiManageAttrsLocked(self))
MelMenuItem(popUpMenu,
label='Unlock',
c=lambda *a: attrToolsLib.uiManageAttrsUnlocked(self))
MelMenuItemDiv(popUpMenu)
MelMenuItem(popUpMenu,
label='Delete',
c=lambda *a: attrToolsLib.uiManageAttrsDelete(self))
return self.ManageForm
def buildAttributeUtilitiesTool(self, parent, vis=True):
containerName = 'Utilities Container'
self.containerName = MelColumn(parent, vis=vis)
#>>> Tag Labels
mc.setParent(self.containerName)
guiFactory.header('Short cuts')
guiFactory.lineSubBreak()
AttributeUtilityRow1 = MelHLayout(self.containerName,
ut='cgmUISubTemplate',
padding=2)
guiFactory.doButton2(
AttributeUtilityRow1, 'cgmName to Float',
lambda *a: tdToolsLib.doCGMNameToFloat(),
'Makes an animatalbe float attribute using the cgmName tag')
mc.setParent(self.containerName)
guiFactory.lineSubBreak()
AttributeUtilityRow1.layout()
#>>> SDK tools
mc.setParent(self.containerName)
guiFactory.lineBreak()
guiFactory.header('SDK Tools')
guiFactory.lineSubBreak()
sdkRow = MelHLayout(self.containerName,
ut='cgmUISubTemplate',
padding=2)
guiFactory.doButton2(sdkRow, 'Select Driven Joints',
lambda *a: tdToolsLib.doSelectDrivenJoints(self),
"Selects driven joints from an sdk attribute")
sdkRow.layout()
mc.setParent(self.containerName)
guiFactory.lineSubBreak()
return self.containerName
class setToolsClass(BaseMelWindow):
from cgm.lib import guiFactory
guiFactory.initializeTemplates()
USE_Template = 'cgmUITemplate'
WINDOW_NAME = 'cgmSetToolsWindow'
WINDOW_TITLE = 'cgm.setTools - %s' % __version__
DEFAULT_SIZE = 275, 400
DEFAULT_MENU = None
RETAIN = True
MIN_BUTTON = True
MAX_BUTTON = False
FORCE_DEFAULT_SIZE = False #always resets the size of the window when its re-created
def __init__(self):
self.toolName = 'cgm.setTools'
self.description = 'This is a series of tools for working with cgm Sets'
self.author = 'Josh Burton'
self.owner = 'CG Monks'
self.website = 'www.cgmonks.com'
self.version = __version__
self.optionVars = []
self.setTypes = [
'NONE', 'animation', 'layout', 'modeling', 'td', 'fx', 'lighting'
]
self.setModes = ['<<< All Loaded Sets >>>', '<<< Active Sets >>>']
self.showHelp = False
self.helpBlurbs = []
self.oldGenBlurbs = []
self.objectSets = []
#Menu
self.setupVariables()
self.setMode = self.SetToolsModeOptionVar.value
setToolsLib.updateObjectSets(self)
self.UI_OptionsMenu = MelMenu(l='Options', pmc=self.buildOptionsMenu)
self.UI_HelpMenu = MelMenu(l='Help', pmc=self.buildHelpMenu)
self.ShowHelpOption = mc.optionVar(q='cgmVar_AnimToolsShowHelp')
#GUI
self.Main_buildLayout(self)
self.show()
def setupVariables(self):
self.ActiveObjectSetsOptionVar = OptionVarFactory(
'cgmVar_activeObjectSets', defaultValue=[''])
self.ActiveRefsOptionVar = OptionVarFactory('cgmVar_activeRefs',
defaultValue=[''])
self.ActiveTypesOptionVar = OptionVarFactory('cgmVar_activeTypes',
defaultValue=[''])
self.SetToolsModeOptionVar = OptionVarFactory('cgmVar_setToolsMode',
defaultValue=0)
self.KeyTypeOptionVar = OptionVarFactory('cgmVar_KeyType',
defaultValue=0)
self.ShowHelpOptionVar = OptionVarFactory('cgmVar_setToolsShowHelp',
defaultValue=0)
self.MaintainLocalSetGroupOptionVar = OptionVarFactory(
'cgmVar_MaintainLocalSetGroup', defaultValue=0)
self.HideSetGroupOptionVar = OptionVarFactory('cgmVar_HideSetGroups',
defaultValue=1)
self.HideNonQssOptionVar = OptionVarFactory('cgmVar_HideNonQss',
defaultValue=1)
self.HideAnimLayerSetsOptionVar = OptionVarFactory(
'cgmVar_HideAnimLayerSets', defaultValue=1)
self.HideMayaSetsOptionVar = OptionVarFactory('cgmVar_HideMayaSets',
defaultValue=1)
guiFactory.appendOptionVarList(self,
self.ActiveObjectSetsOptionVar.name)
guiFactory.appendOptionVarList(self, self.ActiveRefsOptionVar.name)
guiFactory.appendOptionVarList(self, self.ActiveTypesOptionVar.name)
guiFactory.appendOptionVarList(self, self.SetToolsModeOptionVar.name)
guiFactory.appendOptionVarList(self, self.ShowHelpOptionVar.name)
guiFactory.appendOptionVarList(self, self.KeyTypeOptionVar.name)
guiFactory.appendOptionVarList(self, self.HideSetGroupOptionVar.name)
guiFactory.appendOptionVarList(self, self.HideNonQssOptionVar.name)
guiFactory.appendOptionVarList(
self, self.MaintainLocalSetGroupOptionVar.name)
guiFactory.appendOptionVarList(self,
self.HideAnimLayerSetsOptionVar.name)
guiFactory.appendOptionVarList(self, self.HideMayaSetsOptionVar.name)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Menus
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def buildOptionsMenu(self, *a):
self.UI_OptionsMenu.clear()
#Ref menu
self.refPrefixDict = {}
self.activeRefsCBDict = {}
if self.refPrefixes and len(self.refPrefixes) > 1:
refMenu = MelMenuItem(self.UI_OptionsMenu,
l='Load Refs:',
subMenu=True)
MelMenuItem(refMenu,
l='All',
c=Callback(setToolsLib.doSetAllRefState, self, True))
MelMenuItemDiv(refMenu)
for i, n in enumerate(self.refPrefixes):
self.refPrefixDict[i] = n
activeState = False
if self.ActiveRefsOptionVar.value:
if n in self.ActiveRefsOptionVar.value:
activeState = True
tmp = MelMenuItem(refMenu,
l=n,
cb=activeState,
c=Callback(setToolsLib.doSetRefState, self,
i, not activeState))
self.activeRefsCBDict[i] = tmp
MelMenuItemDiv(refMenu)
MelMenuItem(refMenu,
l='Clear',
c=Callback(setToolsLib.doSetAllRefState, self, False))
#Types menu
self.typeDict = {}
self.activeTypesCBDict = {}
if self.setTypes:
typeMenu = MelMenuItem(self.UI_OptionsMenu,
l='Load Types: ',
subMenu=True)
MelMenuItem(typeMenu,
l='All',
c=Callback(setToolsLib.doSetAllTypeState, self, True))
MelMenuItemDiv(typeMenu)
for i, n in enumerate(self.setTypes):
self.typeDict[i] = n
activeState = False
if self.ActiveTypesOptionVar.value:
if n in self.ActiveTypesOptionVar.value:
activeState = True
tmp = MelMenuItem(typeMenu,
l=n,
cb=activeState,
c=Callback(setToolsLib.doSetTypeState, self,
i, not activeState))
self.activeTypesCBDict[i] = tmp
MelMenuItemDiv(typeMenu)
MelMenuItem(typeMenu,
l='Clear',
c=Callback(setToolsLib.doSetAllTypeState, self, False))
#>>> Grouping Options
GroupingMenu = MelMenuItem(self.UI_OptionsMenu,
l='Grouping',
subMenu=True)
#guiFactory.appendOptionVarList(self,'cgmVar_MaintainLocalSetGroup')
MelMenuItem(GroupingMenu,
l="Group Local",
c=lambda *a: setToolsLib.doGroupLocal(self))
MelMenuItem(GroupingMenu,
l="Maintain Local Set Group",
cb=mc.optionVar(q='cgmVar_MaintainLocalSetGroup'),
c=lambda *a: setToolsLib.doSetMaintainLocalSetGroup(self))
#>>> Autohide Options
HidingMenu = MelMenuItem(self.UI_OptionsMenu,
l='Auto Hide',
subMenu=True)
#guiFactory.appendOptionVarList(self,'cgmVar_MaintainLocalSetGroup')
MelMenuItem(HidingMenu,
l="Anim Layer Sets",
cb=self.HideAnimLayerSetsOptionVar.value,
c=lambda *a: setToolsLib.uiToggleOptionCB(
self, self.HideAnimLayerSetsOptionVar))
MelMenuItem(HidingMenu,
l="Maya Sets",
cb=self.HideMayaSetsOptionVar.value,
c=lambda *a: setToolsLib.uiToggleOptionCB(
self, self.HideMayaSetsOptionVar))
MelMenuItem(HidingMenu,
l="Non Qss Sets",
cb=self.HideNonQssOptionVar.value,
c=lambda *a: setToolsLib.uiToggleOptionCB(
self, self.HideNonQssOptionVar))
MelMenuItem(HidingMenu,
l="Set Groups",
cb=self.HideSetGroupOptionVar.value,
c=lambda *a: setToolsLib.uiToggleOptionCB(
self, self.HideSetGroupOptionVar))
#>>> Keying Options
KeyMenu = MelMenuItem(self.UI_OptionsMenu, l='Key type', subMenu=True)
KeyMenuCollection = MelRadioMenuCollection()
if self.KeyTypeOptionVar.value == 0:
regKeyOption = True
bdKeyOption = False
else:
regKeyOption = False
bdKeyOption = True
KeyMenuCollection.createButton(
KeyMenu,
l=' Reg ',
c=lambda *a: self.KeyTypeOptionVar.set(0),
rb=regKeyOption)
KeyMenuCollection.createButton(
KeyMenu,
l=' Breakdown ',
c=lambda *a: self.KeyTypeOptionVar.set(1),
rb=bdKeyOption)
#>>> Reset Options
MelMenuItemDiv(self.UI_OptionsMenu)
MelMenuItem(self.UI_OptionsMenu,
l="Reload",
c=lambda *a: self.reload())
MelMenuItem(self.UI_OptionsMenu, l="Reset", c=lambda *a: self.reset())
def reset(self):
Callback(guiFactory.resetGuiInstanceOptionVars(self.optionVars, run))
def reload(self):
run()
def buildHelpMenu(self, *a):
self.UI_HelpMenu.clear()
MelMenuItem(self.UI_HelpMenu,
l="Show Help",
cb=self.ShowHelpOption,
c=lambda *a: self.do_showHelpToggle())
MelMenuItem(self.UI_HelpMenu,
l="Print Set Report",
c=lambda *a: self.printReport())
MelMenuItem(self.UI_HelpMenu,
l="Print Tools Help",
c=lambda *a: self.printHelp())
MelMenuItemDiv(self.UI_HelpMenu)
MelMenuItem(self.UI_HelpMenu, l="About", c=lambda *a: self.showAbout())
def do_showHelpToggle(self):
guiFactory.toggleMenuShowState(self.ShowHelpOption, self.helpBlurbs)
mc.optionVar(iv=('cgmVar_setToolsShowHelp', not self.ShowHelpOption))
self.ShowHelpOption = mc.optionVar(q='cgmVar_setToolsShowHelp')
def showAbout(self):
window = mc.window(title="About",
iconName='About',
ut='cgmUITemplate',
resizeToFitChildren=True)
mc.columnLayout(adjustableColumn=True)
guiFactory.header(self.toolName, overrideUpper=True)
mc.text(label='>>>A Part of the cgmTools Collection<<<',
ut='cgmUIInstructionsTemplate')
guiFactory.headerBreak()
guiFactory.lineBreak()
descriptionBlock = guiFactory.textBlock(self.description)
guiFactory.lineBreak()
mc.text(label=('%s%s' % ('Written by: ', self.author)))
mc.text(label=('%s%s%s' % ('Copyright ', self.owner, ', 2011')))
guiFactory.lineBreak()
mc.text(label='Version: %s' % self.version)
mc.text(label='')
guiFactory.doButton(
'Visit Tool Webpage',
'import webbrowser;webbrowser.open(" http://www.cgmonks.com/tools/maya-tools/setTools/")'
)
guiFactory.doButton(
'Close', 'import maya.cmds as mc;mc.deleteUI(\"' + window +
'\", window=True)')
mc.setParent('..')
mc.showWindow(window)
def printHelp(self):
help(setToolsLib)
def printReport(self):
setToolsLib.printReport(self)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Layouts
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def Main_buildLayout(self, parent):
def modeSet(item):
i = self.setModes.index(item)
self.SetToolsModeOptionVar.set(i)
self.setMode = i
MainForm = MelFormLayout(parent)
#>>> Snap Section
SetHeader = guiFactory.header('Sets')
HelpInfo = MelLabel(
MainForm,
l=
" Set buffer options: Set active, select, change name,add,remove,key,purge",
ut='cgmUIInstructionsTemplate',
al='center',
ww=True,
vis=self.ShowHelpOption)
self.helpBlurbs.extend([HelpInfo])
#>>> All Sets menu
AllSetsRow = MelFormLayout(MainForm, height=20)
activeState = True
i = 1
if self.objectSets:
for b in self.objectSets:
if b not in self.ActiveObjectSetsOptionVar.value:
activeState = False
else:
activeState = False
tmpActive = MelCheckBox(
AllSetsRow,
annotation='Sets all sets active',
value=activeState,
onCommand=Callback(setToolsLib.doSetAllSetsAsActive, self),
offCommand=Callback(setToolsLib.doSetAllSetsAsInactive, self))
tmpSel = guiFactory.doButton2(
AllSetsRow, ' s ', lambda *a: setToolsLib.doSelectMultiSets(
self, self.SetToolsModeOptionVar.value),
'Select All Loaded/Active Sets')
# Mode toggle box
self.SetModeOptionMenu = MelOptionMenu(AllSetsRow, cc=modeSet)
for m in self.setModes:
self.SetModeOptionMenu.append(m)
self.SetModeOptionMenu.selectByIdx(self.setMode, False)
tmpKey = guiFactory.doButton2(
AllSetsRow, ' k ', lambda *a: setToolsLib.doKeyMultiSets(
self, self.SetToolsModeOptionVar.value), 'Key All Sets')
tmpDeleteKey = guiFactory.doButton2(
AllSetsRow, ' d ', lambda *a: setToolsLib.doDeleteMultiCurrentKeys(
self, self.SetToolsModeOptionVar.value), 'Delete All Set Keys')
tmpReset = guiFactory.doButton2(
AllSetsRow, ' r ', lambda *a: setToolsLib.doResetMultiSets(
self, self.SetToolsModeOptionVar.value), 'Reset All Set Keys')
mc.formLayout(AllSetsRow,
edit=True,
af=[(tmpActive, "left", 10), (tmpReset, "right", 10)],
ac=[(tmpSel, "left", 0, tmpActive),
(self.SetModeOptionMenu, "left", 4, tmpSel),
(self.SetModeOptionMenu, "right", 4, tmpKey),
(tmpKey, "right", 2, tmpDeleteKey),
(tmpDeleteKey, "right", 2, tmpReset)])
#>>> Sets building section
allPopUpMenu = MelPopupMenu(self.SetModeOptionMenu, button=3)
allCategoryMenu = MelMenuItem(allPopUpMenu,
label='Make Type:',
sm=True)
multiMakeQssMenu = MelMenuItem(allPopUpMenu,
label='Make Qss',
c=Callback(setToolsLib.doMultiSetQss,
self, True))
multiMakeNotQssMenu = MelMenuItem(allPopUpMenu,
label='Clear Qss State',
c=Callback(setToolsLib.doMultiSetQss,
self, False))
#Mulit set type
for n in self.setTypes:
MelMenuItem(allCategoryMenu,
label=n,
c=Callback(setToolsLib.doMultiSetType, self,
self.SetToolsModeOptionVar.value, n))
#>>> Sets building section
SetListScroll = MelScrollLayout(MainForm, cr=1, ut='cgmUISubTemplate')
SetMasterForm = MelFormLayout(SetListScroll)
SetListColumn = MelColumnLayout(SetMasterForm, adj=True, rowSpacing=3)
self.objectSetsDict = {}
self.activeSetsCBDict = {}
for b in self.objectSets:
#Store the info to a dict
try:
i = self.setInstancesFastIndex[b] # get the index
sInstance = self.setInstances[i] # fast link to the instance
except:
raise StandardError("'%s' failed to query an active instance" %
b)
#see if the no no fields are enabled
enabledMenuLogic = True
if sInstance.mayaSetState or sInstance.refState:
enabledMenuLogic = False
tmpSetRow = MelFormLayout(SetListColumn, height=20)
#Get check box state
activeState = False
if sInstance.nameShort in self.ActiveObjectSetsOptionVar.value:
activeState = True
tmpActive = MelCheckBox(
tmpSetRow,
annotation='make set as active',
value=activeState,
onCommand=Callback(setToolsLib.doSetSetAsActive, self, i),
offCommand=Callback(setToolsLib.doSetSetAsInactive, self, i))
self.activeSetsCBDict[i] = tmpActive
tmpSel = guiFactory.doButton2(
tmpSetRow, ' s ',
Callback(setToolsLib.doSelectSetObjects, self, i),
'Select the set objects')
tmpName = MelTextField(tmpSetRow,
w=100,
ut='cgmUIReservedTemplate',
text=sInstance.nameShort,
editable=enabledMenuLogic)
tmpName(edit=True,
ec=Callback(setToolsLib.doUpdateSetName, self, tmpName, i))
tmpAdd = guiFactory.doButton2(tmpSetRow,
'+',
Callback(setToolsLib.doAddSelected,
self, i),
'Add selected to the set',
en=not sInstance.refState)
tmpRem = guiFactory.doButton2(tmpSetRow,
'-',
Callback(
setToolsLib.doRemoveSelected,
self, i),
'Remove selected to the set',
en=not sInstance.refState)
tmpKey = guiFactory.doButton2(
tmpSetRow, 'k', Callback(setToolsLib.doKeySet, self, i),
'Key set')
tmpDeleteKey = guiFactory.doButton2(
tmpSetRow, 'd',
Callback(setToolsLib.doDeleteCurrentSetKey, self, i),
'delete set key')
tmpReset = guiFactory.doButton2(
tmpSetRow, 'r', Callback(setToolsLib.doResetSet, self, i),
'Reset Set')
mc.formLayout(tmpSetRow,
edit=True,
af=[(tmpActive, "left", 4), (tmpReset, "right", 2)],
ac=[(tmpSel, "left", 0, tmpActive),
(tmpName, "left", 2, tmpSel),
(tmpName, "right", 4, tmpAdd),
(tmpAdd, "right", 2, tmpRem),
(tmpRem, "right", 2, tmpKey),
(tmpKey, "right", 2, tmpDeleteKey),
(tmpDeleteKey, "right", 2, tmpReset)])
MelSpacer(tmpSetRow, w=2)
#Build pop up for text field
popUpMenu = MelPopupMenu(tmpName, button=3)
MelMenuItem(popUpMenu, label="<<<%s>>>" % b, enable=False)
if not enabledMenuLogic:
if sInstance.mayaSetState:
MelMenuItem(popUpMenu,
label="<Maya Default Set>",
enable=False)
if sInstance.refState:
MelMenuItem(popUpMenu, label="<Referenced>", enable=False)
qssState = sInstance.qssState
qssMenu = MelMenuItem(popUpMenu,
label='Qss',
cb=qssState,
en=enabledMenuLogic,
c=Callback(self.setInstances[i].isQss,
not qssState))
categoryMenu = MelMenuItem(popUpMenu,
label='Make Type:',
sm=True,
en=enabledMenuLogic)
for n in self.setTypes:
MelMenuItem(categoryMenu,
label=n,
c=Callback(setToolsLib.guiDoSetType, self, i, n))
MelMenuItem(popUpMenu,
label='Copy Set',
c=Callback(setToolsLib.doCopySet, self, i))
MelMenuItem(popUpMenu,
label='Purge',
en=enabledMenuLogic,
c=Callback(setToolsLib.doPurgeSet, self, i))
MelMenuItemDiv(popUpMenu)
MelMenuItem(popUpMenu,
label='Delete',
en=enabledMenuLogic,
c=Callback(setToolsLib.doDeleteSet, self, i))
NewSetRow = guiFactory.doButton2(
MainForm, 'Create Set', lambda *a: setToolsLib.doCreateSet(self),
'Create new buffer from selected buffer')
SetMasterForm(edit=True,
af=[(SetListColumn, "top", 0),
(SetListColumn, "left", 0),
(SetListColumn, "right", 0),
(SetListColumn, "bottom", 0)])
MainForm(edit=True,
af=[(SetHeader, "top", 0), (SetHeader, "left", 0),
(SetHeader, "right", 0), (HelpInfo, "left", 0),
(HelpInfo, "right", 0), (AllSetsRow, "left", 0),
(AllSetsRow, "right", 0), (SetListScroll, "left", 0),
(SetListScroll, "right", 0), (NewSetRow, "left", 4),
(NewSetRow, "right", 4), (NewSetRow, "bottom", 4)],
ac=[(HelpInfo, "top", 0, SetHeader),
(AllSetsRow, "top", 2, HelpInfo),
(SetListScroll, "top", 2, AllSetsRow),
(SetListScroll, "bottom", 0, NewSetRow)],
attachNone=[(NewSetRow, "top")])
class bufferToolsClass(BaseMelWindow):
from cgm.lib import guiFactory
guiFactory.initializeTemplates()
USE_Template = 'cgmUITemplate'
WINDOW_NAME = 'cgmBufferToolsWindow'
WINDOW_TITLE = 'cgm.bufferTools'
DEFAULT_SIZE = 265, 200
DEFAULT_MENU = None
RETAIN = True
MIN_BUTTON = True
MAX_BUTTON = False
FORCE_DEFAULT_SIZE = True #always resets the size of the window when its re-created
def __init__( self):
self.toolName = 'cgm.bufferTools'
self.description = 'This is a series of tools for working with cgm Buffers'
self.author = 'Josh Burton'
self.owner = 'CG Monks'
self.website = 'www.cgmonks.com'
self.version = __version__
self.optionVars = []
self.activeObjectBuffersOptionVar = OptionVarFactory('cgmVar_activeObjectBuffers','string')
guiFactory.appendOptionVarList(self,'cgmVar_activeObjectBuffers')
self.showHelp = False
self.helpBlurbs = []
self.oldGenBlurbs = []
self.objectBuffers = []
bufferToolsLib.updateObjectBuffers(self)
#Menu
self.setupVariables
self.UI_OptionsMenu = MelMenu( l='Options', pmc=self.buildOptionsMenu)
self.UI_HelpMenu = MelMenu( l='Help', pmc=self.buildHelpMenu)
self.ShowHelpOption = mc.optionVar( q='cgmVar_AnimToolsShowHelp' )
#GUI
self.Main_buildLayout(self)
self.show()
def setupVariables():
if not mc.optionVar( ex='cgmVar_ForceBoundingBoxState' ):
mc.optionVar( iv=('cgmVar_ForceBoundingBoxState', 0) )
if not mc.optionVar( ex='cgmVar_ForceEveryFrame' ):
mc.optionVar( iv=('cgmVar_ForceEveryFrame', 0) )
if not mc.optionVar( ex='cgmVar_bufferToolsShowHelp' ):
mc.optionVar( iv=('cgmVar_bufferToolsShowHelp', 0) )
if not mc.optionVar( ex='cgmVar_CurrentFrameOnly' ):
mc.optionVar( iv=('cgmVar_CurrentFrameOnly', 0) )
if not mc.optionVar( ex='cgmVar_bufferToolsShowHelp' ):
mc.optionVar( iv=('cgmVar_bufferToolsShowHelp', 0) )
guiFactory.appendOptionVarList(self,'cgmVar_bufferToolsShowHelp')
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Menus
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def buildOptionsMenu( self, *a ):
self.UI_OptionsMenu.clear()
# Placement Menu
PlacementMenu = MelMenuItem( self.UI_OptionsMenu, l='Placement', subMenu=True)
PlacementMenuCollection = MelRadioMenuCollection()
if mc.optionVar( q='cgmVar_ForceBoundingBoxState' ) == 0:
cgmOption = False
pivotOption = True
else:
cgmOption = True
pivotOption = False
PlacementMenuCollection.createButton(PlacementMenu,l='Bounding Box Center',
c=lambda *a: mc.optionVar( iv=('cgmVar_ForceBoundingBoxState', 1)),
rb=cgmOption )
PlacementMenuCollection.createButton(PlacementMenu,l='Pivot',
c=lambda *a: mc.optionVar( iv=('cgmVar_ForceBoundingBoxState', 0)),
rb=pivotOption )
# Tagging options
AutoloadMenu = MelMenuItem( self.UI_OptionsMenu, l='Tagging', subMenu=True)
if not mc.optionVar( ex='cgmVar_TaggingUpdateRO' ):
mc.optionVar( iv=('cgmVar_TaggingUpdateRO', 1) )
guiFactory.appendOptionVarList(self,'cgmVar_TaggingUpdateRO')
RenameOnUpdateState = mc.optionVar( q='cgmVar_TaggingUpdateRO' )
MelMenuItem( AutoloadMenu, l="Update Rotation Order",
cb= mc.optionVar( q='cgmVar_TaggingUpdateRO' ),
c= lambda *a: guiFactory.doToggleIntOptionVariable('cgmVar_TaggingUpdateRO'))
MelMenuItemDiv( self.UI_OptionsMenu )
MelMenuItem( self.UI_OptionsMenu, l="Reset",
c=lambda *a: self.reset())
def reset(self):
guiFactory.resetGuiInstanceOptionVars(self.optionVars,run)
def buildHelpMenu( self, *a ):
self.UI_HelpMenu.clear()
MelMenuItem( self.UI_HelpMenu, l="Show Help",
cb=self.ShowHelpOption,
c= lambda *a: self.do_showHelpToggle())
MelMenuItem( self.UI_HelpMenu, l="Print Tools Help",
c=lambda *a: self.printHelp() )
MelMenuItemDiv( self.UI_HelpMenu )
MelMenuItem( self.UI_HelpMenu, l="About",
c=lambda *a: self.showAbout() )
def do_showHelpToggle( self):
guiFactory.toggleMenuShowState(self.ShowHelpOption,self.helpBlurbs)
mc.optionVar( iv=('cgmVar_bufferToolsShowHelp', not self.ShowHelpOption))
self.ShowHelpOption = mc.optionVar( q='cgmVar_bufferToolsShowHelp' )
def do_showTimeSubMenuToggleOn( self):
guiFactory.toggleMenuShowState(1,self.timeSubMenu)
mc.optionVar( iv=('cgmVar_CurrentFrameOnly', 1))
def do_showTimeSubMenuToggleOff( self):
guiFactory.toggleMenuShowState(0,self.timeSubMenu)
mc.optionVar( iv=('cgmVar_CurrentFrameOnly', 0))
def showAbout(self):
window = mc.window( title="About", iconName='About', ut = 'cgmUITemplate',resizeToFitChildren=True )
mc.columnLayout( adjustableColumn=True )
guiFactory.header(self.toolName,overrideUpper = True)
mc.text(label='>>>A Part of the cgmTools Collection<<<', ut = 'cgmUIInstructionsTemplate')
guiFactory.headerBreak()
guiFactory.lineBreak()
descriptionBlock = guiFactory.textBlock(self.description)
guiFactory.lineBreak()
mc.text(label=('%s%s' %('Written by: ',self.author)))
mc.text(label=('%s%s%s' %('Copyright ',self.owner,', 2011')))
guiFactory.lineBreak()
mc.text(label='Version: %s' % self.version)
mc.text(label='')
guiFactory.doButton('Visit Tool Webpage', 'import webbrowser;webbrowser.open(" http://www.cgmonks.com/tools/maya-tools/bufferTools/")')
guiFactory.doButton('Close', 'import maya.cmds as mc;mc.deleteUI(\"' + window + '\", window=True)')
mc.setParent( '..' )
mc.showWindow( window )
def printHelp(self):
import bufferToolsLib
help(bufferToolsLib)
def do_everyFrameToggle( self):
EveryFrameOption = mc.optionVar( q='cgmVar_ForceEveryFrame' )
guiFactory.toggleMenuShowState(EveryFrameOption,self.timeSubMenu)
mc.optionVar( iv=('cgmVar_ForceEveryFrame', not EveryFrameOption))
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Layouts
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def buildPlaceHolder(self,parent):
self.containerName = MelColumnLayout(parent,ut='cgmUISubTemplate')
return self.containerName
def Main_buildLayout(self,parent):
MainForm = MelFormLayout(parent)
#>>> Snap Section
BufferHeader = guiFactory.header('Buffers')
HelpInfo = MelLabel(MainForm,
l = " Set buffer options: Set active, select, change name,add,remove,key,purge",
ut = 'cgmUIInstructionsTemplate',
al = 'center',
ww = True,vis = self.ShowHelpOption)
self.helpBlurbs.extend([HelpInfo])
BufferListScroll = MelScrollLayout(MainForm,cr = 1, ut = 'cgmUISubTemplate')
BufferMasterForm = MelFormLayout(BufferListScroll)
BufferListColumn = MelColumnLayout(BufferMasterForm, adj = True, rowSpacing = 3)
for i,b in enumerate(self.objectBuffers):
tmpSetRow = MelFormLayout(BufferListColumn,height = 20)
#Get check box state
activeState = False
if b in self.activeObjectBuffersOptionVar.value:
activeState = True
tmpActive = MelCheckBox(tmpSetRow,
annotation = 'Set buffer set as active',
value = activeState,
onCommand = "%s%s%s"%("from cgm.tools.lib import bufferToolsLib;bufferToolsLib.setBufferAsActive('cgmVar_activeObjectBuffers','",b,"')"),
offCommand = "%s%s%s"%("from cgm.tools.lib import bufferToolsLib;bufferToolsLib.setBufferAsInactive('cgmVar_activeObjectBuffers','",b,"')"))
tmpSel = guiFactory.doButton2(tmpSetRow,
's->',
"%s%s%s"%("from cgm.tools.lib import bufferToolsLib;bufferToolsLib.selectBufferObjects('",b,"')"),
'Select the buffer objects')
tmpName = MelTextField(tmpSetRow, w = 100,ut = 'cgmUIReservedTemplate', text = b)
bField = "%s"%tmpName
bName = "%s"%b
tmpName(edit = True,
ec = lambda *a:bufferToolsLib.updateBufferName(self,bField,bName))
"""
tmpName(edit = True,
ec = "%s%s%s%s%s%s%s"%("from cgm.tools.lib import bufferToolsLib;bufferToolsLib.updateBufferName('",self,"','",tmpName,"','",b,"')"))
"""
tmpAdd = guiFactory.doButton2(tmpSetRow,
'+',
"%s%s%s"%("from cgm.tools.lib import bufferToolsLib;bufferToolsLib.addSelected('",b,"')"),
'Add selected to the buffer')
tmpRem= guiFactory.doButton2(tmpSetRow,
'-',
"%s%s%s"%("from cgm.tools.lib import bufferToolsLib;bufferToolsLib.removeSelected('",b,"')"),
'Remove selected to the buffer')
tmpKey = guiFactory.doButton2(tmpSetRow,
'k',
"%s%s%s"%("from cgm.tools.lib import bufferToolsLib;bufferToolsLib.keyBuffer('",b,"')"),
'Key buffer')
tmpPurge = guiFactory.doButton2(tmpSetRow,
'p',
"%s%s%s"%("from cgm.tools.lib import bufferToolsLib;bufferToolsLib.purgeBuffer('",b,"')"),
'Purge buffer')
mc.formLayout(tmpSetRow, edit = True,
af = [(tmpActive, "left", 2),
(tmpPurge,"right",0)],
ac = [(tmpSel,"left",0,tmpActive),
(tmpName,"left",2,tmpSel),
(tmpName,"right",2,tmpAdd),
(tmpAdd,"right",2,tmpRem),
(tmpRem,"right",2,tmpKey),
(tmpKey,"right",2,tmpPurge)])
MelSpacer(tmpSetRow, w = 2)
NewBufferRow = guiFactory.doButton2(MainForm,
'Create Buffer',
lambda *a:bufferToolsLib.createBuffer(self),
'Create new buffer from selected buffer')
BufferMasterForm(edit = True,
af = [(BufferListColumn,"top",0),
(BufferListColumn,"left",0),
(BufferListColumn,"right",0),
(BufferListColumn,"bottom",0)])
MainForm(edit = True,
af = [(BufferHeader,"top",0),
(BufferHeader,"left",0),
(BufferHeader,"right",0),
(HelpInfo,"left",0),
(HelpInfo,"right",0),
(BufferListScroll,"left",0),
(BufferListScroll,"right",0),
(NewBufferRow,"left",4),
(NewBufferRow,"right",4),
(NewBufferRow,"bottom",4)],
ac = [(HelpInfo,"top",0,BufferHeader),
(BufferListScroll,"top",0,HelpInfo),
(BufferListScroll,"bottom",0,NewBufferRow)],
attachNone = [(NewBufferRow,"top")])
"""
formLayout -e
-af $opts "top" 0
-af $opts "left" 0
-af $opts "right" 0
-ac $labelForm "top" 0 $opts
-af $labelForm "left" 0
-af $labelForm "right" 0
-ac $list "top" 0 $labelForm
-af $list "left" 0
-af $list "right" 0
-ac $list "bottom" 2 $newset
-af $newset "left" 0
-af $newset "right" 0
-ac $newset "bottom" 2 $image
-af $image "left" 0
-af $image "right" 0
-af $image "bottom" 0
$master;
formLayout -e
-af $allsel "left" 0
-ac $alllbl "left" 0 $allsel
-ac $alllbl "right" 0 $alladd
-ac $alladd "right" 0 $allrem
-ac $allrem "right" 0 $alldel
-af $alldel "right" 42
$labelForm;
formLayout -e
-af $setList "top" 0
-af $setList "left" 0
-af $setList "right" 0
-af $setList "bottom" 0
$qssMaster;
"""
def MainBackup_buildLayout(self,parent):
BufferLayout = MelColumnLayout(parent)
#>>> Snap Section
guiFactory.header('Buffers')
guiFactory.lineSubBreak()
bufferScroll = MelScrollLayout(BufferLayout,cr = 1)
for i,b in enumerate(self.objectBuffers):
self.b = MelHSingleStretchLayout(bufferScroll,h = 20)
MelSpacer(self.b, w = 2)
"""
lambda *a:bufferToolsLib.selectBufferObjects(self.objectBuffers[i]),
"%s%s%s"%("from cgm.tools.lib import bufferToolsLib;bufferToolsLib.selectBufferObjects('",b,"')"),
"""
guiFactory.doButton2(self.b,
'Sel',
"%s%s%s"%("from cgm.tools.lib import bufferToolsLib;bufferToolsLib.selectBufferObjects('",b,"')"),
'Select the buffer objects')
tmp = MelTextField(self.b, w = 100,ut = 'cgmUIReservedTemplate', text = b, editable = False)
self.b.setStretchWidget(tmp)
guiFactory.doButton2(self.b,
'+',
"%s%s%s"%("from cgm.tools.lib import bufferToolsLib;bufferToolsLib.addSelected('",b,"')"),
'Add selected to the buffer')
guiFactory.doButton2(self.b,
'-',
"%s%s%s"%("from cgm.tools.lib import bufferToolsLib;bufferToolsLib.removeSelected('",b,"')"),
'Remove selected to the buffer')
guiFactory.doButton2(self.b,
'k',
"%s%s%s"%("from cgm.tools.lib import bufferToolsLib;bufferToolsLib.keyBuffer('",b,"')"),
'Key buffer')
guiFactory.doButton2(self.b,
'p',
"%s%s%s"%("from cgm.tools.lib import bufferToolsLib;bufferToolsLib.purgeBuffer('",b,"')"),
'Purge buffer')
MelSpacer(self.b, w = 2)
self.b.layout()
mc.setParent(BufferLayout)
guiFactory.lineSubBreak()
guiFactory.lineBreak()
guiFactory.doButton2(BufferLayout,
'Create Buffer',
lambda *a:bufferToolsLib.createBuffer(self),
'Create new buffer from selected buffer')
"""
for b in self.objectBuffers:
self.b = MelFormLayout(BufferLayout,height = 20)
tmpSel = guiFactory.doButton2(self.b,
'Sel',
lambda *a:bufferToolsLib.selectBufferObjects(b),
'Select the buffer objects')
tmpName = MelTextField(self.b, w = 100,ut = 'cgmUIReservedTemplate', text = b, editable = False)
tmpAdd = guiFactory.doButton2(self.b,
'+',
lambda *a:bufferToolsLib.addSelected(b),
'Add selected to the buffer')
tmpRem= guiFactory.doButton2(self.b,
'-',
lambda *a:bufferToolsLib.removeSelected(b),
'Remove selected to the buffer')
tmpKey = guiFactory.doButton2(self.b,
'k',
lambda *a:bufferToolsLib.keyBuffer(b),
'Key buffer')
tmpPurge = guiFactory.doButton2(self.b,
'p',
lambda *a:bufferToolsLib.purgeBuffer(b),
'Purge buffer')
mc.formLayout(self.b, edit = True,
af = [tmpSel, "left", 0],
ac = [tmpName,"left",0,tmpSel],
ac = [tmpName,"right",0,tmpAdd],
ac = [tmpAdd,"right",0,tmpRem],
ac = [tmpRem,"right",0,tmpKey],
ac = [tmpKey,"right",0,tmpPurge],
af = [tmpPurge,"right",0])
"""
"""