def attachToSurfaceFromUI(close=True):
    """
    Execute attachToSurface() from UI
    @param close:
    """
    # Window
    window = 'attachToSurfaceUI'
    if not cmds.window(window, q=True, ex=1): raise UIError('AttachToSurface UI does not exist!!')
    # Get UI data
    surf = cmds.textFieldGrp('attachToSurfaceTFB', q=True, text=True)
    # Check surface
    if not glTools.utils.surface.isSurface(surf):
        raise UserInputError('Object "' + surf + '" is not a valid nurbs surface!!')
    trans = cmds.textFieldGrp('attachToSurfaceTransformTFB', q=True, text=True)
    pre = cmds.textFieldGrp('attachToSurfacePrefixTFG', q=True, text=True)
    uParam = cmds.floatFieldGrp('attachToSurfaceParamTFB', q=True, v1=True)
    vParam = cmds.floatFieldGrp('attachToSurfaceParamTFB', q=True, v2=True)
    closePnt = cmds.checkBoxGrp('attachToSurfaceClosePntCBG', q=True, v1=True)
    uAttr = cmds.textFieldGrp('attachToSurfaceUAttrTFG', q=True, text=True)
    vAttr = cmds.textFieldGrp('attachToSurfaceVAttrTFG', q=True, text=True)
    # Orient
    orient = cmds.checkBoxGrp('attachToSurfaceOrientCBG', q=True, v1=True)
    # Orient Options
    tanU = str.lower(str(cmds.optionMenuGrp('attachToSurfaceUAxisOMG', q=True, v=True)))
    tanV = str.lower(str(cmds.optionMenuGrp('attachToSurfaceVAxisOMG', q=True, v=True)))
    align = str.lower(str(cmds.optionMenuGrp('attachToSurfaceAlignToOMG', q=True, v=True)))

    # Execute command
    result = glTools.utils.attach.attachToSurface(surface=surf, transform=trans, uValue=uParam, vValue=vParam,
                                                  useClosestPoint=closePnt, orient=orient, uAxis=tanU, vAxis=tanV,
                                                  uAttr=uAttr, vAttr=vAttr, alignTo=align, prefix=pre)

    # Cleanup
    if close: cmds.deleteUI(window)

def doOptions(input_referenceObject, input_rotateOrder, input_axis, input_referenceAxis, input_normalizeAxes):
	"""This is the function called when the apply or create button is clicked"""
	try:
		# validate selection
		utils.dg.validateSelection(type='transform', exact=1)
		
		# validate reference object
		referenceObject = cmds.textFieldGrp(input_referenceObject, q=True, tx=True)
		if len(referenceObject) > 0: utils.dg.verifyNode(referenceObject)
		
		# call the command
		if len(referenceObject) > 0:
			cmds.am_exposeTransform(
				ref=referenceObject, 
				ro=utils.kRotateOrderMapping[cmds.optionMenuGrp(input_rotateOrder, q=True, v=True)], 
				a=cmds.floatFieldGrp(input_axis, q=True, v=True), 
				ra=cmds.floatFieldGrp(input_referenceAxis, q=True, v=True), 
				na=cmds.checkBoxGrp(input_normalizeAxes, q=True, v1=True))
		else:
			cmds.am_exposeTransform(
				ro=utils.kRotateOrderMapping[cmds.optionMenuGrp(input_rotateOrder, q=True, v=True)], 
				a=cmds.floatFieldGrp(input_axis, q=True, v=True), 
				ra=cmds.floatFieldGrp(input_referenceAxis, q=True, v=True), 
				na=cmds.checkBoxGrp(input_normalizeAxes, q=True, v1=True))
	except: raise

