def update_size_ui(self):
     if self.dock_ui and self.dock[0]:
         kwargs = self.__dock_kwargs()
         kwargs["e"] = True
         pmc.dockControl(self.dock_ui, **kwargs)
     else:
         self.win.setWidthHeight(self.sizes[:2])
     
     paneSizes = []
     tmp = self.sizes[2:8]
     j = 1
     for i in range(0, len(tmp) - 1, 2):
         paneSizes.append([j, tmp[i], tmp[i + 1]])
         j += 1
     pmc.paneLayout(self.main_layout, e=True, paneSize=paneSizes)
     
     pmc.paneLayout(self.script_layout, e=True,
                    paneSize=[
                              [1, self.sizes[8], self.sizes[10]],
                              [2, self.sizes[9], self.sizes[11]],
                              ]
                    )
     
     pmc.checkBoxGrp(self.order_ui, e=True, v1=self.order)
     pmc.checkBoxGrp(self.order_ui, e=True, v2=self.show_doc)
     
     pmc.optionMenuGrp(self.filter_test_ui, e=True, v=self.filter_test)

    def initUI(self):
        pm.setUITemplate("DefaultTemplate", pushTemplate=True)
        form = pm.formLayout()

        binMeshExportPath = pm.optionVar.get('mtap_binMeshExportPath', pm.workspace.path + "/geo/export.binarymesh")
        prefix = pm.optionVar.get('mtap_binMeshExportPathPrefix', "prefix")
        createProxy = pm.optionVar.get('mtap_binMeshCreateProxy', True)
        percentage = pm.optionVar.get('mtap_binMeshPercentage', 0.1)
        createStandin = pm.optionVar.get('mtap_binMeshCreateStandin', True)
        oneFilePerMesh = pm.optionVar.get('mtap_binMeshOneFilePerMesh', False)
        useTransform = pm.optionVar.get('mtap_binMeshUseTransform', False)

        with pm.columnLayout('StandinLayout') as StandinLayout:
            with pm.frameLayout('StandinLayout', label="Standin export options", collapsable=False):
                with pm.columnLayout('StandinColumnLayout'):
                    self.pathUI = pm.textFieldButtonGrp(label="Standin directory", text=binMeshExportPath, buttonLabel="File", buttonCommand=self.fileBrowser)
                    self.prefixUI = pm.textFieldGrp(label="Prefix", text=prefix)
                    self.createProxyUI = pm.checkBoxGrp(label="Create proxy", value1=createProxy)
                    self.percentageUI = pm.floatFieldGrp(label="Percentage", value1=percentage)
                    self.createStdInUI = pm.checkBoxGrp(label="Create StandIn", value1=createStandin)
                    self.oneFilePerMeshUI = pm.checkBoxGrp(label="One File Per Mesh", value1=oneFilePerMesh)
                    self.doTransformUI = pm.checkBoxGrp(label="Use Transform", value1=useTransform)
            with pm.rowColumnLayout(numberOfColumns=2):
                pm.button(label="Create BinaryMesh", c=self.doit)
                pm.button(label="Cancel", c=self.cancel)

        pm.formLayout(form, edit=True, attachForm=[(StandinLayout, 'top', 5), (StandinLayout, 'bottom', 5), (StandinLayout, 'right', 5), (StandinLayout, 'left', 5)])
        pm.setUITemplate("DefaultTemplate", popTemplate=True)

    def KrayRendererUpdateTab(self, dummy=None):
        self.createGlobalsNode()
        #self.updateEnvironment()
        log.debug("KrayRendererUpdateTab()")
        
        sDict = self.rendererTabUiDict['sampling']
        sType = self.renderGlobalsNode.samplingType.get()
        
        if sType != 1: #grid
            pm.intFieldGrp(sDict['gridSize'], edit=True, enable=False)
            pm.checkBoxGrp(sDict['gridRotate'], edit=True, enable=False)
        else:
            pm.intFieldGrp(sDict['gridSize'], edit=True, enable=True)
            pm.checkBoxGrp(sDict['gridRotate'], edit=True, enable=True)

        fType = self.renderGlobalsNode.filtertype.get()
        if fType in [4, 5, 6]:
            pm.floatFieldGrp(sDict['filterSize'], edit=True, enable=False)
        else:
            pm.floatFieldGrp(sDict['filterSize'], edit=True, enable=True)
            
        iFormat = self.renderGlobalsNode.imageFormat.get()    
        if iFormat in [2, 3]:
            pm.attrEnumOptionMenuGrp(sDict['bitdepth'], edit=True, enable=True) 
        else:
            pm.attrEnumOptionMenuGrp(sDict['bitdepth'], edit=True, enable=False) 
            
        if iFormat == 1:
            pm.intFieldGrp(sDict['jpgQuality'], edit=True, enable=True)
        else:
            pm.intFieldGrp(sDict['jpgQuality'], edit=True, enable=False)

