Python maya.cmds 模块，deleteUI() 实例源码

def create_shelf():
    '''Create the bns shelf'''

    tab_layout = mel.eval('$pytmp=$gShelfTopLevel')
    shelf_exists = cmds.shelfLayout(SHELF_NAME, exists=True)

    if shelf_exists:
        cmds.deleteUI(SHELF_NAME, layout=True)

    shelf = cmds.shelfLayout(SHELF_NAME, parent=tab_layout)

    for button, kwargs in SHELF_BUTTONS.items():

        try:
            img = QtGui.QImage(kwargs['image'])
            kwargs['width'] = img.width()
            kwargs['height'] = img.height()

            cmds.shelfButton(label=button, parent=shelf, **kwargs)
        except:
            print button + ' failed...'
            print kwargs

def randomSelectionUI(*args):
    if cmds.window("win", exists = True):
        cmds.deleteUI("win")

    widgets["win"] = cmds.window("win", w=280, h=75, t="zbw_randomSelection")

    widgets["mainCLO"] = cmds.columnLayout()
    widgets["text"] = cmds.text("What percent of selection do you want to keep?")
    widgets["keepIFG"] = cmds.intFieldGrp(l=" % to keep:", v1=50, h=40, cw = ([1, 65], [2, 50]), cal = ([1,"left"], [2, "left"]))
    widgets["text2"] = cmds.text("Random: each obj has % chance to be removed")
    widgets["text3"] = cmds.text("Precise: exact num removed, but randomly chosen")
    cmds.separator(h=10)
    widgets["typeRBG"] = cmds.radioButtonGrp(l="Type:", l1 = "Random Remove", l2 = "Precise Remove", nrb = 2, sl = 1, cw = ([1, 30], [2,120], [3, 120], [4, 50]), cal = ([1, "left"], [2,"left"], [3, "left"], [4, "left"]))
    widgets["but"] = cmds.button(l="Reselect", w=280, h=40, bgc = (.6, .8, .6), c = doSel)

    cmds.window(widgets["win"], e=True, w=280, h=75)
    cmds.showWindow(widgets["win"])

def deleteInstances(cls):
        """
        Delete existing instances of this window
        """
        result = False
        # close and delete an existing workspace control
        if cmds.workspaceControl(cls.getWorkspaceControlName(), q=True, ex=True):
            cmds.workspaceControl(cls.getWorkspaceControlName(), e=True, close=True)
            result = True
        if cmds.workspaceControl(cls.getWorkspaceControlName(), q=True, ex=True):
            cmds.deleteUI(cls.getWorkspaceControlName(), control=True)
            result = True
        if cmds.window(cls.OBJECT_NAME, q=True, ex=True):
            cmds.deleteUI(cls.OBJECT_NAME, window=True)
            result = True
        return result

def findScriptUI(*args):

    if cmds.window("findScript", exists = True):
        cmds.deleteUI("findScript")

    widgets["win"] = cmds.window("findScript", t="zbw_findPath", w=300, h=200)
    widgets["mainCLO"] = cmds.columnLayout()

    cmds.separator(h=10)
    widgets["textTx"] = cmds.text(l="Will search your active python paths. \nNo need for suffix (.py or .mel)\nNo wildcards(*). Just string, 3 chars min", al="left")
    cmds.separator(h=20)
    widgets["nameTFG"] = cmds.textFieldGrp(l="search for:", cw = [(1, 75), (2,200)], cal = [(1, "left"),(2, "right")])
    cmds.separator(h=20)
    widgets["searchBut"] = cmds.button(l="Search python paths!", w=300, h=50, bgc=(0,.6, 0), c=searchPaths)
    cmds.separator(h=20)

    widgets["resultTxt"] = cmds.textFieldGrp(l="results:", ed=False, w=300, cw = [(1, 75), (2,200)], bgc = (0,0,0) , cal = [(1, "left"),(2, "right")])

    cmds.showWindow(widgets["win"])

def shadingTransferUI(*args):
    if cmds.window("win", exists=True):
        cmds.deleteUI("win")

    widgets["win"] = cmds.window("win", t="zbw_shadingTransfer", w=200, h=100, s=False)
    widgets["mainCLO"] = cmds.columnLayout()

    cmds.text(l="1. Select the source object (poly/nurbs)", al="left")
    cmds.text(l="2. Select the target object(s)", al="left")
    cmds.text(l="Note: deleteHistory on the transferUV\nwill try to avoid deleting deformers.\nNo promises:)", al="left")
    cmds.separator(h=10)
    widgets["shdBut"] = cmds.button(l="Copy Shaders to targets!", w=200, h=40, bgc=(.4, .7, .4), c=partial(getSelection, "copyShader"))
    cmds.separator(h=10)
    widgets["uvBut"] = cmds.button(l="Transfer UV's to targets!", w=200, h=40, bgc=(.7, .7, .5), c=partial(getSelection, "transferUV"))
    widgets["xferCBG"] = cmds.checkBoxGrp(l="Delete history after transfer?", v1=0, cal=[(1, "left"), (2,"left")], cw=[(1, 150), (2, 50)])
    cmds.window(widgets["win"], e=True, w=200, h=100)
    cmds.showWindow(widgets["win"])