def attachToCurveFromUI(close=False):
    """
    Execute attachToCurve() from UI
    """
    # Window
    window = 'attachToCurveUI'
    if not cmds.window(window, q=True, ex=1): raise UIError('AttachToCurve UI does not exist!!')
    # Get UI data
    curve = cmds.textFieldGrp('attachToCurveTFB', q=True, text=True)
    transform = cmds.textFieldGrp('attachToCurveTransformTFB', q=True, text=True)
    prefix = cmds.textFieldGrp('attachToCurvePrefixTFG', q=True, text=True)
    closestPoint = cmds.checkBoxGrp('attachToCurveClosestPointCBG', q=True, v1=True)
    param = cmds.floatSliderGrp('attachToCurveParamFSG', q=True, v=True)
    paramAttr = cmds.textFieldGrp('attachToCurveParamAttrTFG', q=True, text=True)
    orient = cmds.checkBoxGrp('attachToCurveOrientCBG', q=True, v1=True)
    upVec = (cmds.floatFieldGrp('attachToCurveUpVecFFG', q=True, v1=True),
             cmds.floatFieldGrp('attachToCurveUpVecFFG', q=True, v2=True),
             cmds.floatFieldGrp('attachToCurveUpVecFFG', q=True, v3=True))
    upVecObj = cmds.textFieldButtonGrp('attachToCurveUpVecObjTFG', q=True, text=True)
    # Check curve
    if not glTools.utils.curve.isCurve(curve):
        raise UserInputError('Object "' + curve + '" is not a valid nurbs curve!!')
    glTools.utils.attach.attachToCurve(curve=curve, transform=transform, uValue=param, useClosestPoint=closestPoint,
                                       orient=orient, upVector=upVec, worldUpObject=upVecObj, uAttr=paramAttr,
                                       prefix=prefix)
    # Cleanup
    if close: cmds.deleteUI(window)

def get_ui_values():
    global engine_path, folder, file_name, export_batch, resolution_x, resolution_y, exposure, gamma, \
        ray_number, time, seed, export_animation, start_frame, end_frame, export_normals, invert_normals, check_Z, materials
        
    engine_path = cmds.textFieldButtonGrp(engine_field, query=True, text=True)
    folder = cmds.textFieldButtonGrp(directory_field, query=True, text=True)
    file_name = cmds.textFieldGrp(file_field, query=True, text=True)
    
    export_batch = cmds.checkBoxGrp(batch_field, query=True, value1=True)
    
    resolution_x = cmds.intFieldGrp(resolution_field, query=True, value1=True)
    resolution_y = cmds.intFieldGrp(resolution_field, query=True, value2=True)
    exposure = cmds.floatSliderGrp(exposure_field, query=True, value=True)
    gamma = cmds.floatSliderGrp(gamma_field, query=True, value = True)
    ray_number = cmds.intSliderGrp(rays_field, query=True, value=True)
    seed = cmds.intSliderGrp(seed_field, query=True, value=True)
    time = cmds.intSliderGrp(time_field, query=True, value=True)
    export_animation = cmds.checkBoxGrp(animation_field, query=True, value1=True)
    start_frame =  cmds.intFieldGrp(frame_range_field, query=True, value1=True)
    end_frame =  cmds.intFieldGrp(frame_range_field, query=True, value2=True)
    export_normals = cmds.checkBoxGrp(normals_export_field, query=True, value1=True)
    invert_normals = cmds.checkBoxGrp(normals_invert_field, query=True, value1=True)
    check_Z = cmds.checkBoxGrp(check_Z_field, query = True, value1=True)
    
    materials = []
    for mat in range(5):
        materials.append(cmds.floatFieldGrp(eval('material_%i_field' % (mat)), query=True, value=True))