def addUIElement(uiType, attribute, uiLabel, callback, renderGlobalsNodeName):
    ui = None
    if uiType == 'bool':
        ui = pm.checkBoxGrp(label=uiLabel)
        if callback is not None:
            pm.checkBoxGrp(ui, edit=True, cc=callback)
    if uiType == 'int':
        ui = pm.intFieldGrp(label=uiLabel, numberOfFields = 1)
        if callback is not None:
            pm.intFieldGrp(ui, edit=True, cc = callback)
    if uiType == 'float':
        ui = pm.floatFieldGrp(label=uiLabel, numberOfFields = 1)
        if callback is not None:
            pm.floatFieldGrp(ui, edit=True, cc= callback)
    if uiType == 'enum':
        ui = pm.attrEnumOptionMenuGrp(label = uiLabel, at=attribute, ei = getEnumList(attribute)) 
        # attrEnumOptionGrp has no cc callback, so I create a script job
        if callback is not None:
            attribute = pm.Attribute(renderGlobalsNodeName + "." + attribute)
            pm.scriptJob(attributeChange=[attribute, callback], parent=ui)           
    if uiType == 'color':
        ui = pm.attrColorSliderGrp(label=uiLabel, at=attribute)
    if uiType == 'string':
        ui = pm.textFieldGrp(label=uiLabel)
        if callback is not None:
            pm.textFieldGrp(ui, edit=True, cc=callback)
    if uiType == 'vector':
        ui = pm.floatFieldGrp(label=uiLabel, nf=3)
        if callback is not None:
            pm.floatFieldGrp(ui, edit=True, cc=callback)
    return ui

 def createCamerasUI(self, uiDict):
     with pm.columnLayout(adjustableColumn=True, width=400) as uiDict["camerasCL"]:
         for cam in pm.ls(type="camera"):
             pm.checkBoxGrp(
                 label=cam.name(), value1=cam.renderable.get(), cc=pm.Callback(self.switchCamRenderable, cam)
             )
             self.cameras.append(cam.name())

    def rename(self, *args):
        v1 = pm.checkBoxGrp(self.cbFld, q=1, v1=1)
        v2 = pm.checkBoxGrp(self.cbFld, q=1, v2=1)
        if v1 and v2:
            pm.warning('Only select one Type: FK or IK. No action taken.')
            return

        name = pm.textFieldGrp( self.nameFld, q=1, text=1)

        # Rename base control
        baseCnt = pm.PyNode('vks_explicit1')
        baseCnt.rename('%s_baseCnt' % name)

        # Get joints
        pm.select('vks_skin_joint_1', hi=1)
        jnts = pm.ls(sl=1, type='joint')
        count = 1
        for each in jnts:
            pc = each.listConnections(et=1, type='parentConstraint')[0]
            print pc
            pc.rename('%s_joint_%s_parentConstraint' % (name, count))
            each.rename('%s_joint_%s' % (name, count))
            pm.select(each, r=1)
            pm.mel.eval('ToggleLocalRotationAxes;')
            count += 1

        # FK parametric controls
        if v1:
            pm.select('vks_parametric*Shape')
            sel = pm.ls(sl=1)
            count = 1
            for each in sel:
                prnt = each.getParent()
                prnt.rename('%s_cnt_%s' % (name, count))
                count += 1

 def updateCamerasUI(self):
     if self.rendererTabUiDict.has_key('common'):            
         uiDict = self.rendererTabUiDict['common']
         pm.deleteUI(uiDict['camerasCL'])
         with pm.columnLayout(adjustableColumn=True, width=400, parent=uiDict['camerasFrame']) as uiDict['camerasCL']:
             for cam in pm.ls(type="camera"):
                 pm.checkBoxGrp(label=cam.name(), value1=cam.renderable.get(), cc=pm.Callback(self.switchCamRenderable, cam))

 def KrayFinalGatheringCreateTab(self):
     log.debug("KrayFinalGatheringCreateTab()")
     self.createGlobalsNode()
     parentForm = pm.setParent(query=True)
     pm.setUITemplate("attributeEditorTemplate", pushTemplate=True)
     scLo = self.rendererName + "PhotonsScrollLayout"
     with pm.scrollLayout(scLo, horizontalScrollBarThickness=0):
         with pm.columnLayout(self.rendererName + "ColumnLayout", adjustableColumn=True, width=400):
             with pm.frameLayout(label="Photons frame", collapsable=True, collapse=False):
                 with pm.columnLayout(self.rendererName + "ColumnLayout", adjustableColumn=True, width=400):
                     ui = pm.floatFieldGrp(label="Threshold:", numberOfFields=1)
                     pm.connectControl(ui, self.renderGlobalsNodeName + ".fgThreshold", index=2)
                     pm.separator()                     
                     ui = pm.intFieldGrp(label="Min Rays:", numberOfFields=1)
                     pm.connectControl(ui, self.renderGlobalsNodeName + ".fgMinRays", index=2) 
                     ui = pm.intFieldGrp(label="Max Rays:", numberOfFields=1)
                     pm.connectControl(ui, self.renderGlobalsNodeName + ".fgMaxRays", index=2) 
                     ui = pm.floatFieldGrp(label="Prerender:", numberOfFields=1)
                     pm.connectControl(ui, self.renderGlobalsNodeName + ".fgPrerender", index=2)                     
                     ui = pm.intFieldGrp(label="Passes:", numberOfFields=1)
                     pm.connectControl(ui, self.renderGlobalsNodeName + ".fgPasses", index=2) 
                     pm.separator()                     
                     ui = pm.floatFieldGrp(label="Sploth Detect:", numberOfFields=1)
                     pm.connectControl(ui, self.renderGlobalsNodeName + ".fgSplotchDetect", index=2)                     
                     ui = pm.floatFieldGrp(label="Sensitivity:", numberOfFields=1)
                     pm.connectControl(ui, self.renderGlobalsNodeName + ".fgSensitivity", index=2)  
                     pm.separator()                     
                     ui = pm.checkBoxGrp(label="FG Reflections:", value1=False)
                     pm.connectControl(ui, self.renderGlobalsNodeName + ".fgReflections", index=2) 
                     ui = pm.checkBoxGrp(label="FG Refractions:", value1=False)
                     pm.connectControl(ui, self.renderGlobalsNodeName + ".fgRefractions", index=2)                   
                     pm.separator()                     
                     ui = pm.floatFieldGrp(label="Spatial Tolerance:", numberOfFields=1)
                     pm.connectControl(ui, self.renderGlobalsNodeName + ".fgSpatialTolerance", index=2)  
                     ui = pm.floatFieldGrp(label="Angular Tolerance:", numberOfFields=1)
                     pm.connectControl(ui, self.renderGlobalsNodeName + ".fgAngularTolerance", index=2)  
                     ui = pm.floatFieldGrp(label="FG Min Dist:", numberOfFields=1)
                     pm.connectControl(ui, self.renderGlobalsNodeName + ".fgDistMin", index=2)  
                     ui = pm.floatFieldGrp(label="FG Dist Max:", numberOfFields=1)
                     pm.connectControl(ui, self.renderGlobalsNodeName + ".fgDistMax", index=2)  
                     ui = pm.floatFieldGrp(label="Density/Brightness:", numberOfFields=1)
                     pm.connectControl(ui, self.renderGlobalsNodeName + ".fgBrightness", index=2)  
                     pm.separator()                     
                     ui = pm.intFieldGrp(label="Path Passes:", numberOfFields=1)
                     pm.connectControl(ui, self.renderGlobalsNodeName + ".fgPathPasses", index=2)  
                     ui = pm.floatFieldGrp(label="Corner Dist:", numberOfFields=1)
                     pm.connectControl(ui, self.renderGlobalsNodeName + ".fgCornerDist", index=2)  
                     ui = pm.checkBoxGrp(label="Show Samples:", value1=False)
                     pm.connectControl(ui, self.renderGlobalsNodeName + ".fgShowSamples", index=2) 
                     
     pm.setUITemplate("attributeEditorTemplate", popTemplate=True)
     pm.formLayout(parentForm, edit=True, attachForm=[ (scLo, "top", 0), (scLo, "bottom", 0), (scLo, "left", 0), (scLo, "right", 0) ])