def selectionUI(*args):
    #window stuff, two buttons
    if cmds.window("selWin", exists=True):
        cmds.deleteUI("selWin")

    widgets["win"] = cmds.window("selWin", t="zbw_selectionBuffer", s=False)
    widgets["mainCLO"] = cmds.columnLayout(bgc = (.8, .8, .8))

    widgets["getBut"] = cmds.button(l="Grab Selection", bgc = (.5, .5, .9), w=200, h=50, c=grabSel)
    cmds.separator(h=5)
    widgets["checkBut"] = cmds.button(l="Check Stored (in scipt ed.)", bgc = (.5, .5, .5), w=200, h=20, en=False, c=checkSel)
    cmds.separator(h=10)
    widgets["restoreBut"] = cmds.button(l="Restore Selection", bgc = (.5, .8, .5), w=200, h=50, c=restoreSel)

    cmds.window(widgets["win"], e=True, w=200, h=135)
    cmds.showWindow(widgets["win"])

def jointRadiusUI(*args):
    if cmds.window("jntWin", exists=True):
        cmds.deleteUI("jntWin")

    widgets["win"] = cmds.window("jntWin", t="zbw_jointRadius", w=200, h=90, s=False)
    widgets["clo"] = cmds.columnLayout(rs=10)

    widgets["slider"] = cmds.floatSliderGrp(l="radius", min=0.05, max=2, field=True, fieldMinValue=0.01,
                                            fieldMaxValue=2, precision=2, sliderStep=0.1, value=0.5,
                                            cw=([1, 40], [2, 45], [3, 115]),
                                            cal=([1, "left"], [2, "left"], [3, "left"]))
    # radio button group, all or selected
    widgets["rbg"] = cmds.radioButtonGrp(nrb=2, l1="all", l2="selected", cw=([1, 50], [1, 50]), sl=1)
    widgets["but"] = cmds.button(l="Set Radius", w=205, h=50, bgc=(.5, .8, .5), c=adjustRadius)

    cmds.window(widgets["win"], e=True, w=200, h=90)
    cmds.showWindow(widgets["win"])

def zbw_mmChangeConnectAttrUI(base, attr, obj, *args):
    if (cmds.window('zbw_mmChangeAttrUI', exists=True)):
        cmds.deleteUI('zbw_mmChangeAttrUI', window=True)
        cmds.windowPref('zbw_mmChangeAttrUI', remove=True)
    window=cmds.window('zbw_mmChangeAttrUI', widthHeight=(400,80), title='zbw_messageMapper_changeAttrName')
    cmds.columnLayout()
    #show old attr name
    cmds.text("old attribute name: " + attr)
    #asks for the new attr name
    cmds.textFieldGrp("zbw_mmChangeAttrTFG", l="new attr name (just attr name)")
    #button to do it (pass along attr, obj)
    cmds.button("zbw_mmChangeAttrB", l="change attr!", c=partial(zbw_mmChangeConnectAttr, base, attr, obj))
    cmds.showWindow(window)
    #force window to size
    cmds.window('zbw_mmChangeAttrUI', e=True, widthHeight = (400,80))
    pass

def zbw_mmChangeConnectObjUI(base, attr, obj, *args):
    if (cmds.window('zbw_mmChangeObjUI', exists=True)):
        cmds.deleteUI('zbw_mmChangeObjUI', window=True)
        cmds.windowPref('zbw_mmChangeObjUI', remove=True)
    window=cmds.window('zbw_mmChangeObjUI', widthHeight=(400,85), title='zbw_messageMapper_changeObjName')
    cmds.columnLayout()
    #show old attr name
    cmds.text("base attribute name: " + attr)
    cmds.text("old connected obj name: " + obj)
    #asks for the new attr name
    cmds.textFieldButtonGrp("zbw_mmChangeObjTFBG", l="select new obj: ", bl="get", bc=partial(zbw_mmAddTarget, "zbw_mmChangeObjTFBG"))
    #button to do it (pass along attr, obj)
    cmds.button("zbw_mmChangeObjB", l="change obj!", c=partial(zbw_mmChangeConnectObj, base, attr, obj))
    cmds.showWindow(window)
    #force window to size
    cmds.window('zbw_mmChangeObjUI', e=True, widthHeight = (420,85))

def modelSequenceUI(*args):
    if (cmds.window("modSeq", exists=True)):
        cmds.deleteUI("modSeq")

    widgets["win"] = cmds.window("modSeq", w = 300, h = 220, t = "zbw_modelSequence")
    widgets["mainCLO"] = cmds.columnLayout(w = 300,h = 220)

    cmds.separator(h=10)
    cmds.text("Select ONE object to be duplicated \nThis will duplicate it for frames selected and group", al="left")
    cmds.separator(h=20)

    #textFieldGRP - name of objs
    widgets["sufTFG"] = cmds.textFieldGrp(l="Sequence Suffix:", cw = [(1, 100), (2,200)], cal = [(1, "left"),(2, "right")])
    #radioButtonGrp - timeslider or frame range
    widgets["frmRBG"] = cmds.radioButtonGrp(l="Get Frames From:", nrb=2, sl=2, l1="Time Slider", l2="Frame Range", cw = [(1, 120), (2,80), (3,80)], cal = [(1, "left"),(2, "left")], cc=enableFR)
    #textFieldGrp - framerange (enable)
    widgets["frmRngIFG"] = cmds.intFieldGrp(l="Range:", nf=2, en=True, v1=0, v2 = 9, cw = [(1, 120), (2,80), (3,80)], cal = [(1, "left"),(2, "left")])
    #int = by frame step
    widgets["stepIFG"] = cmds.intFieldGrp(l="Step By (frames):", v1 = 1, cw = [(1, 120), (2,80)], cal = [(1, "left"),(2, "right")])

    cmds.separator(h=30)
    widgets["doBut"] = cmds.button(l="Create duplicates of objects!", w= 300, h=40, bgc = (0,.8, 0), c=getValues)


    cmds.showWindow(widgets["win"])