def defaultButtonPush(args):
    '''
    Calls the procedure cityGenerator.city(...) with the user specified 
    arguments.
    
    args: Dummy argument needed to satisfy the command interface.
    On exit: The cityGenerator.city(...) procedure has been called with
             the arguments specified by the user. 
    '''
    Name_ = cmds.textField("cityName", query = True, text = True)
    if Name_ == "":
        Name_ = "Helsinki"
    cityWidth = cmds.intSliderGrp("cityWidth", query = True, value = True)
    cityDepth = cmds.intSliderGrp("cityDepth", query = True, value = True)
    minHeight = cmds.intSliderGrp("minHeight", query = True, value = True)
    maxHeight = cmds.intSliderGrp("maxHeight", query = True, value = True)
    minWidth = cmds.intSliderGrp("minWidth", query = True, value = True)
    maxWidth = cmds.intSliderGrp("maxWidth", query = True, value = True)
    windows = cmds.checkBoxGrp("features", query = True, v1 = True)
    booleans = cmds.checkBoxGrp("features", query = True, v2 = True)
    deformers = cmds.checkBoxGrp("features", query = True, v3 = True)
    dayTime = cmds.checkBoxGrp("time", query = True, v1=True)
    glow = cmds.checkBoxGrp("time", query = True, v3=True)
    environment = cmds.colorSliderGrp("environment", query = True, rgbValue = True)
    colourRangeStart = (cmds.intSliderGrp("hue1", query = True, value = True),
    cmds.floatSliderGrp("saturation1", query = True, value = True), 
    cmds.floatSliderGrp("value1", query = True, value = True))
    colourRangeEnd = (cmds.intSliderGrp("hue2", query = True, value = True),
    cmds.floatSliderGrp("saturation2", query = True, value = True), 
    cmds.floatSliderGrp("value2", query = True, value = True))
    cityGenerator.city(Name_, (cityWidth,cityDepth),(minHeight,maxHeight),
    (minWidth,maxWidth), windows, booleans, deformers, dayTime, glow, environment,(colourRangeStart,colourRangeEnd))    

	def init(self):
		window = c.window(title='WeatherViz',widthHeight=(400,600));
		#form = c.formLayout(numberOfDivisions=100);
		c.rowColumnLayout(numberOfColumns=1);
		c.checkBoxGrp('weatherPanel', label='Weather');
		c.checkBox('snowCheck', label='Snow', onc=self.snow.init, ofc=self.snow.remove, p='weatherPanel');
		c.checkBox('rainCheck', label='Rain', onc=self.rain.init, ofc=self.rain.remove, p='weatherPanel');
		c.checkBox('windCheck', label='Wind', onc=self.wind.init, ofc=self.wind.remove, p='weatherPanel');
		c.button('collButton', label='Add collision', c=self.addCollision);


		#s1 = c.floatSliderGrp('snowTurb',label='Snow turbulence', field=True, value=5, dc=self.slider_drag_callback, min=0, max=10);
		c.floatSliderGrp('snowIntens',label='Snow Intencity', field=True, value=200, dc=self.slider_drag_callback, min=0, max=1000, en=False);
		c.floatSliderGrp('rainIntens',label='Rain Intencity', field=True, value=200, dc=self.slider_drag_callback, min=0, max=1000, en=False);
		c.floatSliderGrp('snowTurbSlider',label='Turbulence', field=True, value=1, dc=self.slider_drag_callback, min=0, max=100, en=False);
		c.floatSliderGrp('airMSlider',label='Wind Magnitude', field=True, value=30, dc=self.slider_drag_callback, min=0, max=100, en=False);
		c.floatSliderGrp('airMxdSlider',label='Wind Distance', field=True, value=20, dc=self.slider_drag_callback, min=0, max=100, en=False);
		#c.formLayout(form, edit=True, attachPosition=[(s1, 'top', 20, 1)]);
		#c.formLayout(form, edit=True, attachPosition=[(s2, 'top', 20, 1)]);
		
		c.textField("WeatherViz_HDR_Path_textField", cc=_WeatherViz_HDR_Path_textField__changeCommand)
		c.button("WeatherViz_HDR_Path_button", label="...", al="center", command=_WeatherViz_HDR_Path_button__command)
		
		WeatherViz_HDR_Path = c.optionVar(q="WeatherViz_HDR_Path")
		if WeatherViz_HDR_Path:
			c.textField("WeatherViz_HDR_Path_textField", edit=True, text=WeatherViz_HDR_Path)
			
		c.showWindow(window);
		c.windowPref(enableAll=True)

