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

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 _create_ui(self):
        u"""UI???"""
        safe_delete_window(self._WINDOW_NAME)
        win = cmds.window(self._WINDOW_NAME, t="Convert Color Code", mb=True, w=480, h=128)
        cmds.menu(l="Option")
        cmds.menuItem(l="ColorEditor", c=self.get_color_from_editor)
        cmds.columnLayout(adj=True, rs=2)
        self.color_code_field = cmds.textFieldButtonGrp(l="Color code", bl="Convert", bc=self._convert)
        self.decimal_point_field = cmds.intFieldGrp(l="Decimal point", nf=1, v1=2)
        self.result_field = cmds.textFieldGrp(l="Result")

        cmds.setParent("..")

        cmds.columnLayout(adj=True)
        self.color_preview = cmds.text(l="", h=24)
        cmds.setParent("..")
        cmds.showWindow(win)

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 getScriptsUI(*args):

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

    widgets["win"] = cmds.window("thisWin", w=300, h=200)
    widgets["mainFLO"] = cmds.formLayout()

    widgets["list"] = cmds.textScrollList(nr=10, w=300, dcc = executeCommand)

    cmds.formLayout(widgets["mainFLO"], e=1, af = [(widgets["list"], "left", 0), (widgets["list"], "top", 0), (widgets["list"], "bottom", 30), (widgets["list"], "right", 0)])

    widgets["button"] = cmds.button(l="Refresh List!", w=300, h= 30, bgc = (.8, .6, .3), c= getScripts)
    cmds.formLayout(widgets["mainFLO"], e=1, af = [(widgets["button"], "left", 0), (widgets["button"], "right", 0), (widgets["button"], "bottom", 0)])

    cmds.showWindow(widgets["win"])

#populate the list with the contents of the path

def executeCommand(*args):
    item = cmds.textScrollList(widgets["list"], q=True, si=True)[0]
    #### here we should reference a dictionary of scriptName: code to execute script
    #### load our file from userprefs(?)

    # with open("/Bluearc/HOME/CHRLX/zwillie/Desktop/jsonTest.json" ,"w") as f:
    # json.dump(animals, f, sort_keys = True, indent=4)

    # with open("/Bluearc/HOME/CHRLX/zwillie/Desktop/jsonTest.json", "r") as f:
    #     data  = json.load(f)

    #if there is an item or items that AREN'T in the dictionary as keys, throw a warning and ask for the correct input--
    #separate function to add stuff to our dictionary and save it
    #BETTER - color code the item in the list as red and when clicked, bring up a window to enter the call for the script (and add to dict and save)

    #if the key exists (aka the script name), then execute the code (value) next to it

    #print out in the script editor (warning) which command your trying to run.
    #catch key errors - i.e. this script:command pair isn't registered in the fileName.json

    if (item.rpartition(".")[2] == "mel"):
        mel.eval(item.rpartition(".")[0])

    elif (item.rpartition(".")[2] == "py"):
        exec(pythonRun[item.rpartition(".")[0]])

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 snapUI():
    """simple snap UI for snapping"""

    if cmds.window("snapWin", exists=True):
        cmds.deleteUI("snapWin", window=True)
        cmds.windowPref("snapWin", remove=True)

    widgets["win"] = cmds.window("snapWin", t="zbw_snap", w=210, h=100, rtf=True)
    widgets["mainCLO"] = cmds.columnLayout(w=210, h=100)
    cmds.text("Select the target object(s),\nthen the object(s) you want to snap", al="center", w=210)
    cmds.separator(h=5, style="single")
    widgets["cbg"] = cmds.checkBoxGrp(l="Options: ", ncb=2, v1=1, v2=1, l1="Translate", l2="Rotate", cal=[(1,"left"),(2,"left"), (3,"left")], cw=[(1,50),(2,75),(3,75)])
    widgets["avgRBG"] = cmds.radioButtonGrp(nrb=2, l1="Snap all to first", l2="Snap last to avg", cal=[(1,"left"),(2,"left"),(3,"left")], cw=[(1,100),(2,100)],sl=1)
    widgets["rpCB"] = cmds.checkBox(l="Use Rotate Pivot To Query Position?", v=1)
    widgets["snapPivCB"] = cmds.checkBox(l="Snap via pivot? (vs. translate value)", v=1)
    cmds.separator(h=5, style="single")
    widgets["snapButton"] = cmds.button(l="Snap obj(s)!", w=210, h=40, bgc=(.6,.8,.6), c=partial(snapIt, False))
    widgets["snapPivButton"] = cmds.button(l="Snap pivot!", w=210, h=20, bgc=(.8,.6,.6), c=partial(snapIt, True))

    cmds.window(widgets["win"], e=True, w=5, h=5)
    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 setValues(*args):
    """sets the values from window on all selected objs for appropriate channels"""

    sel = cmds.ls(sl=True)

    attrs = cmds.checkBoxGrp(widgets["transCBG"], q=True, va3=True)
    trans = attrs[0]
    rots = attrs[1]
    scls = attrs[2]

    for obj in sel:
        if cmds.objectType(obj)=="transform":
            if trans:
                t = cmds.floatFieldGrp(widgets["trnFFG"], q=True, v=True)
                cmds.setAttr("{}.translate".format(obj), t[0], t[1], t[2])
            if rots:
                r = cmds.floatFieldGrp(widgets["rotFFG"], q=True, v=True)
                cmds.setAttr("{}.rotate".format(obj), r[0],r[1], r[2])
            if scls:
                s = cmds.floatFieldGrp(widgets["sclFFG"], q=True, v=True)
                cmds.setAttr("{}.scale".format(obj), s[0], s[1], s[2])