def follicleUI(*args):
    """UI for the script"""

    if cmds.window("folWin", exists=True):
        cmds.deleteUI("folWin")

    widgets["win"] = cmds.window("folWin", t="zbw_makeFollicle", w=300, h=100)
    widgets["mainCLO"] = cmds.columnLayout()
    # widgets["polyFrame"] = cmds.frameLayout(l="Polygon Vert(s) Follicle")
    # widgets["polyCLO"] = cmds.columnLayout()
    widgets["text"] = cmds.text("Select one or two vertices (2 will get avg position) and run")
    widgets["nameTFG"] = cmds.textFieldGrp(l="FollicleName:", cal=([1, "left"],[2,"left"]), cw=([1,100],[2,200]), tx="follicle")
    cmds.separator(h=10)
    widgets["button"] = cmds.button(w=300, h=50, bgc=(0.6,.8,.6), l="Add follicle to vert(s)", c=getUV)
    # cmds.setParent(widgets["mainCLO"])
    # widgets["nurbsFrame"] = cmds.frameLayout(l="Nurbs select")
    cmds.showWindow(widgets["win"])
    cmds.window(widgets["win"], e=True, w=300, h=100)
#-------could also select edit point????
#-------multiple selection and average uv position? Orrrr option to create multiple UV's, one on each vertex
#-------grab an edge and convert to 2 verts and get average. . .
#-------have option for distributed (select 2 verts and number of follicles, spread that num between the two uv positions)

def animNoiseUI():
    if cmds.window('animNoiseWin', exists=True):
        cmds.deleteUI('animNoiseWin', window=True)
        cmds.windowPref('animNoiseWin', remove=True)

    widgets["win"] = cmds.window('animNoiseWin', widthHeight=(300,200), title='zbw_animNoise')
    widgets["CLO"] = cmds.columnLayout(cal='center')
    widgets["ampFFG"] = cmds.floatFieldGrp(cal=(1, 'left'), nf=2, l="set Min/Max Amp", v1=-1.0, v2=1.0)
    #add gradient?
    widgets["freqIFG"] = cmds.intFieldGrp(cal=(1,'left'), l='frequency(frames)', v1=5)
    #checkbox for random freq
    widgets["randFreqOnCBG"] = cmds.checkBoxGrp(cal=(1,'left'), cw=(1, 175),l='random frequency on', v1=0, cc=animNoiseRandom)
    widgets["randFreqFFG"] = cmds.floatFieldGrp(l='random freq (frames)', v1=1, en=0)
    #checkbox for avoid keys
    widgets["avoidCBG"] = cmds.checkBoxGrp(cal=(1,'left'), cw=(1, 175),l='buffer existing keys (by freq)', v1=0)
    #radiobutton group for tangents
    #checkbox for timeline range
    widgets["rangeRBG"] = cmds.radioButtonGrp(nrb=2,l="Frame Range:", l1="Timeslider", l2="Frame Range", sl=1, cw=[(1,100),(2,75),(3,75)],cc=enableFrameRange)
    #floatFieldGrp for range
    widgets["frameRangeIFG"] = cmds.intFieldGrp(nf=2, l='start/end frames', v1=1, v2=10, en=0)

    widgets["goBut"] = cmds.button(l='Add Noise', width=300, h=30, bgc=(.6,.8,.6), command=addNoise)

    cmds.showWindow(widgets["win"])

def show(self):
        # First we check if a window of this name already exists.
        # This prevents us having many tweener windows when we just want one
        if cmds.window(self.windowName, query=True, exists=True):
            # If another window of the same name exists, we close it by deleting it
            cmds.deleteUI(self.windowName)

        # Now we create a window using our name
        cmds.window(self.windowName)

        # Now we call our buildUI method to build out the insides of the UI
        self.buildUI()

        # Finally we must actually show the window
        cmds.showWindow()

def close(self, *args):
        # This will delete our UI, thereby closing it
        cmds.deleteUI(self.windowName)

def close(self, *args):
        cmds.deleteUI(self.windowName)


# For our tweener UI, we inherit from our BaseWindow
# Just like our BaseWindow inherits from the Python object, our TweenerWindow inherits from BaseWindow
# This means that it will get all the attributes and methods that the Base Window has

def createMenu():
    cmds.setParent(mel.eval("$temp1=$gMainWindow"))

    if cmds.control('NR_ImportMenu', exists=True):
        cmds.deleteUI('NR_ImportMenu', menu=True)

    menu = cmds.menu('NR_ImportMenu', label='Ninja Ripper', tearOff=True)

    cmds.menuItem(
        label='Import RIP v4', c="cmds.showWindow('NR_ImportWindow')"
    )

    cmds.menuItem(
        label="Reload Script", c="reload(NinjaRipperMayaImportTools)"
    )