def pupMaya2mental(mentalVersion):
        destPath = os.getenv('DEST_PATH_WIN')
        rootPath, shadersPath = {	
                3.8:('c:/Program Files/Autodesk/mrstand3.8.1-adsk2011/bin', destPath + '/mental3.8.1'),
                3.11:('c:/Program Files/Autodesk/mrstand3.11.1-adsk2014/bin', destPath + '/mental3.11.1')
                }[mentalVersion]

        os.putenv('RAY_COMMAND', '"' + rootPath + '/ray.exe"')

        os.putenv('MR_VERSION', str( mentalVersion ) )

        miModulesPaths, binModulesPaths = modulesPath.getMiBinString()
        #os.putenv('MI_RAY_INCPATH', shadersPath + '/mi;' +  miModulesPaths)
        #os.putenv('MI_LIBRARY_PATH', shadersPath + '/bin;' +  binModulesPaths)
        #os.putenv('MI_ROOT', rootPath)
        mel.eval('pup_maya_2_mental(3);')

        mc.checkBoxGrp('pup_m2mrOverrideEnv', e=True, v1=1)
        mc.textFieldGrp('pup_m2mrMiRoot', e=True, tx= rootPath )
        mc.textFieldGrp('pup_m2mrMiInclude', e=True, tx= shadersPath + '/mi;' +  miModulesPaths )
        mc.textFieldGrp('pup_m2mrMiLib', e=True, tx= shadersPath + '/bin;' +  binModulesPaths )
        mc.textFieldGrp('pup_m2mrMiDir', e=True, tx= "C:/Temp/" )
        mc.optionMenuGrp('pup_m2mrVerboseM', e=True, sl=5)
        #mc.textFieldGrp('pup_m2mrCommandLine', e=True, tx= '-finalgather_passes 0 -memory 1000000' )
        mc.textFieldGrp('pup_m2mrCommandLine', e=True, tx= '-memory 1000000' )
        mc.checkBoxGrp('pup_m2mrUniqueMI', e=True, v1=1)
        mc.optionMenuGrp('pup_m2mrPriority', e=True, sl=3)

def edgeLoopCurveUI():
	'''
	UI for edgeLoopCurve()
	'''
	# Window
	window = 'edgeLoopCurveUI'
	if mc.window(window,q=True,ex=1): mc.deleteUI(window)
	window = mc.window(window,t='Edge Loop Curve')
	
	# Layout
	CL = mc.columnLayout()
	# Prefix
	prefixTFG = mc.textFieldGrp('edgeLoopCurvePrefixTFG',label='Prefix',text='')
	# Rebuild
	rebuildCBG = mc.checkBoxGrp('edgeLoopCurveRebuildCBG',numberOfCheckBoxes=1,label='Rebuild Curve',v1=True)
	# Span Count
	spanISG = mc.intSliderGrp('edgeLoopCurveSpanISG',field=True,label='Rebuild Spans',minValue=0,maxValue=10,fieldMinValue=0,fieldMaxValue=100,value=0,en=1)
	
	# Toggle UI element
	mc.checkBoxGrp('edgeLoopCurveRebuildCBG',e=True,cc='mc.intSliderGrp("edgeLoopCurveSpanISG",e=1,en=(not mc.intSliderGrp("edgeLoopCurveSpanISG",q=1,en=1)))')
	
	# Buttons
	createB = mc.button('edgeLoopCurveCreateB',l='Create',c='glTools.ui.curve.edgeLoopCurveFromUI(False)')
	createCloseB = mc.button('edgeLoopCurveCreateCloseB',l='Create and Close',c='glTools.ui.curve.edgeLoopCurveFromUI(True)')
	cancelB = mc.button('edgeLoopCurveCancelB',l='Cancel',c='mc.deleteUI("'+window+'")')
	
	# Show Window
	mc.showWindow(window)

