def FTV_getFluidElements( fluid ):
	'''this function consider the type of parameter fluid to not be exactly known but output anyway the fluid Transform and the fluid Shape'''

	if fluid is None:
		raise FTV_msCommandException('Please select a Fluid')

	fldTrs = None
	fldShp = None

	if pm.nodeType(fluid)== 'transform':
		childs = pm.listRelatives(fluid, s=True)
		if len(childs)>0 and pm.nodeType(childs[0]) == 'fluidShape' :
			fldTrs = fluid
			fldShp = childs[0]
		else :
			raise FTV_msCommandException('selection is invalid, you must select a fluid')
	elif pm.nodeType(fluid)== 'fluidShape':
		par = pm.listRelatives(fluid, p=True)
		if len(par)>0 and pm.nodeType(par[0]) == 'transform' :
			fldTrs = par[0]
			fldShp = fluid
		else :
			raise FTV_msCommandException('selection is invalid, you must select a fluid')
	else :
		raise FTV_msCommandException('selection is invalid, you must select a fluid')
	return (fldTrs,fldShp)

	def createManipCtrlCenter(self):
		
		pm.select(cl = True)
		
		#createTextCurves
		nurbsText = self.prefix + '_Ctrl'
		textCurvesReturnList = pm.textCurves(f = 'arial' , t = nurbsText, ch = True )
		
		textTopGrp = textCurvesReturnList[0]
		makeTextCurvesNode = textCurvesReturnList[1]
		
		pm.select(cl = True)
		
		#get future history of makeTextCurvesNode
		textHistoryList = pm.listHistory(makeTextCurvesNode, future = True, af = True)
		
		#get list of transforms and NurbsCurve nodes connected to makeTextCurvesNode
		textTransformList = []
		textNurbsCurveList = []
		for node in textHistoryList:
			if(pm.nodeType(node) == 'transform'): textTransformList.append(node)
			if(pm.nodeType(node) == 'nurbsCurve'): textNurbsCurveList.append(node)
			
		pm.select(cl = True)
		
		#delete makeTextCurvesNode
		pm.delete(makeTextCurvesNode)
		pm.select(cl = True)
		
		#iterate through transformList, move pivot to ws (0,0,0) and freeze all
		for transformNode in textTransformList:
			pm.xform(transformNode, ws = True, piv = (0,0,0))
			pm.makeIdentity(transformNode, a = True)
			
			
		#create manipCtrlGrp
		self.manip_CtrlCenter = pm.group(n = self.prefix + '_manip_ctrl_center')
		pm.select(cl = True)
		
		#iterate through nurbsCurve list and parent shapes under manip ctrlCenter
		for nurbsCurveShape in textNurbsCurveList:
			pm.parent(nurbsCurveShape, self.manip_CtrlCenter, r = True, s = True)
			
		pm.select(cl = True)
		
		#create manip_ctrlCenter grp and translate correctly
		self.manip_CtrlCenter_grp = pm.group(n = self.prefix + '_manip_ctrl_center_grp')
		pm.select(cl = True)
		pm.parent(self.manip_CtrlCenter, self.manip_CtrlCenter_grp)
		pm.select(cl = True)
		
		self.manip_CtrlCenter_grp.translate.set(self.jointPositionList[-1][0], self.jointPositionList[-1][1] + 2, self.jointPositionList[-1][2])
		
		
		#delete remaining text transform nodes
		pm.delete(textTopGrp)
		pm.select(cl = True)

def isObjType(*args):
    tmpList = [ o.getParent() for o in sel if not(pm.nodeType(o) == 'mesh' or pm.nodeType(o) == 'nurbsSurface') ]
    
    tmpStr = ''
    for s in tmpList:
        tmpStr = tmpStr + s + ','
            
    if( len(tmpList) > 0 ):
        pm.confirmDialog(t="Error", message= tmpStr + " are not mesh or nurbsSurface", icon='critical')
        return 0
    
    return 1