def dupeSwapUI():
    """UI for script"""

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

    cmds.window("dupeWin", t="zbw_dupeSwap", w=250, h=100)
    cmds.columnLayout("dupeCLO")
    cmds.text("Select the initial object. then select the", al="center", w=250)
    cmds.text("duplicates and press button", al="center", w=250)
    cmds.separator(h=5, style ="single")
    cmds.radioButtonGrp("inputsRBG", l="inputs:", nrb=3, l1="none", l2="connect", l3="duplicate", cw=[(1, 50), (2,47), (3,63), (4,40)], cal=[(1,"left"), (2,"left"), (3,"left"), (4,"left")], sl=1)
    cmds.separator(h=5, style ="single")

    cmds.button("dupeButton", l="Swap Elements", w=250, h=50, bgc=(.6, .8,.6), c=dupeIt)

    cmds.showWindow("dupeWin")
    cmds.window("dupeWin", e=True, w=250, h=100)

def changeValue(attr, slider, *args):

    value = cmds.floatSliderGrp(slider, q=True, v=True)
    cmds.setAttr(attr, value)

# def focusToCamera():

    #get camera from focus window
    # panel = cmds.getPanel(wf=True)
    # cam = cmds.modelEditor(panel, q=True, camera=True)

#----------get camera from focus . . .
#----------have camera list to select from . . .

# (coverageX)
# (coverageY)

def finish(self):
        '''
        Finalize the UI
        '''

        mc.setParent(self.form)

        frame = mc.frameLayout(labelVisible=False)
        mc.helpLine()

        mc.formLayout( self.form, edit=True,
                       attachForm=((self.column, 'top', 0), (self.column, 'left', 0),
                                   (self.column, 'right', 0), (frame, 'left', 0),
                                   (frame, 'bottom', 0), (frame, 'right', 0)),
                       attachNone=((self.column, 'bottom'), (frame, 'top')) )

        mc.showWindow(self.name)
        mc.window(self.name, edit=True, width=self.width, height=self.height)

def about(self, *args):
        '''
        This pops up a window which shows the revision number of the current script.
        '''

        text='by Morgan Loomis\n\n'
        try:
            __import__(self.module)
            module = sys.modules[self.module]
            text = text+'Revision: '+str(module.__revision__)+'\n'
        except StandardError:
            pass
        try:
            text = text+'ml_utilities Rev: '+str(__revision__)+'\n'
        except StandardError:
            pass

        mc.confirmDialog(title=self.name, message=text, button='Close')

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 show(self):
        if cmds.window(self.windowName, query=True, exists=True):
            self.close()

        cmds.window(self.windowName)
        self.buildUI()
        cmds.showWindow()

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 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 createAndShow(cls):
        cls.deleteInstances()
        window = cls()
        window.show()
        return window

def exists(cls):
        """
        Return True if an instance of this window exists
        """
        result = False
        if cmds.workspaceControl(cls.getWorkspaceControlName(), q=True, ex=True):
            result = True
        if cmds.workspaceControl(cls.getWorkspaceControlName(), q=True, ex=True):
            result = True
        if cmds.window(cls.OBJECT_NAME, q=True, ex=True):
            result = True
        return result