def about():
    """Displays the CMT About dialog."""
    name = 'cmt_about'
    if cmds.window(name, exists=True):
        cmds.deleteUI(name, window=True)
    if cmds.windowPref(name, exists=True):
        cmds.windowPref(name, remove=True)
    window = cmds.window(name, title='About CMT', widthHeight=(600, 500), sizeable=False)
    form = cmds.formLayout(nd=100)
    text = cmds.scrollField(editable=False, wordWrap=True, text=cmt.__doc__.strip())
    button = cmds.button(label='Documentation', command='import cmt.menu; cmt.menu.documentation()')
    margin = 8
    cmds.formLayout(form, e=True,
                    attachForm=(
                        (text, 'top', margin),
                        (text, 'right', margin),
                        (text, 'left', margin),
                        (text, 'bottom', 40),
                        (button, 'right', margin),
                        (button, 'left', margin),
                        (button, 'bottom', margin),
                    ),
                    attachControl=(
                        (button, 'top', 2, text)
                    ))
    cmds.showWindow(window)

def deleteControl(self, control):

        if cmds.workspaceControl(control, q=True, exists=True):

            cmds.workspaceControl(control, e=True, close=True)
            cmds.deleteUI(control, control = True)

    # Show window with docking ability

def Show():
    global MedicUIInstance

    if MedicUIInstance:
        cmds.showWindow(window.MainWindow.Name)

    else:
        if cmds.window(window.MainWindow.Name, q=True, ex=True):
            cmds.deleteUI(window.MainWindow.Name)

        MedicUIInstance = window.MainWindow(functions.getMayaMainWindow())
        MedicUIInstance.show()

def show_ui(self):
        u"""Window???"""
        if cmds.window(self._WINDOW_NAME, exists=True):
            cmds.deleteUI(self._WINDOW_NAME)

        self.window = cmds.window(self._WINDOW_NAME,
                                  t=self._WINDOW_TITLE,
                                  width=340,
                                  maximizeButton=False, minimizeButton=False)

        form = cmds.formLayout()
        field_group = cmds.columnLayout(adj=True, cal="center", rs=self._MARGIN)
        cmds.text(u"""???????????????????????????????
????????????????????????????""", al="left")
        self.text_scroll = cmds.textScrollList(append=self.get_windows(), ams=False, dcc=self.check_execute)
        self.text_field = cmds.textFieldGrp(l=u"????", ad2=2, cl2=["left", "left"], cw=[1, 60])
        cmds.setParent("..")

        button_group = cmds.columnLayout(adj=True, cal="center")
        cmds.button(l="Check", c=self.check_execute)
        cmds.setParent("..")

        cmds.formLayout(form, e=True,
                        attachForm=[(field_group, "top", self._MARGIN),
                                    (field_group, "left", self._MARGIN),
                                    (field_group, "right", self._MARGIN),
                                    (button_group, "bottom", self._MARGIN),
                                    (button_group, "left", self._MARGIN),
                                    (button_group, "right", self._MARGIN)],
                        attachControl=[(button_group, "top", self._MARGIN, field_group)])
        cmds.setParent("..")

        cmds.showWindow(self.window)

def safe_delete_window(win, *args):
    u"""????????????????"""
    if cmds.window(win, q=True, ex=True):
        cmds.deleteUI(win)

def safe_delete_ui(self, ui_name):
        u"""?????UI??????????????"""
        if cmds.window(ui_name, exists=True):
            cmds.deleteUI(ui_name)

def _create_swatch_display_port_widget(file_node, parent):
    u"""swatchDisplayPort?QWidget???????????????"""
    # swatchDisplayPort??????????????????window?????????
    tmp = cmds.window()
    cmds.columnLayout()
    sw = cmds.swatchDisplayPort(h=64, w=64, sn=file_node)
    ptr = om.MQtUtil.findControl(sw)
    sw_widget = QtCompat.wrapInstance(long(ptr), QtWidgets.QWidget)
    sw_widget.setParent(parent)
    sw_widget.resize(64, 64)
    cmds.deleteUI(tmp)
    return sw_widget

def add_toolbox_menu():
    gridLayout = 'hj_gridLayout'
    if mc.gridLayout(gridLayout, q=1, ex=1):
        mc.deleteUI(gridLayout)

    mc.setParent('flowLayout2')
    size=36
    mc.gridLayout(gridLayout, nc=1, cwh=[size, size])
    mc.setParent(gridLayout)

    global_vars = inspect.getouterframes(
        inspect.currentframe())[-1][0].f_globals
    # global_vars = globals()
    mc.shelfButton(
        i='play.png', c=lambda *x: __import__("pyshell").main(global_vars),w=40)

def DeleteMenu():
    # Check for existing control, remove it if we can
    if cmds.control(MENU_DATA['menu'][0], exists=True):
        # Found it, delete it
        cmds.deleteUI(MENU_DATA['menu'][0], menu=True)

# Create the menu