def ui():
    """
    user interface for ml_copyAnim
    """

    with utl.MlUi(
        "ml_copyAnim",
        "Copy Animation",
        width=400,
        height=120,
        info="""Copy animation across single nodes, or hierarchies based on name.
Highlight the timeline to copy just that part of the animation.""",
    ) as win:

        mc.checkBoxGrp(
            "ml_copyAnim_layer_checkBox",
            label="Copy To New Layer",
            annotation="Create a new animation layer to copy the curves into, preserving the original animation.",
        )
        win.ButtonWithPopup(
            label="Copy Single",
            command=copySingle,
            annotation="Copy animation from one object to another.",
            shelfLabel="cpAn",
            shelfIcon="defaultTwoStackedLayout",
            readUI_toArgs={"addToLayer": "ml_copyAnim_layer_checkBox"},
        )
        win.ButtonWithPopup(
            label="Copy Hierarchy",
            command=copyHierarchy,
            annotation="Uses name matching to copy animation across hierarchies.",
            shelfLabel="cpAn",
            shelfIcon="defaultTwoStackedLayout",
            readUI_toArgs={"addToLayer": "ml_copyAnim_layer_checkBox"},
        )

    def switchFromUI(self, ctrl):
        """
        Switch a spaces nodes to the specified target from the spaces UI
        @param ctrl: Control whose spaces target will be switched
        @type ctrl: str
        """
        # Determine spaces node
        spacesNode = self.getSpacesNode(ctrl)
        tag = cmds.getAttr(spacesNode + '.nameTag')

        # Query Target
        # !!! optionMenu command no longer allows access to attrEnumOptionMenu !!!
        # target = cmds.optionMenu(tag+'_switchAEO',q=True,v=True)
        targetIndex = cmds.getAttr(cmds.attrEnumOptionMenu(tag + '_switchAEO', q=True, dtg=True))
        target = self.targetList(spacesNode)[targetIndex]

        # Check keyframe options
        key = cmds.checkBoxGrp(self.uiKeyCBG, q=True, v1=True)
        keyPrevious = cmds.checkBoxGrp(self.uiKeyPreviousCBG, q=True, v1=True)

        # Check offset options
        maintainPos = cmds.checkBoxGrp(self.uiMaintainPosCBG, q=True, v1=True)

        # Do switch
        self.switch(ctrl, target, key, keyPrevious, maintainPos)

def boolAttribute(mainSetting, setting):
    cmds.checkBoxGrp(str(setting.keys()[0])+'_attribute',
                        numberOfCheckBoxes=1,
                        label=str(setting.keys()[0]).replace('_', ' '),
                        v1=setting.values()[0],
                        cc="import dmptools.setup.settingsWindow as settingsWindow;settingsWindow.updateBoolAttribute('"+mainSetting+"')"
                        )

def particleLocatorsUI():
    """
    """
    # Get current frame range
    start = cmds.playbackOptions(q=True, min=True)
    end = cmds.playbackOptions(q=True, max=True)

    # Define window
    particleLocatorsUI = 'particleLocatorsWindow'
    if cmds.window(particleLocatorsUI, q=True, ex=True): cmds.deleteUI(particleLocatorsUI)
    particleLocatorsUI = cmds.window(particleLocatorsUI, t='Generate Locators')

    # UI Layout
    cmds.columnLayout(adj=False, cal='left')
    partiTFG = cmds.textFieldGrp('partiLoc_particleTFG', label='Particle', text='', cw=[(1, 120)])
    prefixTFG = cmds.textFieldGrp('partiLoc_prefixTFG', label='Prefix', text='', cw=[(1, 120)])
    bakeAnicmdsBG = cmds.checkBoxGrp('partiLoc_bakeAnicmdsBG', label='Bake Animation', ncb=1, v1=0, cw=[(1, 120)])
    startEndIFG = cmds.intFieldGrp('partiLoc_startEndISG', nf=2, label='Frame Range', v1=start, v2=end, cw=[(1, 120)])

    rotateLocCBG = cmds.checkBoxGrp('partiLoc_rotateCBG', label='Rotate (rotatePP)', ncb=1, v1=0, cw=[(1, 120)])
    scaleLocCBG = cmds.checkBoxGrp('partiLoc_scaleCBG', label='Scale (scalePP)', ncb=1, v1=0, cw=[(1, 120)])

    cmds.button(l='Create Locators', c='glTools.tools.generateParticles.particleLocatorsFromUI()')

    # Popup menu
    cmds.popupMenu(parent=partiTFG)
    for p in cmds.ls(type=['particle', 'nParticle']):
        cmds.menuItem(p, c='cmds.textFieldGrp("' + partiTFG + '",e=True,text="' + p + '")')

    # Show Window
    cmds.showWindow(particleLocatorsUI)