def animateExportUI():
    
    winName = 'animateUI'
    if(pm.window(winName,q=1,ex=1)):
        pm.deleteUI(winName)
    pm.window(winName,ret=1,mb=1)
    pm.columnLayout('columnLayout8',adj=1)
    pm.checkBoxGrp('exportType',ncb=3, label='export Type  :  ', 
                     la3=[':  transform', ':  rotate', ':  custom'])
    pm.textFieldGrp('exportPath',l = 'export Path  :  ',adj = 0,
                      cl2 = ['right','center'],tx = 'asdd')
    pm.button('export',c = 'animateExport()')
    
    pm.showWindow(winName)

    def getData(self, *args):
        path = pm.textFieldButtonGrp(self.pathUI, query=True, text=True)
        prefix = pm.textFieldGrp(self.prefixUI, query=True, text=True)
        doProxy = pm.checkBoxGrp(self.createProxyUI, query=True, value1=True)
        percentage = pm.floatFieldGrp(self.percentageUI, query=True, value1=True)
        createStdin = pm.checkBoxGrp(self.createStdInUI, query=True, value1=True)
        oneFilePerMesh = pm.checkBoxGrp(self.oneFilePerMeshUI, query=True, value1=True)
        useTransform = pm.checkBoxGrp(self.doTransformUI, query=True, value1=True)

        pm.optionVar['mtap_binMeshExportPath'] = path
        pm.optionVar['mtap_binMeshExportPathPrefix'] = prefix
        pm.optionVar['mtap_binMeshCreateProxy'] = doProxy
        pm.optionVar['mtap_binMeshPercentage'] = percentage
        pm.optionVar['mtap_binMeshCreateStandin'] = createStdin
        pm.optionVar['mtap_binMeshOneFilePerMesh'] = oneFilePerMesh
        pm.optionVar['mtap_binMeshUseTransform'] = useTransform