def create_shelf():
    """
    Create the OBB shelf

    Raises:
        None

    Returns:
        None
    """

    tab_layout = mel.eval('$pytmp=$gShelfTopLevel')
    shelf_exists = cmds.shelfLayout('OBB', exists=True)

    if shelf_exists:
        cmds.deleteUI('OBB', layout=True)

    shelf = cmds.shelfLayout('OBB', parent=tab_layout)

    for button, kwargs in buttons.items():

        img = QtGui.QImage(kwargs['image'])
        kwargs['width'] = img.width()
        kwargs['height'] = img.height()

        cmds.shelfButton(label=button, parent=shelf, **kwargs)

    # Fix object 0 error.
    shelves = cmds.shelfTabLayout(tab_layout, query=True, tabLabelIndex=True)

    for index, shelf in enumerate(shelves):
        cmds.optionVar(stringValue=("shelfName%d" % (index+1), str(shelf)))

def script_execute(code, source_type):
    '''
    maya????????????
    :param code: string
    :param source_type: 'mel' or 'python'
    :return:
    '''
    window = cmds.window()
    cmds.columnLayout()
    cmds.cmdScrollFieldExecuter(t=code, opc=1, sln=1, exa=1, sourceType=source_type)
    cmds.deleteUI(window)


# ??????????????????

def closeWindow(ui):
        cmds.deleteUI(ui)

def closeWindow(ui):
        cmds.deleteUI(ui)

def curveJntRigUI(*args):
    if cmds.window("crvRigJntWin", exists=True):
        cmds.deleteUI("crvRigJntWin")

    w, h= 400, 300

    widgets["win"] = cmds.window("crvRigJntWin", t="zbw_curveJntRig", w=w,h=h)
    widgets["mainCLO"] = cmds.columnLayout()


    widgets["numCtrlIFG"] = cmds.intFieldGrp(l="Number of Ctrls:", cal=[(1,"left"), (2,"left")], cw=[(1,120), (2,50)], v1=5)
    widgets["nameTFG"] = cmds.textFieldGrp(l="Rig Name (i.e. lfEye):", cal=[(1,"left"), (2,"left"), (3,"left")], cw=[(1,120), (2,280), (3,30)], tx="eye")
    widgets["cntrPivTFBG"] = cmds.textFieldButtonGrp(l="Center pivot object:", bl="<<<", cal=[(1,"left"), (2,"left"), (3,"left")], cw=[(1,120), (2,280), (3,30)], bc=partial(populateCrvField, "cntrPivTFBG"), cc=partial(secondFill, "center"), tx="centerLoc")
    widgets["upLocTFBG"] = cmds.textFieldButtonGrp(l="Aim up object:", bl="<<<", cal=[(1,"left"), (2,"left"), (3,"left")], cw=[(1,120), (2,280), (3,30)], bc=partial(populateCrvField, "upLocTFBG"), cc=partial(secondFill, "up"), tx="upLoc")
    cmds.separator(h=10)

    widgets["upCrvTFBG"] = cmds.textFieldButtonGrp(l="First Curve", bl="<<<", cal=[(1,"left"), (2,"left"), (3,"left")], cw=[(1,120), (2,280), (3,30)], bc=partial(populateCrvField, "upCrvTFBG"),tx="topCrv")
    widgets["upNameTFG"] = cmds.textFieldGrp(l="1st Suffix (i.e.'Top')", cal=[(1,"left"), (2,"left")], cw=[(1,120), (2,280)], tx="Top")
    cmds.separator(h=10)

    widgets["secondCBG"] = cmds.checkBoxGrp(l="Create Second Curve?", ncb=1, v1=0, cal=[(1,"left"), (2,"left")], cc=toggleSecond, en=True)
    widgets["downCrvTFBG"] = cmds.textFieldButtonGrp(l="Second Curve", bl="<<<", cal=[(1,"left"), (2,"left"), (3,"left")], en=False, cw=[(1,120), (2,280), (3,30)], bc=partial(populateCrvField, "downCrvTFBG"), tx="downCrv")
    widgets["downNameTFG"] = cmds.textFieldGrp(l="2nd Suffix (i.e. 'Dwn')", cal=[(1,"left"), (2,"left")], cw=[(1,120), (2,280)], en=False, tx="Dwn")
    widgets["cntrPiv2TFBG"] = cmds.textFieldButtonGrp(l="Center pivot object:", bl="<<<", cal=[(1,"left"), (2,"left"), (3,"left")], cw=[(1,120), (2,280), (3,30)], bc=partial(populateCrvField, "cntrPivTFBG"), en=False, tx="centerLoc")
    widgets["upLoc2TFBG"] = cmds.textFieldButtonGrp(l="Aim up object:", bl="<<<", cal=[(1,"left"), (2,"left"), (3,"left")], cw=[(1,120), (2,280), (3,30)], bc=partial(populateCrvField, "upLoc2TFBG"), en=False, tx="upLoc")
    cmds.separator(h=10)

    widgets["execBut"] = cmds.button(l="create base rig!", w=w, c=passToExecute)
    widgets["cnctBut"] = cmds.button(l="connect ctrls to jnts", w=w, c=connectProxies)
    widgets["closeBut"] = cmds.button(l="setup smart close", w=w, c=smartClose)

    cmds.separator(h=10)

    # widgets["scCBG"] = cmds.checkBoxGrp(l="Set up smart close?", ncb=1, v1=0, cal=[(1,"left"), (2,"left")], en=True)


    cmds.window(widgets["win"], e=True, w=5, h=5, resizeToFitChildren=True, sizeable=True)
    cmds.showWindow(widgets["win"])

