def uiAutoNameWalkUp(self):
autoNameObject = mc.textField(self.AutoNameObjectField, q=True, text=True)
if autoNameObject:
parent = search.returnParentObject(autoNameObject, False)
if parent:
mc.textField(self.AutoNameObjectField, e=True, text=parent)
mc.select(parent)
uiUpdateAutoNamePreview(self)
uiLoadAutoNameObject(self)
else:
guiFactory.warning('No parent found!')
else:
guiFactory.warning('No current autoname object loaded!')
def uiAutoNameWalkUp(self):
autoNameObject = mc.textField(self.AutoNameObjectField,q=True,text = True)
if autoNameObject:
parent = search.returnParentObject(autoNameObject,False)
if parent:
mc.textField(self.AutoNameObjectField,e=True,text = parent)
mc.select(parent)
uiUpdateAutoNamePreview(self)
uiLoadAutoNameObject(self)
else:
guiFactory.warning('No parent found!')
else:
guiFactory.warning('No current autoname object loaded!')
def doParentToWorld(obj):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Parents an object to the world
ARGUMENTS:
objList(list)
RETURNS:
obj(string) - new name if parented to world
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
parents = search.returnParentObject(obj)
if parents != False:
returnBuffer = mc.parent(obj,world = True)
return returnBuffer[0]
else:
return obj
def doParentToWorld(obj):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Parents an object to the world
ARGUMENTS:
objList(list)
RETURNS:
obj(string) - new name if parented to world
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
parents = search.returnParentObject(obj)
if parents != False:
returnBuffer = mc.parent(obj, world=True)
return returnBuffer[0]
else:
return obj
def storeTemplateRootParent(moduleNull):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Stores the template root parent to the root control if there is a new one
ARGUMENTS:
moduleNull(string)
RETURNS:
success(bool)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
templateNull = modules.returnTemplateNull(moduleNull)
root = modules.returnInfoNullObjects(moduleNull,
'templatePosObjects',
types='templateRoot')
parent = search.returnParentObject(root, False)
if parent != templateNull:
if parent != False:
attributes.storeObjectToMessage(parent, root, 'skeletonParent')
return True
return False
def returnObjectGeneratedNameDict(obj, ignore=[False]):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns a generated dictionary of name info
ARGUMENTS:
obj(string) - object
ignore(string) - default is 'none', only culls out cgmtags that are
generated via returnCGMOrder() function
RETURNS:
namesDict(string)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
typesDictionary = dictionary.initializeDictionary(typesDictionaryFile)
namesDictionary = dictionary.initializeDictionary(namesDictionaryFile)
settingsDictionary = dictionary.initializeDictionary(
settingsDictionaryFile)
namesDict = {}
divider = returnCGMDivider()
order = returnCGMOrder()
nameBuilder = []
#>>> Get our cgmVar_iables
userAttrs = attributes.returnUserAttributes(obj)
cgmAttrs = lists.returnMatchList(userAttrs, order)
#>>> Tag ignoring
if ignore:
for i in ignore:
if i in order:
order.remove(i)
#>>> Geting our data
for tag in order:
tagInfo = search.findRawTagInfo(obj, tag)
if tagInfo is not False:
namesDict[tag] = (tagInfo)
""" remove tags up stream that we don't want if they don't exist on the actual object"""
if mc.objExists(obj + '.cgmTypeModifier') != True:
if namesDict.get('cgmTypeModifier') != None:
namesDict.pop('cgmTypeModifier')
#>>> checks if the names exist as objects or it's a shape node
ChildNameObj = False
nameObj = search.returnTagInfo(obj, 'cgmName')
typeTag = search.returnTagInfo(obj, 'cgmType')
isType = search.returnObjectType(obj)
childrenObjects = search.returnChildrenObjects(obj)
"""first see if it's a group """
if childrenObjects > 0 and isType == 'transform' and typeTag == False:
""" if it's a transform group """
groupNamesDict = {}
if not nameObj:
groupNamesDict['cgmName'] = childrenObjects[0]
else:
groupNamesDict['cgmName'] = nameObj
groupNamesDict['cgmType'] = typesDictionary.get('transform')
if namesDict.get('cgmDirection') != None:
groupNamesDict['cgmDirection'] = namesDict.get('cgmDirection')
if namesDict.get('cgmDirectionModifier') != None:
groupNamesDict['cgmDirectionModifier'] = namesDict.get(
'cgmDirectionModifier')
if namesDict.get('cgmTypeModifier') != None:
groupNamesDict['cgmTypeModifier'] = namesDict.get(
'cgmTypeModifier')
return groupNamesDict
""" see if there's a name tag"""
elif nameObj != None or isType == 'shape':
"""if there is, does it exist """
if mc.objExists(nameObj) == True:
"""basic child object with cgmName tag """
childNamesDict = {}
childNamesDict['cgmName'] = namesDict.get('cgmName')
childNamesDict['cgmType'] = namesDict.get('cgmType')
if namesDict.get('cgmDirection') != None:
childNamesDict['cgmDirection'] = namesDict.get('cgmDirection')
if namesDict.get('cgmNameModifier') != None:
childNamesDict['cgmNameModifier'] = namesDict.get(
'cgmNameModifier')
if namesDict.get('cgmDirectionModifier') != None:
childNamesDict['cgmDirectionModifier'] = namesDict.get(
'cgmDirectionModifier')
if namesDict.get('cgmTypeModifier') != None:
childNamesDict['cgmTypeModifier'] = namesDict.get(
'cgmTypeModifier')
return childNamesDict
elif isType == 'shape' or 'Constraint' in isType:
"""if so, it's a child name object"""
childNamesDict = {}
childNamesDict['cgmName'] = search.returnParentObject(obj, False)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
elif typeTag == 'infoNull':
"""if so, it's a special case"""
moduleObj = search.returnMatchedTagObjectUp(
obj, 'cgmType', 'module')
masterObj = search.returnMatchedTagObjectUp(
obj, 'cgmType', 'master')
if moduleObj != False:
moduleName = returnUniqueGeneratedName(moduleObj,
ignore='cgmType')
childNamesDict = {}
childNamesDict['cgmName'] = (moduleName + '_' + nameObj)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
elif masterObj != False:
masterName = returnUniqueGeneratedName(masterObj,
ignore='cgmType')
childNamesDict = {}
childNamesDict['cgmName'] = (masterName + '_' + nameObj)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
else:
return namesDict
else:
return namesDict
else:
return namesDict
def getFamily(self):
""" Get the parent, child and shapes of the object."""
self.parent = search.returnParentObject(self.nameLong) or False
self.children = search.returnChildrenObjects(self.nameLong) or []
self.shapes = mc.listRelatives(self.nameLong,shapes=True) or []
def returnObjectGeneratedNameDict(obj,ignore='none'):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns a generated dictionary of name info
ARGUMENTS:
obj(string) - object
ignore(string) - default is 'none', only culls out cgmtags that are
generated via returnCGMOrder() function
RETURNS:
namesDict(string)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
typesDictionary = dictionary.initializeDictionary(typesDictionaryFile)
namesDictionary = dictionary.initializeDictionary(namesDictionaryFile)
settingsDictionary = dictionary.initializeDictionary(settingsDictionaryFile)
namesDict={}
divider = returnCGMDivider()
order = returnCGMOrder()
nameBuilder = []
#>>> Get our cgmVar_iables
userAttrs = attributes.returnUserAttributes(obj)
cgmAttrs = lists.returnMatchList(userAttrs,order)
#>>> Tag ignoring
if ignore != 'none':
if ignore in order:
order.remove(ignore)
#>>> Geting our data
for tag in order:
tagInfo = search.findRawTagInfo(obj,tag)
if tagInfo is not False:
namesDict[tag] = (tagInfo)
""" remove tags up stream that we don't want if they don't exist on the actual object"""
if mc.objExists(obj+'.cgmTypeModifier') != True:
if namesDict.get('cgmTypeModifier') != None:
namesDict.pop('cgmTypeModifier')
#>>> checks if the names exist as objects or it's a shape node
ChildNameObj = False
nameObj = search.returnTagInfo(obj,'cgmName')
typeTag = search.returnTagInfo(obj,'cgmType')
isType = search.returnObjectType(obj)
childrenObjects = search.returnChildrenObjects(obj)
"""first see if it's a group """
if childrenObjects > 0 and isType == 'transform' and typeTag == False:
""" if it's a transform group """
groupNamesDict = {}
if not nameObj:
groupNamesDict['cgmName'] = childrenObjects[0]
else:
groupNamesDict['cgmName'] = nameObj
groupNamesDict['cgmType'] = typesDictionary.get('transform')
if namesDict.get('cgmDirection') != None:
groupNamesDict['cgmDirection'] = namesDict.get('cgmDirection')
if namesDict.get('cgmDirectionModifier') != None:
groupNamesDict['cgmDirectionModifier'] = namesDict.get('cgmDirectionModifier')
if namesDict.get('cgmTypeModifier') != None:
groupNamesDict['cgmTypeModifier'] = namesDict.get('cgmTypeModifier')
return groupNamesDict
""" see if there's a name tag"""
elif nameObj != None or isType == 'shape':
"""if there is, does it exist """
if mc.objExists(nameObj) == True:
"""basic child object with cgmName tag """
childNamesDict = {}
childNamesDict['cgmName'] = namesDict.get('cgmName')
childNamesDict['cgmType'] = namesDict.get('cgmType')
if namesDict.get('cgmDirection') != None:
childNamesDict['cgmDirection'] = namesDict.get('cgmDirection')
if namesDict.get('cgmNameModifier') != None:
childNamesDict['cgmNameModifier'] = namesDict.get('cgmNameModifier')
if namesDict.get('cgmDirectionModifier') != None:
childNamesDict['cgmDirectionModifier'] = namesDict.get('cgmDirectionModifier')
if namesDict.get('cgmTypeModifier') != None:
childNamesDict['cgmTypeModifier'] = namesDict.get('cgmTypeModifier')
return childNamesDict
elif isType == 'shape' or 'Constraint' in isType:
"""if so, it's a child name object"""
childNamesDict = {}
childNamesDict['cgmName'] = search.returnParentObject(obj,False)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
elif typeTag == 'infoNull':
"""if so, it's a special case"""
moduleObj = search.returnMatchedTagObjectUp(obj,'cgmType','module')
masterObj = search.returnMatchedTagObjectUp(obj,'cgmType','master')
if moduleObj != False:
moduleName = returnUniqueGeneratedName(moduleObj,ignore='cgmType')
childNamesDict = {}
childNamesDict['cgmName'] = (moduleName+'_'+nameObj)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
elif masterObj != False:
masterName = returnUniqueGeneratedName(masterObj,ignore='cgmType')
childNamesDict = {}
childNamesDict['cgmName'] = (masterName+'_'+nameObj)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
else:
return namesDict
else:
return namesDict
else:
return namesDict
def returnObjectGeneratedNameDict(obj,ignore=[False]):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns a generated dictionary of name info
ARGUMENTS:
obj(string) - object
ignore(string) - default is 'none', only culls out cgmtags that are
generated via returnCGMOrder() function
RETURNS:
namesDict(string)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
_str_funcName = "returnObjectGeneratedNameDict"
log.debug(">>> %s >>> "%(_str_funcName) + "="*75)
#_str_funcName = "returnObjectGeneratedNameDict(%s,ignore = %s)"%(obj,ignore)
if type(ignore) is not list:ignore = [ignore]
typesDictionary = dictionary.initializeDictionary(typesDictionaryFile)
namesDictionary = dictionary.initializeDictionary(namesDictionaryFile)
settingsDictionary = dictionary.initializeDictionary(settingsDictionaryFile)
namesDict={}
divider = returnCGMDivider()
order = returnCGMOrder()
nameBuilder = []
#>>> Get our cgmVar_iables
userAttrs = attributes.returnUserAttributes(obj)
cgmAttrs = lists.returnMatchList(userAttrs,order)
#>>> Tag ignoring
if ignore:
for i in ignore:
if i in order:
order.remove(i)
#>>> Geting our data
for tag in order:
tagInfo = search.findRawTagInfo(obj,tag)
if tagInfo is not False:
namesDict[tag] = (tagInfo)
_iterator = search.findRawTagInfo(obj,'cgmIterator')
if _iterator is not False:
log.debug("Iterator found")
namesDict['cgmIterator'] = (_iterator)
# remove tags up stream that we don't want if they don't exist on the actual object"""
if not mc.objExists(obj+'.cgmTypeModifier'):
if namesDict.get('cgmTypeModifier') != None:
namesDict.pop('cgmTypeModifier')
log.debug("%s >>> initial nameDict: %s "%(_str_funcName,namesDict))
#>>> checks if the names exist as objects or it's a shape node
ChildNameObj = False
nameObj = search.returnTagInfo(obj,'cgmName')
typeTag = search.returnTagInfo(obj,'cgmType')
isType = search.returnObjectType(obj)
childrenObjects = search.returnChildrenObjects(obj)
"""first see if it's a group """
if isType == 'group' and typeTag == False:
log.debug("%s >>> group and no typeTag..."%(_str_funcName))
""" if it's a transform group """
groupNamesDict = {}
if not nameObj:
groupNamesDict['cgmName'] = childrenObjects[0]
else:
groupNamesDict['cgmName'] = nameObj
groupNamesDict['cgmType'] = typesDictionary.get('transform')
if namesDict.get('cgmTypeModifier') != None:
groupNamesDict['cgmTypeModifier'] = namesDict.get('cgmTypeModifier')
return groupNamesDict
""" see if there's a name tag"""
elif nameObj != None or isType == 'shape':
#If we have a name object or shape
log.debug("%s >>> nameObj not None or isType is 'shape'..."%(_str_funcName))
if mc.objExists(nameObj) and mc.attributeQuery ('cgmName',node=obj,msg=True):
log.debug("%s >>> nameObj exists: '%s'..."%(_str_funcName,nameObj))
#Basic child object with cgmName tag
childNamesDict = {}
childNamesDict['cgmName'] = namesDict.get('cgmName')
childNamesDict['cgmType'] = namesDict.get('cgmType')
if namesDict.get('cgmTypeModifier') != None:
childNamesDict['cgmTypeModifier'] = namesDict.get('cgmTypeModifier')
if namesDict.get('cgmIterator') != None:
childNamesDict['cgmIterator'] = namesDict.get('cgmIterator')
return childNamesDict
elif isType == 'shape' or 'Constraint' in isType:
"""if so, it's a child name object"""
log.debug("%s >>> child name object..."%(_str_funcName))
childNamesDict = {}
childNamesDict['cgmName'] = search.returnParentObject(obj,False)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
elif typeTag == 'infoNull':
log.debug("%s >>> special case..."%(_str_funcName))
moduleObj = search.returnMatchedTagObjectUp(obj,'cgmType','module')
masterObj = search.returnMatchedTagObjectUp(obj,'cgmType','master')
if moduleObj != False:
moduleName = returnUniqueGeneratedName(moduleObj,ignore='cgmType')
childNamesDict = {}
childNamesDict['cgmName'] = (moduleName+'_'+nameObj)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
elif masterObj != False:
masterName = returnUniqueGeneratedName(masterObj,ignore='cgmType')
childNamesDict = {}
childNamesDict['cgmName'] = (masterName+'_'+nameObj)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
else:
return namesDict
else:
log.debug("%s >>> No special case found. %s"%(_str_funcName,namesDict))
return namesDict
else:
return namesDict
NewName(mc.ls(sl=True)[0]).getMatchedChildren()
NewName(mc.ls(sl=True)[0]).returnUniqueGeneratedName()
a = NewName(mc.ls(sl=True)[0]).returnUniqueGeneratedName()
NewName(mc.ls(sl=True)[0]).getIterator()
NewName(mc.ls(sl=True)[0]).getBaseIterator()
NewName(mc.ls(sl=True)[0]).doName()
NewName(mc.ls(sl=True)[0]).doName(fastIterate=False)
NewName(mc.ls(sl=True)[0]).doName(nameChildren=True, nameShapes=True)
NewName(mc.ls(sl=True)[0]).doName(nameChildren=True, fastIterate=False)
NewName(mc.ls(sl=True)[0]).doNameObject(fastIterate=False)
NewName(mc.ls(sl=True)[0]).doName(True)
for o in mc.ls(sl=True, sn=True):
i_o = cgmMeta.cgmNode(o)
NewName.go(i_o).doName()
search.returnParentObject(mc.ls(sl=True)[0])
i_obj = cgmMeta.cgmNode(mc.ls(sl=True)[0])
cgmMeta.NameFactory(i_obj).getBaseIterator()
NewName(i_obj).getBaseIterator()
cgmMeta.cgmNode(mc.ls(sl=True)[0]).doName()
log.info(cgmMeta.cgmNode(mc.ls(sl=True)[0]).translate)
i_obj.doName()
i_obj.mNode
i_obj.getBaseName()
i_obj.getMayaType()
cgmMeta.cgmNode(mc.ls(sl=True)[0]).getSiblings()
cgmMeta.cgmNode(mc.ls(sl=True)[0]).getLongName()
cgmMeta.cgmNode(mc.ls(sl=True)[0]).getTransform()
cgmMeta.cgmNode(mc.ls(sl=True)[0]).parent
log.info(cgmMeta.cgmNode(mc.ls(sl=True)[0]).getNameDict())