def dimConnections(element):
    print "DimConnections"
    if element['name'] in ['motionblur']:
        value = pm.checkBoxGrp( element['name'], query = True, v1 = True)
        print element['uielement']
        valueInv = value
        #groups = mantraGlobalsAttributes.mantraGlobalsAttributes
        #if el['name'] in ['xftimesamples', 'geotimesamples', 'motionfactor', 'mbtype']:
        if value:
            print "enabling ctrls"            
        else:
            print "disabling ctrls"
        pm.intFieldGrp('xftimesamples', edit = True, enable = valueInv)
        pm.intFieldGrp('geotimesamples', edit = True, enable = valueInv)
        pm.floatFieldGrp('motionfactor', edit = True, enable = valueInv)
        pm.attrEnumOptionMenu('mbtype', edit = True, enable = valueInv)
        pm.checkBoxGrp('imagemotionblur',  edit = True, enable = valueInv)

 def setValue(self, value):
     if value == "stdingfilename":
         self.fileName = pm.textFieldButtonGrp("stdingfilename", query=True, text=True)
     if value == "stdinshowpoints":
         self.showPoints = pm.checkBoxGrp("stdinshowpoints", query=True, value1=True)
     if value == "stdinptdensity":
         self.density = pm.floatFieldGrp("stdinptdensity", query=True, value1=True)          
     if value == "stdinptsize":
         self.pointSize = pm.intFieldGrp("stdinptsize", query=True, value1=True)

 def order_by_ui(self, *args):
     self.order = pmc.checkBoxGrp(self.order_ui, q=True, v1=True)
     
     self.spp_.sort_objects(alphabetical=self.order,
                            filter_str=pmc.textFieldGrp(self.filter_ui, q=True, text=True),
                            filter_test=self.filter_test)
     
     pmc.textScrollList(self.infos_ui, e=True, ra=True)
     pmc.textScrollList(self.infos_ui, e=True, a=[o.repr_ for o in self.spp_.order_obj])

    def AppleseedTranslatorCreateTab(self):
        log.debug("AppleseedTranslatorCreateTab()")
        self.createGlobalsNode()
        parentForm = pm.setParent(query=True)
        pm.setUITemplate("attributeEditorTemplate", pushTemplate=True)
        scLo = self.rendererName + "TrScrollLayout"
        
        with pm.scrollLayout(scLo, horizontalScrollBarThickness=0):
            with pm.columnLayout(self.rendererName + "TrColumnLayout", adjustableColumn=True, width=400):
                with pm.frameLayout(label="Translator", collapsable=True, collapse=False):
                    attr = pm.Attribute(self.renderGlobalsNodeName + ".translatorVerbosity")
                    ui = pm.attrEnumOptionMenuGrp(label="Translator Verbosity", at=self.renderGlobalsNodeName + ".translatorVerbosity", ei=self.getEnumList(attr)) 
                
                with pm.frameLayout(label="{0} export".format(self.rendererName), collapsable=True, collapse=False):
                    ui = pm.checkBoxGrp(label="Export {0} Scene file:".format(self.rendererName), value1=False)
                    pm.connectControl(ui, self.renderGlobalsNodeName + ".exportSceneFile", index=2)