def closeWindow(self, *args):
        cmds.deleteUI(self.widgets["window"])

def setClipUI(*args):
    """ UI for the whole thing"""

    if cmds.window("SCPwin", exists=True):
        cmds.deleteUI("SCPwin")
    cmds.window("SCPwin", t="Set Clip Planes", w=200, h=100)
    cmds.columnLayout("colLO")
    cmds.radioButtonGrp("camRBG", l="Cameras:", nrb=2, l1="All", l2="Selected", sl=1, cal=[(1,"left"),(2,"left"),(3,"left")], cw=[(1,70),(2,50),(3,50)])
    cmds.floatFieldGrp("nearFFG", l="nearClip", v1=1, cal=([1,"left"], [2,"left"]), cw=([1,50], [2,150]))
    cmds.floatFieldGrp("farFFG", l="farClip", v1=100000, cal=([1,"left"], [2,"left"]), cw=([1,50], [2,150]))
    cmds.separator(h=10,style="single")
    cmds.button("button", l="Set Clip Planes", h=50, w=200, bgc=(.8, .6,.6), c=setPlanes)

    cmds.showWindow("SCPwin")
    cmds.window("SCPwin", e=True, w=200, h=100)

def spaceBufferUI(*args):
    if cmds.window("spaceBufferWin", exists=True):
        cmds.deleteUI("spaceBufferWin")

    widgets["win"] = cmds.window("spaceBufferWin", rtf=True, wh=(200, 20))
    widgets["mainCLO"] = cmds.columnLayout(w=200)

    widgets["jntCreateBut"] = cmds.button(l="Create Joint/Grps at Selection!", w=200, h=30, bgc=(.6, .8,.6), c=createJointFromObj)
    widgets["makeBuffer"] = cmds.button(l="Create Space Buffer!", w=200, h=30, bgc=(.4, .6, .8), c=createSpaceBuffers)

    cmds.window(widgets["win"], e=True, wh=(5, 5), rtf=True)
    cmds.showWindow(widgets["win"])

def spaceMatchUI():
    if (cmds.window("spaceMatchWin", exists=True)):
        cmds.deleteUI("spaceMatchWin", window=True)
    #create window
    widgets["window"] = cmds.window("spaceMatchWin", title="Space Matcher", w=250, h=300)

    #create top frame
    widgets["topFrame"] = cmds.frameLayout(l="Object/Attr Selection", w=250, li=70, bgc=(0,0,0))
    widgets["objCLO"] = cmds.columnLayout()

    #create top controls
    widgets["objTFG"] = cmds.textFieldGrp(l="Selected Obj", cw=([1,70],[2,175]), cal=([1,"left"], [2,"left"]), cc=clearList)
    widgets["matchObjButton"] = cmds.button(l="Select Control Object", w=250, bgc=(.8,.8,.8), c = getObj)

#   #or we could assume the obj has a "follow" enum attr. . . .
#     widgets["attrTFG"] = cmds.textFieldGrp(l="Selected Attr", cw=([1,70],[2,175]), cal=([1,"left"], [2,"left"]), cc=clearList)
#     widgets["matchObjButton"] = cmds.button(l="Select Spaces Enum Attr", w=250, bgc=(.8,.8,.8), c = getAttr)

    #back to window
    cmds.setParent(widgets["window"])

    #create bottom frmae
    widgets["bottomFrame"] = cmds.frameLayout(l="Spaces", li=100, w=250, bgc=(0,0,0))
    widgets["bottomRCLO"] = cmds.rowColumnLayout(nc=2, w=250)

    #get obj and put it in
    sel = cmds.ls(sl=True)
    if (len(sel)) == 1:
        getObj()

    #show window
    cmds.showWindow(widgets["window"])
    cmds.window(widgets["window"], e=True, w=250, h=300)

def clearList(*args):
    #get rid of all children of the lower frame layout
    #or
    #delete the rcLayout
    cmds.deleteUI(widgets["bottomRCLO"])
    widgets["bottomRCLO"] = cmds.rowColumnLayout(nc=2, w=250, p=widgets["bottomFrame"])

def huddleUI(*args):
    if cmds.window("hudWin", exists=True):
        cmds.deleteUI("hudWin")

    widgets["win"] = cmds.window("hudWin", t="zbw_huddle", w=350, h=100, rtf=True)
    widgets["CLO"] = cmds.columnLayout()
    widgets["slider"] = cmds.floatSliderGrp(min=0, max=2, f=True, label="Factor:", cal=([1, "left"], [2,"left"], [3,
                                                                                                                  "left"]), cw=([1,50],[2,50],[3,225]), pre=3, v=1.0)
    cmds.separator(h=20)
    widgets["button"] = cmds.button(l="Move objects aroudnd first selected", w=350, h=30, bgc=(.6,.8, .6), c=huddleExec)

    cmds.window(widgets["win"], e=True, w=5, h=5, rtf=True)
    cmds.showWindow(widgets["win"])