def export():
    '''
    Export a nuke file out with all the selected object from maya. 
    Takes care of all exporting
    need: shape and transform
    because might need some attributes from them
    '''
    objList = []
    for node in pm.ls(sl=True):
        print '[%s]%s' % (pm.nodeType(node) , node)
        if pm.nodeType(node) == 'transform':
            obj = mObject(node)
            objList.append(obj)
    writeNukeFile(objList)

 def findCameraInSelection(self):
     selection = pm.ls(sl=True)
     assert len(selection)>0, "Nothing is selected. Select a camera"
     assert len(selection)<2, "Multiple objects selected. Select camera only"
     
     if pm.nodeType(selection[0])=='transform':
         camShapeLst = pm.listRelatives(selection[0], type='camera')
         assert len(camShapeLst)>0, "No camera selected"
         return (selection[0], camShapeLst[0])
     
     elif pm.nodeType(selection[0])=='camera':
         parentTransform = pm.listRelatives(selection[0], parent=True)
         return (parentTransform,selection[0])
     
     raise StandardError("No camera is selected")

    def check(self):
        """
        Initial checks to prevent from some problems.
        This is not a guarantee for the procedure to run smoothly,
        but a big hint that it will.
        """

        #selected_node
        selected_node = self.get_selected_node()

        #check selected node exists
        if not (selected_node):

            #log
            self.logger.debug('Selected node is None.')
            return False

        
        #check if node is transform
        if not (pm.nodeType(selected_node) == 'transform'):

            #log
            self.logger.debug('Selected node {0} is not of type transform'.format(selected_node.name()))
            return False


        #return
        return True

def addMaterialinGraph(*args):
    
    sel_shapes = pm.ls( sl=True, dag=True, type='shape' )
    
    global panel_hyperShd
    for shape in sel_shapes:
        if( not( pm.nodeType(shape) == 'mesh' or pm.nodeType(shape) == 'nurbsSurface' ) ):
            pm.confirmDialog( t="Error", message= " selected objects are not mesh or nurbsSurface", icon='critical' )
            
        shdGrp = shape.outputs(type='shadingEngine')
        for sg in shdGrp:
            shader = pm.ls( sg.inputs(), materials=1 )
            pm.select(shader)
            mel.eval( "hyperShadePanelGraphCommand( \"%s\", \"addSelected\" )"  % str(panel_hyperShd) )
            
            pm.select(shape.getParent())

def create_ui(* args):
    '''
    # this creates the ui for the selected  light from the scrollField
    '''
    # dictionary for class
    # the script get the light type each type is a key
    # and based on that it will pick which class to instance
    
    light_classes = {'spotLight': lights.Light_spot,
            'directionalLight': lights.Light_directional,
              'ambientLight': lights.Light_ambient,
              'areaLight': lights.Light_area,
              'pointLight': lights.Light_point,
              'volumeLight': lights.Light_volume}
    
    selected = scroll_list.getSelectItem()
    global lights_dict
    global obj_ui_list
    # deleteting existing ui objects
    for obj in obj_ui_list:
        try:
            obj.delete()
            
        except:
            pass
    
    
    for sel in selected:
        pm.setParent(ui_row)
       # getting the node type
        obj_type = pm.nodeType('%s' % (lights_dict[u'%s' %(str(sel))]))
        # using the  ^^ dictionarry to instance the appropritate class
        light  = light_classes[obj_type](light= '%s' % (sel)).create()
        # appending that object to the global objects list
        obj_ui_list.append(light)

 def create_preset(self):
     '''
     # creates the file for the preset
     ******
     # file pattern
     # data = ['preset name', 'light type', 'description',
                         xform_attrs[], shape_attrs[]] 
     ******
     '''
     sel = pm.ls(selection= True)[0]
     sel_shape = sel.getShape()
     node_type = pm.nodeType(sel_shape)
     
     if 'Light' not in node_type:
         return
     
     data = []
     
     data.append('%s' % (self.field.getText()))
     
     data.append('%s' % (node_type))
     
     data.append('%s' % (self.scroll.getText()))
     
     sel_data = []
     
     sel_shape_data = []
     
     sel_attrs = pm.listAttr(sel)
     sel_shape_attrs = pm.listAttr(sel_shape)
     
     for attr in sel_attrs:
         try :
             value = pm.getAttr('%s.%s' % (sel, attr))
             temp_data = (attr , value)
             sel_data.append(temp_data)
         
         except:
             pass
         
     for attr in sel_shape_attrs:
         try:
             value = pm.getAttr('%s.%s' % (sel_shape, attr))
             temp_data = (attr , value)
             sel_shape_data.append(temp_data)
         
         except:
             pass
         
         
     data.append(sel_data)
     data.append(sel_shape_data)
     
     name ='%s.light'  % (self.field.getText())
     full_path = os.path.join(self.path, name)
     f = open(full_path, 'w')
     pickle_data = pickle.dump(data, f)
     f.close()
     
     preset_ui() # this will list will update the preset section

 def __init__(self, node, **kwargs):
     self.setup(kwargs)
     self.transform = node
     self.shape = self.transform.getShape()
     self.type = pm.nodeType(self.shape)
     
     self.setAttributes()