def locatorParticlesUI():
    """
    """
    # Define window
    locParticleUI = 'locatorParticleWindow'
    if cmds.window(locParticleUI, q=True, ex=True): cmds.deleteUI(locParticleUI)
    locParticleUI = cmds.window(locParticleUI, t='Generate Particles')

    # UI Layout
    cmds.columnLayout(adj=False, cal='left')
    partiTFG = cmds.textFieldGrp('locParticle_particleTFG', label='Particle', text='', cw=[(1, 100)])
    radiusFFG = cmds.floatSliderGrp('locParticle_radiusFSG', label='radius', f=True, min=0.1, max=10.0, fmn=0.01,
                                  fmx=100.0, pre=2, v=1.0, cw=[(1, 100)])
    rotateLocCBG = cmds.checkBoxGrp('locParticle_rotateCBG', label='Add rotatePP', ncb=1, v1=0, cw=[(1, 100)])
    scaleLocCBG = cmds.checkBoxGrp('locParticle_scaleCBG', label='Add scalePP', ncb=1, v1=0, cw=[(1, 100)])
    selfCollideCBG = cmds.checkBoxGrp('locParticle_selfCollideCBG', label='self collide', ncb=1, v1=0, cw=[(1, 100)])

    cmds.button(l='Create Particles', c='glTools.tools.generateParticles.locatorParticlesFromUI()')

    # Popup menu
    cmds.popupMenu(parent=partiTFG)
    for p in cmds.ls(type=['particle', 'nParticle']):
        cmds.menuItem(p, c='cmds.textFieldGrp("' + partiTFG + '",e=True,text="' + p + '")')

    # Show Window
    cmds.showWindow(locParticleUI)