def extendUI(*args):
    """UI for the script"""
    #UI
    if cmds.window("curbWin", exists=True):
        cmds.deleteUI("curbWin")

    cmds.window("curbWin", t="zbw_polyExtender", w=200, h=200)
    cmds.columnLayout("colLO")
    cmds.frameLayout("topFrame", l="Covert Edge", cll=True, bgc=(.2,.2,.2))
    cmds.text("Select poly edge to convert")
    cmds.button("convertBut", l="Convert!", w=200, h=30, bgc=(.8, .8,.6), c=convertEdge)
    cmds.separator(h=5)

    cmds.setParent("colLO")

    cmds.frameLayout("midFrame", l="Create Poly", cll=True, bgc=(.2,.2,.2))
    cmds.text("Select curve")
    cmds.separator(h=5)
    cmds.textFieldGrp("name", l="Name", w=200, cw=[(1,30), (2,170)], tx="newPoly")
    cmds.checkBox("curbCB", l="Positive Direction", v=True)
    # cmds.checkBox("bumpCB", l="Add vertical hump?", v=True)
    cmds.floatFieldGrp("curbFFG", l="Curb Width", cal=((1, "left"),(2,"left")), cw=([1,75],[2,50]), v1=10)
    cmds.intFieldGrp("UDivIFG", l="Width Subdivisions", cal=((1, "left"),(2,"left")), cw=([1,75],[2,50]), v1=1)
    cmds.intFieldGrp("VDivIFG", l="Length Subdivisions", cal=((1, "left"),(2,"left")), cw=([1,75],[2,50]), v1=1)
    cmds.checkBox("polyHistory", l="Keep history on final poly?", v=False)
    cmds.checkBox("history", l="Keep history objects?", v=True, cc=enableHistory)

    cmds.separator(h=5)
    cmds.button("curbBut", l="Create Curb", h=40, w=200, bgc=(.6, .8, .6), c=extendPoly)

    cmds.showWindow("curbWin")
    cmds.window("curbWin", e=True, h=150, w=200)

def zbw_mmDeleteConfirm():
    if (cmds.text("mmTextConfirm", q=True, ex=True)):
        cmds.deleteUI("mmTextConfirm")
        cmds.deleteUI("mmConfirmSep")

def zbw_mmDeleteMsgAttr(attr, *args):
    #delete the attr from the base obj
    cmds.deleteAttr(attr)
    #when you delete, then run the whole proc again afterwards (to clean up the nums)
    cmds.deleteUI("mmRCListLayout")
    zbw_mmListCurrentMessages("mmListMessages")

def zbw_mmChangeConnectAttr(base, attr, obj, *args):
    #get that from the text field
    newAttr = cmds.textFieldGrp("zbw_mmChangeAttrTFG", q=True, tx=True)
    #delete old attr
    cmds.deleteAttr(attr)
    #create new attr
    cmds.addAttr(base, at="message", ln=newAttr)
    #create connection to obj in new attr
    cmds.connectAttr((obj+".message"), (base+"."+newAttr), f=True)

    #when you delete, then run the whole proc again afterwards (to clean up the nums)
    cmds.deleteUI('zbw_mmChangeAttrUI', window=True)
    cmds.windowPref('zbw_mmChangeAttrUI', remove=True)
    cmds.deleteUI("mmRCListLayout")
    zbw_mmListCurrentMessages("mmListMessages")

def extrudeUI():
    if cmds.window("curveExtrudeWin", exists=True):
        cmds.deleteUI("curveExtrudeWin")

    w, h = 300, 220
    widgets["win"] = cmds.window("curveExtrudeWin", w=w, h=h)
    widgets["CLO"] = cmds.columnLayout(w=w, h=h)

    widgets["text1"] = cmds.text(l="Name the rig to be created:")
    cmds.separator(h=5)
    widgets["nameTFG"] = cmds.textFieldGrp(l="Rig Name: ", cal=[(1, "left"),(2, "left")],cw=[(1, 50),(2, 245)])
    cmds.separator(h=5)

    widgets["text2"] = cmds.text(l="Select the path curve.\nOptionally, "
                                   "then select profile crv and the cap rig in that order\n"
                                   "Note that cap rig and profile curve should be y up!", al="left")
    cmds.separator(h=5) 
    widgets["extrBut"] = cmds.button(l="Create Extrusion Rig!", w=300, h=35, bgc = (.4, .5,.4), c=prepExtrude)

    cmds.separator(h=10)    

    widgets["text3"] = cmds.text(l="Once you've attached a material :\nselect the control, then any place2DTexture nodes", al="left")
    cmds.separator(h=5) 
    widgets["textureBut"] = cmds.button(l="Connect Ctrl to place2DTexture nodes!", w=300, h=35, bgc = (.25, .35, .5), c = connectTexture)

    cmds.window(widgets["win"], e=True, w=w, h=h)
    cmds.showWindow(widgets["win"])