def printSelection(longNames=True):
    """Print the selection in an organized, numbered list"""
    selList = pm.selected()
    print '\n//{0} Nodes Selected'.format(len(selList))
    nameMethod = None
    if longNames:
        nameMethod = 'longName'
    else:
        nameMethod = 'name'
    
    maxLen = 0
    for obj in selList:
        if hasattr(obj, nameMethod):
            name = getattr(obj, nameMethod)()
        else:
            name = obj.name()
        if len(name) > maxLen:
            maxLen = len(name)
    
    for i in range(len(selList)):
        obj = selList[i]
        typ = pm.nodeType(obj)
        if hasattr(obj, nameMethod):
            name = getattr(obj, nameMethod)()
        else:
            name = obj.name()
        print '{index:03}. {name:<{maxLen}} - {type}'.format(index=i, name=name, type=typ, maxLen=maxLen)

def getAnimCurve(node):
    '''
    If node or nodes parent is a transform node.
        returns a AnimCurve node.
    '''
    
    type = pm.nodeType(node)
    if type == 'transform':
        return getAnimCurveFromTransform(node)
    else:
        parent = node.getParent()
        if pm.nodeType(parent) == 'transform':
            return getAnimCurveFromTransform(parent)
        else:
            print node, 'is none of the requered nodeTypes...'
            return None

def FindDeformers ( shape=None , type=''):
	
	if shape==None:
		obj = pm.ls(sl=True)[0]
		shape = obj.getShape()
	
	if shape :
		# List Deformers
		history = pm.listHistory( shape, pruneDagObjects=True, interestLevel=2 ) 
		
		deformers = []
		
		for node in  history :
			nodeTypes = pm.nodeType( node, inherited=True )
		
			if 'geometryFilter' in nodeTypes:
				
				if type=='' and  nodeTypes[1] != 'tweak' :
					deformers.append(node)
			
				elif nodeTypes[1] == type and nodeTypes[1] != 'tweak':
					deformers.append(node)
		
		return deformers
	else:
		pm.warning('No shape found.')

def get_camera_details_list():
	"""Parse the scene for camera nodes and return list with information"""

	#log_progress
	log_progress = False

	#scene_cameras_list
	scene_cameras_list = pm.ls(ca = True)
	#empty
	if not(scene_cameras_list):
		print('No camera nodes in the scene.')
		return []

	#camera_details_list
	camera_details_list = []

	#iterate and add details
	for camera_node in scene_cameras_list:

		#camera_details_dict
		camera_details_dict = {}

		#camera_shape_name
		camera_details_dict['camera_shape_name'] = camera_node.name()
		#camera_transform_name
		camera_details_dict['camera_transform_name'] = camera_node.getParent().name()
		#camera_type
		camera_details_dict['camera_type'] = pm.nodeType(camera_node)

		
		#inclusive_matrix
		inclusive_matrix = get_inclusive_matrix(camera_node.name())
		#list_matrix
		list_matrix = mmatrix_to_list(inclusive_matrix)
		#add to dict
		camera_details_dict['matrix'] = list_matrix




		#iterate LIGHT_PARAMETERS_LIST and add values if existing
		CAMERA_PARAMETERS_LIST = VRAY_CAMERA_PARAMETERS_LIST + MAYA_CAMERA_PARAMETERS_LIST
		for attr in CAMERA_PARAMETERS_LIST:
			if(camera_node.hasAttr(attr)):
				#attr_value
				attr_value = pm.getAttr(camera_node.name() +'.' +attr)
				#append to dict
				camera_details_dict[attr] = attr_value

		

		#append dict to list
		camera_details_list.append(camera_details_dict)


	return camera_details_list