def __init__(self):
        u"""initialize"""
        self.window = None
        self.text_field = None
        self.text_scroll = None

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 show(self):
        u"""Window???"""
        self.safe_delete_ui(RecentFileWindow._WINDOW_NAME)

        cmds.window(RecentFileWindow._WINDOW_NAME, title=RecentFileWindow._WINDOW_TITLE)
        cmds.frameLayout(label="RecentFiles",
                         marginWidth=6,
                         marginHeight=6,
                         borderStyle="etchedIn")

        for file_path, file_type in get_recent_files().items():
            cmds.button(label=file_path, c=partial(self._open_file, file_path, file_type))
        cmds.showWindow(RecentFileWindow._WINDOW_NAME)

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 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 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 action(self, close, *args):
        ############ modify for inheritence #############
        #do the action here

        #close window
        if close:
            self.closeWindow()
        pass

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

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 resize_window(*args):
    cmds.window(widgets["win"], e=True, rtf=True, w=100, h=100)

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 doSel(*args):
    """pass values from window"""
    #get value from win
    keepNum = cmds.intFieldGrp(widgets["keepIFG"], q=True, v1=True)
    #get type of sel to
    typeNum = cmds.radioButtonGrp(widgets["typeRBG"], q=True, sl=True)
    #pass info to corresponding func
    if typeNum == 1:
        randRemovePercent(keepNum)
    if typeNum == 2:
        preciseRemovePercent(keepNum)

def zbw_offsetAnim(*args):
    """creates offset from first obj sel to last based on the entered offset value"""
    def zbw_runOffsetAnim(*args):
        #get frame range!!!!!!
        #get selection, check that they are tranforms
        sel = cmds.ls(sl=True,type="transform")
        selSize = int(len(sel))
        #for each selection mult the index by the offset value
        for i in range(0,selSize):
            obj = sel[i]
            offsetRaw = cmds.intFieldGrp('zbw_offsetValue', q=True, v=True)
            offset = offsetRaw[0]
            multFactor = i * offset
            #shift the entire anim curve by the offset mult value
            cmds.keyframe(obj, edit=True,relative=True,timeChange=multFactor,time=(1,24))

    #create UI, get offset value, frame range or all anim
    if (cmds.window('zbw_offsetAnimUI', exists=True)):
        cmds.deleteUI('zbw_offsetAnimUI', window=True)
        cmds.windowPref('zbw_offsetAnimUI', remove=True)
    window=cmds.window('zbw_offsetAnimUI', widthHeight=(350,200), title='zbw_offsetAnim')
    cmds.columnLayout(cal='center')
    cmds.intFieldGrp('zbw_offsetValue', cal=(1,'left'), label='frequency(frames)', value1=5)
    #CREATE FRAME RANGE AREA (WHICH FRAMES ARE WE DOING?)
    #WHEN THAT HAPPENS, WHAT DO WE DO WITH THE FRAMES AFTER THAT? (PROBABLY NOTHING. . . LET USER WORRY ABOUT IT)
    #checkbox for random freq (to give a random amount to offset each object)
    #cmds.checkBoxGrp('zbw_animNoiseRandom', cal=(1,'left'), cw=(1, 175),label='random frequency on', value1=0, cc=zbw_animNoiseRandom)
    cmds.button('zbw_offsetAnimGo', label='offset!', width=75, command=zbw_runOffsetAnim)

    cmds.showWindow(window)

#clean up keys

def resizeWindow(*args):
    cmds.window(widgets["win"], e=True, rtf=True, w=100, h=100)

def calculatePts(crv, *args):
    """
    uses the window to get the number of pts that should be in the curve
    """
    cLen = cmds.arclen(crv, ch=False)
    perUnit = cmds.intFieldGrp(widgets["recoIFBG"], q=True, v1=True)
    total = cLen * perUnit

    return total

def rebuildCurve(curve, *args):
    """ 
        rebuilds selected curves to specs in window
    """
    num = calculatePts(curve)
    newCrv = cmds.rebuildCurve(curve, rebuildType=0, ch=1, spans=num, keepRange=0, replaceOriginal=0,
                               name="{0}_RB".format(curve))
    cmds.setAttr("{0}.v".format(curve), 0)

    return newCrv

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 zbw_mmChangeConnectObj(base, attr, obj, *args):
    #get that from the text field
    newObj = cmds.textFieldGrp("zbw_mmChangeObjTFBG", q=True, tx=True)
    #create connection to obj in new attr
    cmds.connectAttr((newObj+".message"), attr, f=True)

    #delete this window, delete mmRCListLayout and call the list again
    cmds.deleteUI('zbw_mmChangeObjUI', window=True)
    cmds.windowPref('zbw_mmChangeObjUI', remove=True)
    cmds.deleteUI("mmRCListLayout")
    zbw_mmListCurrentMessages("mmListMessages")

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"])