def import_anim_UI():
    width = 400

    if cmds.window("impAnimWin", exists=True):
        cmds.deleteUI("impAnimWin")

    widgets["win"] = cmds.window("impAnimWin", t="Import anim files", w=width, h=400, rtf=True)
    # widgets["clo"] = cmds.columnLayout()
    widgets["mainTLO"] = cmds.tabLayout()
    widgets["impCLO"] = cmds.columnLayout("Import Anim")
    cmds.text("1. choose the folder where your anim clips live,\n2. select the objs in scene to apply to\n3. 'random' will start anim in frame range\n4. select anim clips from list to randomly apply to objs\n5. press button to apply",al="left")
    cmds.separator(h=10)    
    widgets["impPathTFG"] = cmds.textFieldButtonGrp(l="Anim Path:", bl="<<<", cal = ([1, "left"], [2, "left"], [3, "right"]), cw=([1, 75], [2, 275], [3, 40]), bc=partial(get_path, "import", "impPathTFG"), cc=populate_tsl)
    widgets["randRBG"] = cmds.radioButtonGrp(l="Insert Placement:", nrb=2, l1="Random Start", l2="At current Frame", sl=1, cal=([1, "left"], [2,"left"], [3,"left"]), cw=([1,100], [2, 100], [3, 100]), cc=partial(toggle_enable, "randRBG", "rangeIFG"))
    widgets["rangeIFG"] = cmds.intFieldGrp(l="Random Start Range:", nf=2, v1=0, v2=100, cw=([1, 120], [2, 50], [3, 50]), cal=([1, "left"], [2, "left"], [3, "left"]))
    widgets["delCBG"] = cmds.checkBoxGrp(l="Delete subsequent keys?", v1=True, cal=([1, "left"], [2, "left"]), cw=([1, 130], [2, 20]))
    cmds.separator(h=10)    
    widgets["animTSL"] = cmds.textScrollList(w=400, h=150, allowMultiSelection=True)
    cmds.separator(h=10)    
    widgets["importBut"] = cmds.button(l="Import random anim from selection", h=40, w=width, bgc=(.5, .8, .5), c=import_animation)

    cmds.setParent(widgets["mainTLO"])
    widgets["expCLO"] = cmds.columnLayout("Export Anim")
    cmds.text("1. Select the obj 2. choose a path and name the anim\n3. choose range and hierarchy 4. press button!", al="left")
    cmds.separator(h=10)
    widgets["expPathTFG"] = cmds.textFieldButtonGrp(l="Export Path:", bl="<<<", cal = ([1, "left"], [2, "left"], [3, "right"]), cw=([1, 75], [2, 275], [3, 40]), bc=partial(get_path, "export", "expPathTFG"))
    widgets["nameTFG"] = cmds.textFieldGrp(l="Animation Name:", cw=([1, 100], [2, 250]), cal=([1, "left"], [2, "left"]))    
    widgets["selRBG"] = cmds.radioButtonGrp(l="Hierarchy:", nrb=2, l1="Selection Only", l2="Below", sl=2, cal=([1, "left"], [2,"left"], [3,"left"]), cw=([1,75], [2, 100], [3, 100]))
    widgets["expRngRBG"] = cmds.radioButtonGrp(l="Time Range:", nrb=2, l1="Start_End", l2="All", sl=2, cal=([1, "left"], [2,"left"], [3,"left"]), cw=([1,75], [2, 100], [3, 100]), cc=partial(toggle_enable, "expRngRBG", "expRngIFG"))
    widgets["expRngIFG"] = cmds.intFieldGrp(nf=2, en=False, l="Start_End", v1=1, v2=10, cal=([1, "left"], [2,"left"], [3,"left"]), cw=([1,75], [2, 100], [3, 100]))
    cmds.separator(h=10)    
    widgets["exportBut"] = cmds.button(l="Export anim from selection", h=40, w=width, bgc=(.5, .8, .5), c=export_animation)

    cmds.window(widgets["win"], e=True, w=5, h=5, rtf=True)
    cmds.showWindow(widgets["win"])

def wireRigUI (*args):
    if cmds.window("wireRigWin", exists = True):
        cmds.deleteUI("wireRigWin")

    widgets["win"] = cmds.window("wireRigWin", t="zbw_wireRig", w=300, h=250)
    widgets["mainCLO"] = cmds.columnLayout()

    widgets["topFLO"] = cmds.frameLayout(l="Convert Poly Edges",cll=True, cl=True)
    widgets["topCLO"] = cmds.columnLayout()
    widgets["convertBut"] = cmds.button(l="convert selected poly edge to curve", w=300, bgc = (.8,.8,0), c=convertEdge)
    cmds.separator(h=20, style="single")
    widgets["reverseBut"] = cmds.button(l="reverse direction of selected curve", w=300, bgc = (.8,.5,0), c=reverseCrv)

    cmds.setParent(widgets["mainCLO"])
    widgets["botFLO"] = cmds.frameLayout(l="Create Wire Rig", cll=True)
    widgets["botCLO"] = cmds.columnLayout()
    widgets["numCtrlIFG"] = cmds.intFieldGrp(l="Number of Ctrls:", v1=5, cal=[(1, "left"), (2, "left")], cw=[(1, 150),(3, 75)])
    widgets["hierCBG"] = cmds.checkBoxGrp(ncb=1, l1 = "Put Ctrls in hierarchy?", v1=True, en=True)
    widgets["nameTFG"] = cmds.textFieldGrp(l="Wire Rig Name:", w=300, tx="wireCtrl1", cal=[(1, "left")])
    widgets["scaleFFG"] = cmds.floatFieldGrp(l="Control scale:", v1=1.0, cal=[(1, "left"), (2, "left")], cw=[(1, 150),(3, 75)])

    cmds.separator(h=30, style="single")
    widgets["textText"] = cmds.text("Select geo, then curve, then button below", al="center")
    widgets["rigBut"] = cmds.button(l="Create Wire Rig", w= 300, h=40, bgc= (0, .5, 0), c=createWireDef)

    cmds.showWindow(widgets["win"])

#option to pull curve from edges