def evenEdgeSpacingUI():
    """
    Even Edge Spacing UI
    """
    # Window
    window = 'evenEdgeSpacingUI'
    if cmds.window(window, q=True, ex=1): cmds.deleteUI(window)
    window = cmds.window(window, t='Even Edge Spacing', s=True)

    # Layout
    CL = cmds.columnLayout()

    # UI Elements
    cmds.intSliderGrp('evenEdgeSpacing_smoothISG', label='Smooth', field=True, minValue=0, maxValue=20, fieldMinValue=0,
                    fieldMaxValue=100, value=4)
    cmds.floatSliderGrp('evenEdgeSpacing_influenceFSG', label='Influence', field=True, minValue=0.0, maxValue=1.0,
                      fieldMinValue=0.0, fieldMaxValue=1.0, value=1.0)
    cmds.checkBoxGrp('evenEdgeSpacing_snapToOrigCBG', label='Maintain Shape', numberOfCheckBoxes=1,
                   v1=False)  # columnWidth2=[100,165]
    cmds.checkBoxGrp('evenEdgeSpacing_deleteHistoryCBG', label='Delete History', numberOfCheckBoxes=1, v1=False)
    cmds.button('evenEdgeSpacingB', l='Even Edge Spacing', w=390,
              c='glTools.model.straightenVerts.evenEdgeSpacingFromUI()')

    # Show Window
    cmds.window(window, e=True, wh=[392, 99])
    cmds.showWindow(window)

 def cmdCreate(self, *args ):
     
     axisIndex = cmds.optionMenuGrp( self.optionMenu, q=1, sl=1 )-1
     inverseAim = cmds.checkBoxGrp( self.checkInverseAim, q=1, value1=1 )
     displayAxis = cmds.checkBoxGrp( self.checkDisplayAxis, q=1, value1=1 )
     #worldPosition = cmds.checkBoxGrp( self.checkWorldPosition, q=1, value1=1 )
     cmdModel.uiCmd_createAimObject(axisIndex, inverseAim, displayAxis, True )

	def enable_distributed(self, arg) :
		"""enable_distributed

		:param arg: Missing documentation about arg argument
		:return:
		"""
		ar_distr_frame = self.winMain + '|f0|t0|tc2|fr2'
		ar_distr = ar_distr_frame + '|fc2|'
		setDefaultIntValue(
			self_prefix,
			'ar_distributed',
			self.ar_param,
			arg
		)
		cmds.checkBoxGrp(
			ar_distr + 'ar_nomaster',
			edit=True,
			enable=arg
		)

		# cmds.intFieldGrp(
		#     ar_distr + 'ar_port',
		#     edit=True,
		#     enable=arg
		# )

		cmds.intFieldGrp(
			ar_distr + 'ar_hosts_min',
			edit=True,
			enable=arg
		)

		cmds.intFieldGrp(
			ar_distr + 'ar_hosts_max',
			edit=True,
			enable=arg
		)

		# cmds.intFieldGrp(
		#     ar_distr + 'ar_threads_limit',
		#     edit=True,
		#     enable=arg
		# )

		cmds.textFieldGrp(
			ar_distr + 'ar_hosts',
			edit=True,
			enable=arg
		)

		bg_color = self.save_frame_bgc
		if arg:
			bg_color = self.def_frame_bgc

		cmds.frameLayout(
			ar_distr_frame,
			edit=True,
			bgc=bg_color
		)  # , enableBackground=False

    def dimScaleFields( self):
        status = 1 - mc.checkBoxGrp( self.uniformScale, q=1, v1=1)
        mc.floatFieldGrp( self.sScale, e=1, en=status)

        status = 1 - mc.checkBoxGrp( self.cmpAlongNormal, q=1, v1=1)
        mc.floatFieldGrp( self.tCmpScale, e=1, en=status)

        status = mc.checkBoxGrp( self.cmpUseDnoise, q=1, v1=1)
        mc.floatFieldGrp( self.cmpDnoiseScale, e=1, en=status)

def uiSetCheckBox(*args):

    if mc.checkBoxGrp('ml_goToKeyframe_selected_checkBox', query=True, value1=True):
        mc.checkBoxGrp('ml_goToKeyframe_selectKeys_checkBox', edit=True, value1=False, enable=False)
    elif mc.checkBoxGrp('ml_goToKeyframe_selectKeys_checkBox', query=True, value1=True):
        mc.checkBoxGrp('ml_goToKeyframe_selected_checkBox', edit=True, value1=False, enable=False)
    else:
        mc.checkBoxGrp('ml_goToKeyframe_selectKeys_checkBox', edit=True, enable=True)
        mc.checkBoxGrp('ml_goToKeyframe_selected_checkBox', edit=True, enable=True)

def enableChannel(source, target, *args):
	"""This function enables or disables the indiv channel checkboxes when attr is toggled"""

	CBG = widgets[target]
	on = cmds.checkBox(widgets[source], q=True, v=True)
	if on:
		cmds.checkBoxGrp(CBG, e=True, en=True, va3=(1,1,1))
	else:
		cmds.checkBoxGrp(CBG, e=True, en=False, va3=(0,0,0))

 def flags(self,value):#Attribute Render Flag Assigner
     if value=='Apply':
         for sel in mc.ls(sl=1,dag=1):
             objType=mc.nodeType(sel)
             if objType== 'mesh' or objType == 'nurbsSurface' or objType == 'subdiv':
                 for att in ls.renderAtts():
                     if not mc.getAttr(sel + '.' + att) == mc.checkBoxGrp(att,q=1, v1=1):
                         mc.setAttr( sel + '.' + att , mc.checkBoxGrp(att,q=1, v1=1))
     else:
         for each in ls.renderAtts(): mc.checkBoxGrp(each,e=1,v1=value)