#                     xmlDict = {}
#                     self.rendererTabUiDict['xml'] = xmlDict
#                     defaultXMLPath = pm.workspace.path + "/" + pm.sceneName().basename().split(".")[0] + ".appleseed"
#                     if not defaultXMLPath.dirname().exists():
#                         defaultXMLPath.dirname().makedirs()
#                     with pm.rowLayout(nc=3):
#                         xmlDict['xmlFileText'] = pm.text(label="Export to")
#                         xmlDict['xmlFile'] = pm.textField(text=defaultXMLPath)
#                         pm.symbolButton(image="navButtonBrowse.png", c=self.xmlFileBrowse)
#                         pm.connectControl(xmlDict['xmlFile'], self.renderGlobalsNodeName + ".exportSceneFileName", index=2)
                        
                with pm.frameLayout(label="Optimize Textures", collapsable=True, collapse=False):
                    optiDict = {}
                    ui = pm.checkBoxGrp(label="Use Optimized Textures:", value1=False)
                    pm.connectControl(ui, self.renderGlobalsNodeName + ".useOptimizedTextures", index=2)
                    with pm.rowLayout(nc=3):
                        self.rendererTabUiDict['opti'] = optiDict
                        pm.text(label="OptimizedTex Dir:")
                        optiDict['optiField'] = pm.textField(text=self.renderGlobalsNode.optimizedTexturePath.get())
                        pm.symbolButton(image="navButtonBrowse.png", c=self.dirBrowse)
                        pm.connectControl(optiDict['optiField'], self.renderGlobalsNodeName + ".optimizedTexturePath", index=2)
                        
                with pm.frameLayout(label="Additional Settings", collapsable=True, collapse=False):
                    ui = pm.floatFieldGrp(label="Scene scale:", value1=1.0, numberOfFields=1)
                    pm.connectControl(ui, self.renderGlobalsNodeName + ".sceneScale", index=2)
                         
        pm.setUITemplate("attributeEditorTemplate", popTemplate=True)
        pm.formLayout(parentForm, edit=True, attachForm=[ (scLo, "top", 0), (scLo, "bottom", 0), (scLo, "left", 0), (scLo, "right", 0) ])

 def __init__(self, inst):
     self.armModuleFrame = pm.frameLayout( parent = inst.simpleSetup_layout, w =244, label='simpleArm', borderStyle='out', cll = True, cl = True )
     self.armSide_RBGRP = pm.radioButtonGrp( label='Choose Arm Side', labelArray3=['Left', 'Center', 'Right'], numberOfRadioButtons=3 )
     self.armSpace_RBGRP = pm.radioButtonGrp( label='Choose Arm Space', labelArray3=['Top', 'Middle', 'Bottom'], numberOfRadioButtons=3 )
     self.armAttribute_ChkBoxGRP = pm.checkBoxGrp( parent = self.armModuleFrame, label = 'Arm Attributes   ', cw = ( [ 1, 90 ], [ 2, 70 ], [ 3, 100 ], [ 4, 60 ] ),numberOfCheckBoxes=3, labelArray3=['Stretchy', 'Elbow Pinning', 'Bendy Arms'], v1 = 1, v2 = 1, v3 =  1 )
     
     self.armModulebutton_layout = pm.rowColumnLayout(parent = self.armModuleFrame, nc = 3 )
     self.buildArm_Btn = pm.button(parent = self.armModulebutton_layout, w = 120, h = 24, label="Build Arm", command = self.build_armMod)
     self.mirrorArm_Btn = pm.button( parent = self.armModulebutton_layout, w = 120, h = 24, label = 'Mirror Arm', c = self.exe_MirrorArm )
     self.collapseArmModule_Btn = pm.button( parent = self.armModulebutton_layout, w = 120, h = 24, label = 'Collapse Arm Module', c = self.exe_collapseArmModule )

 def create(self, stationary_count, offset_count):
     '''
     Create the fgshooter window.
     '''
     if pm.window(self.window_name, exists=True):
         pm.deleteUI(self.window_name)
     pm.window(self.window_name, title=self.window_title)
     
     main_form = pm.formLayout(numberOfDivisions=2)
     self.column = pm.columnLayout(adjustableColumn=True)
     
     # Render Camera
     self.render_camera_field = pm.checkBoxGrp(label="Include Render Camera", value1=self.render_camera, changeCommand=self.updateRenderCamera)
     
     # Stationary Cameras
     pm.separator(height=20, style="in")
     
     pm.rowLayout(numberOfColumns=3, columnWidth3=(140, 80, 80), columnAlign=(1, 'right'), columnAttach3=("right", "both", "both"))
     pm.text("Stationary Cameras")
     self.stationary_field = pm.intField(value=stationary_count)
     pm.button(label="Update", height=22, command=self.update)
     pm.setParent('..')
     
     self.stationary = []
     i = 0
     while i < stationary_count:
         self.stationary.append(pm.floatFieldGrp(value1=self.stationary_frames[i], label="frame"))
         i += 1
     
     # Offset Cameras
     pm.separator(height=20, style="in")
     
     pm.rowLayout(numberOfColumns=3, columnWidth3=(140, 80, 80), columnAlign=(1, 'right'), columnAttach3=("right", "both", "both"))
     pm.text("Offset Cameras")
     self.offset_field = pm.intField(value=offset_count)
     pm.button(label="Update", height=22, command=self.update)
     pm.setParent('..')
     
     self.offset = []
     i = 0
     while i < offset_count:
         self.offset.append(pm.intFieldGrp(value1=self.offset_frames[i], label="frame offset"))
         i += 1
     
     pm.setParent('..')
     
     # remove/apply buttons        
     self.remove_button = pm.button(label="Remove All", height=30, command=self.remove)
     self.apply_button = pm.button(label="Apply / Refresh", height=30, command=self.apply)
     
     pm.formLayout(main_form, edit=True, attachForm=[(self.column, "top", 2),(self.column, "left", 2),(self.column, "right", 2), (self.remove_button, "bottom", 2), (self.remove_button, "left", 2), (self.apply_button, "bottom", 2), (self.apply_button, "right", 2)], attachControl=(self.remove_button, "right", 1, self.apply_button), attachPosition=[ (self.remove_button, "right", 0, 1), (self.apply_button, "left", 1, 1)] )
     
     pm.setParent('..')
     pm.showWindow()

 def __init__(self):
     self.title = "Mantra Standin"
     self.fileName = ""
     self.density = .3
     self.pointSize = 1
     self.showPoints = False
     self.boundingBox = [-.5, -.5, -.5, .5, .5, .5]
     
     pm.setUITemplate("DefaultTemplate", pushTemplate=True)
     self.height = 500
     with pm.frameLayout(collapsable=False, labelVisible=False) as frame:
         pm.textFieldButtonGrp("stdingfilename", label="GeoFileName", text="", buttonLabel="Select", bc=pm.Callback(self.selectGeoFile), cc=pm.Callback(self.setValue, "stdingfilename"))
         #string $b = `symbolButton -image "navButtonBrowse.xpm" browser`;
         with pm.frameLayout(collapsable=False, label="Points"):
             pm.checkBoxGrp("stdinshowpoints", label="Show Points", value1=False, cc=pm.Callback(self.setValue, "stdinshowpoints"))
             pm.floatFieldGrp("stdinptdensity", label="PointDensity", value1=0.3, cc=pm.Callback(self.setValue, "stdinptdensity"))
             pm.intFieldGrp("stdinptsize", label="PointSize", value1=1, cc=pm.Callback(self.setValue, "stdinptsize"))
         with pm.rowLayout(nc=2):
             pm.button(label="Create Standin", c=pm.Callback(self.createStandin))            
             pm.button(label="Cancel", c=pm.Callback(self.delete))        
     self.show()

 def LuxEnvironmentCreateTab(self, dummy = None):
     log.debug("LuxEnvironmentCreateTab()")
     self.createGlobalsNode()
     
     if self.rendererTabUiDict.has_key('environment'):
         self.rendererTabUiDict.pop('environment')
     
     parentForm = pm.setParent(query=True)
     pm.setUITemplate("attributeEditorTemplate", pushTemplate=True)
     scLo = self.rendererName + "ENScrollLayout"
     envDict = {}
     self.rendererTabUiDict['environment'] = envDict
     with pm.scrollLayout(scLo, horizontalScrollBarThickness=0):
         with pm.columnLayout(self.rendererName + "ColumnLayout", adjustableColumn=True, width=400):
             with pm.frameLayout(label="Environment Lighting", collapsable=False):
                 with pm.columnLayout(self.rendererName + "ColumnLayout", adjustableColumn=True, width=400):
                     envDict['pskSkyUse'] = pm.checkBoxGrp(label="Use physical Sky:", value1=True, cc=pm.Callback(self.uiCallback, tab="environment"))
                     pm.connectControl(envDict['pskSkyUse'], self.renderGlobalsNodeName + ".usePhysicalSky", index=2)             
                     envDict['pskUsePhySun'] = pm.checkBoxGrp(label="Use Physical Sun:", value1=False, cc=pm.Callback(self.uiCallback, tab="environment"))
                     pm.connectControl(envDict['pskUsePhySun'], self.renderGlobalsNodeName + ".physicalSun", index=2)                    
                     envDict['pskPhySun'] = pm.textFieldGrp(label="Sun Object:", text="", editable=False) 
                     pm.separator()
                     envDict['pskSunGain'] = pm.floatFieldGrp(label="Sun Gain:", value1=1.0, numberOfFields=1)
                     pm.connectControl(envDict['pskSunGain'], self.renderGlobalsNodeName + ".sunGain", index=2)             
                     envDict['pskTurb'] = pm.floatFieldGrp(label="Turbidity:", value1=1.0, numberOfFields=1)
                     pm.connectControl(envDict['pskTurb'], self.renderGlobalsNodeName + ".turbidity", index=2)                    
                     envDict['pskSamples'] = pm.floatFieldGrp(label="Samples:", value1=1.0, numberOfFields=1)
                     pm.connectControl(envDict['pskSamples'], self.renderGlobalsNodeName + ".skySamples", index=2)                    
                     envDict['pskRelSize'] = pm.floatFieldGrp(label="Sun Size:", value1=1.0, numberOfFields=1)
                     pm.connectControl(envDict['pskRelSize'], self.renderGlobalsNodeName + ".sunRelSize", index=2)                    
                 
     pm.setUITemplate("attributeEditorTemplate", popTemplate=True)
     pm.formLayout(parentForm, edit=True, attachForm=[ (scLo, "top", 0), (scLo, "bottom", 0), (scLo, "left", 0), (scLo, "right", 0) ])
     
     pm.scriptJob(attributeChange=[self.renderGlobalsNode.physicalSun, pm.Callback(self.uiCallback, tab="environment")])   
     
     self.updateEnvironment()     

    def __init__(self):
        version = "1.0"
        if pm.window('RigToolsRenameWin', exists=True):
            pm.deleteUI('RigToolsRenameWin' , window=True)
        self.window = pm.window( 'RigToolsRenameWin' , title="Rig Tools Rename v%s" % version, iconName='RigToolsRenameWin' )

        with pm.columnLayout(adj=1):
            with pm.columnLayout( adjustableColumn=True ):
                pm.text('Assumes only one rig in the scene.')
                pm.text('Will only rename things with default naming.')
                self.cbFld = pm.checkBoxGrp( numberOfCheckBoxes=2,
                                             label='Type:',
                                             labelArray2=['FK', 'IK'] )
                self.nameFld = pm.textFieldGrp( label='Name' )
                pm.button(l='Rename', c=self.rename)

        pm.showWindow( self.window )

 def __init__(self):
     title="joints_on_curve"
     if(pm.windowPref(title, q=True, ex=True)):
         pm.windowPref(title, remove=True)
     if(pm.window(title, q=True, ex=True)):
         pm.deleteUI(title)
     #splineIK UI
     self.win = pm.window(title, title="Joints on Curve")
     self.layout = pm.rowColumnLayout()
     self.jntPlaceBtn = pm.radioButtonGrp(parent=self.layout, numberOfRadioButtons=2, label="Joint Placement", labelArray2=("CV's", "Even"), cc=self.jntPlaceBtn_change)
     self.jntSnapBtn = pm.radioButtonGrp(parent=self.layout, enable=False, numberOfRadioButtons=2, sl = 1,  label="Snap To", labelArray2=("CV", "Closest Point On Curve"))
     self.jntLayoutBtn = pm.radioButtonGrp(parent=self.layout, enable=False, numberOfRadioButtons=2, sl = 1,  label="Joint Layout", labelArray2=("Solo", "Hierarchy"), on1 = self.jntLayoutBtn_on)
     self.jntNumSlider = pm.intSliderGrp(enable=False, field=True, label='number of joints', minValue=4, maxValue=100, fieldMinValue=4, fieldMaxValue=100, value=0)
     self.crvNameField = pm.textFieldButtonGrp(enable=False, label='Target Curve', placeholderText='Enter Curve Name Here', buttonLabel='load selected', buttonCommand=self.crvNameField_load)
     self.jntNameFeild = pm.textFieldGrp(parent=self.layout,enable=False, label='Joint Base Name', placeholderText="name your joints", editable=True, tcc=self.jntNameFeild_change)
     self.chkboxGrp = pm.checkBoxGrp(enable=False, numberOfCheckBoxes=3, label='Add', labelArray3=['splineIK', 'CTRLs', 'stretchy'])
     self.goBtn = pm.button(parent=self.layout, enable=False,w = 100, h = 24, label="GO!", command=self.execute)  
     self.noBtn = pm.button(parent=self.layout, enable=False,w = 100, h = 24, label="NO DONT DO IT!", command=self.close)   
     self.format_string = "{PREFIX}_{INDEX}_{SUFFIX}"
     self.delete = []
     self.win.show()