def get_light_details_list():
	"""Parse the scene for light nodes and return list with information"""

	#log_progress
	log_progress = False

	#scene_lights_list
	scene_lights_list = get_all_scene_lights()
	#empty
	if not(scene_lights_list):
		print('No light nodes in the scene.')
		return []

	#scene_light_details_list
	scene_light_details_list = []

	#iterate and add details
	for light_node in scene_lights_list:

		#light_details_dict
		light_details_dict = {}

		#light_shape_name
		light_details_dict['light_shape_name'] = light_node.name()
		#light_transform_name
		light_details_dict['light_transform_name'] = light_node.getParent().name()
		#light_type
		light_details_dict['light_type'] = pm.nodeType(light_node)

		
		#inclusive_matrix
		inclusive_matrix = get_inclusive_matrix(light_node.name())
		#list_matrix
		list_matrix = mmatrix_to_list(inclusive_matrix)
		#add to dict
		light_details_dict['matrix'] = list_matrix




		#iterate LIGHT_PARAMETERS_LIST and add values if existing
		LIGHT_PARAMETERS_LIST = VRAY_LIGHT_PARAMETERS_LIST + MAYA_LIGHT_PARAMETERS_LIST
		for attr in LIGHT_PARAMETERS_LIST:
			if(light_node.hasAttr(attr)):
				#attr_value
				attr_value = pm.getAttr(light_node.name() +'.' +attr)
				#append to dict
				light_details_dict[attr] = attr_value

		

		#append dict to list
		scene_light_details_list.append(light_details_dict)


	return scene_light_details_list

 def filterForTextures(cls, textureList, *args, **kwargs):
   ''' filter a list for only file texture nodes '''
   newList = []
   if textureList:
     #
     for item in textureList:
       type = pm.nodeType(item)
       if type == 'file':
         newList.append(item)
   return newList

def getNodeType(name):
    nodeType = pm.nodeType(name)
    lights = ["directionalLight",
                "pointLight",
                "spotLight",
                "areaLight"]

    if nodeType in lights:
        nodeType = 'light'

    return nodeType

	def startupCheck(self):
		'''Perform check to see if all requirements to run the script are fullfilled'''
		
		
		#Check namespaces attrs.
		if not(self.namespaceShader):
			if(self.verbose):print('Empty namespaces for shader. Please provide correct parameter.')
			return False
			
		#Check namespaces attrs.
		if not(self.namespaceChrystal):
			if(self.verbose):print('Empty namespaces for chrystal. Please provide correct parameter.')
			return False
		
		
		
		
		#check selection
		selectionList = pm.ls(sl = True, fl  = True)
		
		#check selectionList 
		if not(selectionList):
			if(self.verbose):print('Nothing selected.')
			return False
			
		#check selectionList == 1
		if not(len(selectionList) == 1):
			if(self.verbose):print('SelectionList has wrong length, please only select Chrystal_top_grp')
			return False
			
		
		#check shadernames in scene
		for shaderName in self.shaderNamesList:
			#if shdername in scene
			if not(self.namespaceShader +':' +shaderName in pm.ls(fl = True, mat = True)):
				if(self.verbose):print(self.namespaceShader +':' +shaderName +' not in scene')
				return False
				
		
		#check if chrystalTopGrp is type transform
		if not(pm.nodeType(selectionList[0]) == 'transform'):
			if(self.verbose):print('Selected chrystal top grp is not of type transform')
			return False
			
		#Check subGroupNames
		for chrystalSubgroupName in self.chrystalSubgroupNamesList:
			if not(chrystalSubgroupName in [x.name().split('|')[-1] for x in selectionList[0].getChildren()]):
				if(self.verbose):print(chrystalSubgroupName +' not in selectionList')
				return False
		
		
		#If successful return True
		return True

def listWorldChildren ():
    '''
    Return the transform node at the root of the hierarchy.
    
    Return :
    worldChildrenList = List
    '''
    worldChildrenList = list()
    for elem in pm.ls(assemblies=True) :
        if pm.nodeType(elem) == 'transform' :
            worldChildrenList.append(elem)
    return worldChildrenList

	def getAnimCurveNodeList(self, object):
		
		pm.select(cl = True)
		
		#get all connections to object
		connectionsList = pm.listConnections(object)
		
		#Check if connectionsList is empty
		if not(connectionsList):
			if(self.verbose): print('Object hast no input coonections')
			return connectionsList
			
		#get animCurveList
		animCurveList = []
		
		#iterate through connectionList and append animcurve nodes
		for node in connectionsList:
			if(pm.nodeType(node) == 'animCurveTU' or pm.nodeType(node) == 'animCurveTL' or pm.nodeType(node) == 'animCurveTA'): animCurveList.append(node)
			
			
		return animCurveList