Beispiel #1
0
    def __init__(self):

        self.uiCmd = AssignPsd_uiCmd( self )

        if cmds.uiTemplate( 'worldBasePsdTemplate', exists=True ):
            cmds.deleteUI( 'worldBasePsdTemplate', uiTemplate=True )
            
        template = cmds.uiTemplate( 'worldBasePsdTemplate' )
        cmds.text( defineTemplate=template, l='' )

        if cmds.window( "assignPsd_ui", ex=1 ):
            cmds.deleteUI( "assignPsd_ui" )
        
        self.win = cmds.window( "assignPsd_ui", title="Assign   UI" )

        cmds.columnLayout()
        
        cmds.setUITemplate( template, pushTemplate=True )
        
        cmds.rowColumnLayout( nc=3, cw=[(1,120),(2,120),(3,60)] )
        cmds.text( l='Blend Shape Controler' )
        self.txf = cmds.textField()
        cmds.popupMenu()
        cmds.menuItem( l='Load Selected', c=self.uiCmd.loadSel )
        cmds.button( l='Select', c= self.uiCmd.selControlCmd )
        cmds.setParent( '..' )
        
        cmds.text(h=10)
        
        cmds.rowColumnLayout( nc=3, cw=[(1,50),(2,200),(3,50)] )
        cmds.text()
        cmds.button( l="Assign BlendShape", c=self.uiCmd.assignCmd, h=25 )
        cmds.text()
        cmds.setParent( '..' )
        
        cmds.text()
        cmds.rowColumnLayout( nc=1, cw=(1,300) )
        cmds.separator()
        cmds.setParent( '..' )
        cmds.text()
        
        cmds.rowColumnLayout( nc=3, cw=[(1,50),(2,200),(3,50)] )
        cmds.text()
        self.fixModeButton = cmds.button( l="", h=25 )
        self.fixModeButton_condition()
        cmds.text()
        cmds.setParent( '..' )
        cmds.text()
        
        '''
        cmds.rowColumnLayout( nc=1, cw=( 1,300 ) )
        self.scroll = cmds.textScrollList()
        '''
        
        cmds.window( self.win, e=1, wh=( 305, 150 ) )
        cmds.showWindow( self.win )
        
        cmds.setUITemplate( template, popTemplate=True )
        
        self.scriptJobSetting()
Beispiel #2
0
    def __init__(self, attrName, width ):
        
        width = width
        deltaName = cmds.getAttr( attrName+'.deltaName' )
        value = cmds.getAttr( attrName+'.weight' )
        
        nameWidth  = 140
        fieldWidth = 70
        sliderWidth = width - nameWidth - fieldWidth 
        self._row  = cmds.rowColumnLayout( nc=3, cw=[(1,nameWidth),(2,fieldWidth),(3,sliderWidth)], 
                                           co=[(1,'left',8 ), (2,'right',5)], h=30 )
        self._textRow = cmds.rowColumnLayout( nc=1, cw=[(1,nameWidth-15)] )
        self._textRowPopup = cmds.popupMenu( mm=1 )
        self._text = cmds.text( al='left', h=20 )
        cmds.setParent( '..' )
        self._field = cmds.floatField( min=0.0, max=1.0 )
        self._fieldPopup = cmds.popupMenu()
        self._slider = cmds.floatSlider( min=0.0, max=1.0 )
        cmds.setParent( '..' )
        
        cmds.text( self._text, e=1, l=deltaName )
        cmds.floatField( self._field, e=1, v=value )
        cmds.floatSlider( self._slider, e=1, v=value )

        self._dragStart = False
        self._keepValue = 0.0
        self._attrName = attrName
        
        cmds.menuItem( l='Select Anim Curve', rp='W', c= self.selectAnimCurveCmd, p=self._textRowPopup )
        cmds.menuItem( l='Change Name', rp='E', c= self.changeNameMoveCmd, p=self._textRowPopup )
        cmds.menuItem( l='Delete Shape', rp='S', c= self.deleteShapeCmd, p=self._textRowPopup )
        #cmds.menuItem( l='Edit Mesh', rp='N', c=self.editMeshCmd, p=self._textRowPopup )
        
        cmds.menuItem( l='Set Key', c= self.setKeyCmd, p=self._fieldPopup )
        cmds.menuItem( l='Break Connection', c= self.breakConnectionCmd, p=self._fieldPopup )
Beispiel #3
0
def createInfinityMM():
	# pmn = 'graphEditor1GraphEdanimCurveEditorMenu' # standard rmb popupmenu
	gEd = 'graphEditor1GraphEd' # graph editor name
	if not m.control( gEd, ex=1 ):
		print ('the graph editor: ' + str(gEd) + ' does not (yet) exist!! :/')
		return
	# our new popup
	pup = 'tweakGraphEditPopup'
	if not m.popupMenu( pup, ex=1 ):
		m.popupMenu( pup, parent=gEd, markingMenu=1, ctrlModifier=1 )

	m.popupMenu( pup, edit=1, deleteAllItems=1 )
	m.setParent( pup, menu=1 )

	# display infinities checkbox
	cmd = 'from maya.cmds import animCurveEditor; animCurveEditor( "' +gEd+ '", e=1, displayInfinities=int(not animCurveEditor( "' +gEd+ '", q=1, displayInfinities=1 )) )'
	m.menuItem( 'displayInfinitiesMenuItem', label='Display Infinities', checkBox=m.animCurveEditor( gEd, q=1, displayInfinities=1 ), c=cmd, radialPosition='N' )

	m.menuItem( 'preInfinityMenuItem', label='< Pre Infinity', subMenu=True, parent=pup ) # radialPosition='W'
	m.menuItem( 'postInfinityMenuItem', label='Post Infinity >', subMenu=True, parent=pup ) # , radialPosition='E'
	m.menuItem( 'bothInfinityMenuItem', label='< Both Infinity >', subMenu=True, parent=pup ) # , radialPosition='S'

	infType = ['cycle', 'linear', 'constant', 'cycleRelative', 'oscillate']
	itemList = ['preInfinityMenuItem', 'postInfinityMenuItem', 'bothInfinityMenuItem']
	for i in range(3):
		for type in infType:
			cmd = 'from maya.cmds import setInfinity;'
			if i != 0:
				cmd += 'setInfinity( poi="' + type + '" );'
			if i != 1:
				cmd += 'setInfinity( pri="' + type + '" );'
			m.menuItem( label=type, parent=itemList[i], c=cmd )
Beispiel #4
0
 def __init__( self, parentUi, sels ):
     self.sels = sels
     self.mainCmd = allCtlsCmd.CTL()
     cmds.popupMenu( 'locusChrigPopup', e=1, deleteAllItems=1 )
     self.mirrorType = 'object'
     self.parentUi = parentUi
     self.radialPosList = [ "N", "NE", "E", "SE", "S", "SW", "W", "NW" ]
Beispiel #5
0
 def addMirrorMeshCmd(self, logicalIndex, *args ):
     
     items = cmds.textScrollList( globalInfo.meshInfoInst._selMeshList, q=1, ai=1 )
     
     if not items: return None
     
     nodeName = amCmd.getBlendAndFixedShapeNode( items[0] )
     targetName, driverInfo, returnIndex = amCmd.addMirrorTarget( items[0], logicalIndex )
     
     cmds.setParent( self._scrollLay )
     cmds.rowColumnLayout( nc=3, cw=[(1,25),(2,self._mainWidthList[0]-30),(3,self._mainWidthList[1]-30) ] )
     cmds.button( l="X", c= partial( self.removeBlendMeshInfoElement, nodeName, logicalIndex ) )
     meshNameField = cmds.textField( tx=targetName.replace( items[0]+'_', '' ), cc=partial( self.meshNameChangeCmd, nodeName, returnIndex ) )
     self._meshNameList.append( meshNameField )
     cmds.popupMenu( markingMenu = 1 )
     cmds.menuItem( l='Edit Anim Curve', rp='W', c=partial( self.editAnimCurveCmd, nodeName, returnIndex ) )
     cmds.menuItem( l='Edit Mesh',rp='N', c=partial( self.editAssigned, returnIndex) )
     cmds.menuItem( l='Add Mirror Mesh',rp='E', c=partial( self.addMirrorMeshCmd, returnIndex) )
     cmds.menuItem( l='Select Delta Points', rp='S', c=partial( self.selectDeltaPointsCmd, items[0], logicalIndex ) )
     widthList = uifnc.setWidthByPerList( [50,50], self._mainWidthList[1] )
     cmds.rowColumnLayout( nc=2, cw=[(1,widthList[0]),(2,widthList[1]-30)] )
     for element in driverInfo:
         engleName, value1, value2, value3= element
         cmds.text( l= engleName )
         cmds.floatFieldGrp( precision=2, nf=3, cw3=[50,50,50], v1=value1, v2=value2, v3=value3 )
     cmds.setParent( '..' )
def postMenuCommand(*args):
    """
    This function is passed to, and executed by the menu created via makePopup()
    whenever the popupMenu is shown.  It's what you'd update to have custom menu
    items appear based on what's selected.
    """
    # Delete all the items from any pre-existing menus:
    if mc.popupMenu(POP_NAME, exists=True):
        mc.popupMenu(POP_NAME, edit=True, deleteAllItems=True)

    # Make our menu the current menu for any new children:
    mc.setParent(POP_NAME, menu=True)
    if mc.dagObjectHit():  # undocumented command!
        # If the user has Alt+RMB'd over a node, capture the return of the
        # function that overrides the dagMenuProc's popupMenu.  The return is
        # the full name of the node that has been Alt+RMB'd over... and use it as
        # the label for the menu.  Extract the leaf name from the full path:
        fullObjectName = eval('overrideDagMenuProc()')
        leafObjectName = fullObjectName.split("|")[-1]
        mc.menuItem(label=leafObjectName)

        # Here, any custom code can be authored that is based on the object name
        # For example, track if there are any highlighted components:
        componentPreSelect = mc.ls(preSelectHilite=True)

        if len(componentPreSelect):
            mc.menuItem(divider=True)
            mc.menuItem(label=componentPreSelect[0])
    else:
        # Otherwise, no thing Alt+RMB'd on:
        mc.menuItem(label="No object under cursor")
Beispiel #7
0
 def create(self):
     
     if cmds.window( self.winName, ex=1 ):
         cmds.deleteUI( self.winName, wnd=1 )
     cmds.window( self.winName, title= self.title )
     
     cmds.columnLayout()
     columnWidth = self.width - 2
     firstWidth  = ( columnWidth -2 )* 0.23
     secondWidth = ( columnWidth -2 ) - firstWidth
     cmds.rowColumnLayout( nc=1, cw=[(1,columnWidth)] )
     cmds.text( l='', h=5 )
     fd_cutName = cmds.textFieldGrp( l='Cut Path : ', cw=[(1,firstWidth),(2,secondWidth)],
                                     cc=self.cmdChangeCutName )
     pu_cutName = cmds.popupMenu()
     cmds.text( l='', h=5 )
     cmds.separator()
     cmds.text( l='', h=5 )
     
     fd_sceneName = cmds.textFieldGrp( l='Scene Path : ', cw=[(1,firstWidth),(2,secondWidth)],
                                     cc=self.cmdChangeSceneName )
     pu_sceneName = cmds.popupMenu()
     
     cmds.window( self.winName, e=1,
                  w = self.width, h = self.height )
     cmds.showWindow( self.winName )
     
     self.fd_cutName = fd_cutName
     self.pu_cutName = pu_cutName
 def modifySubdivisions(*args):
     if cmds.objExists("CMForegroundPlane"):
         if cmds.window("SubdivisionsTextWindow", query = True, exists = True):
             cmds.deleteUI("SubdivisionsTextWindow")
         
         SubdivisionTextClass.UpdateSubSnap()
 
         if os.path.exists(SubdivisionTextClass.ImagePath):
             
             cmds.window( "SubdivisionsTextWindow", title = "Subdivisions Text" )
             cmds.formLayout("SubWriterLayout", numberOfDivisions=100, w = 740, h = 400)
             cmds.picture( "BasePicture", image = SubdivisionTextClass.ImagePath )
             
             cmds.editRenderLayerGlobals( currentRenderLayer = "Subdivision_0")
             SubdivisionTextClass.subColor = cmds.getAttr("CMForegroundPlane.imageName")[-5]
             cmds.editRenderLayerGlobals( currentRenderLayer = "defaultRenderLayer")
             
             
             cmds.window( "SubdivisionsTextWindow", edit = True, w = 740, h = 400)
             
             #Create popupMenu for images 
             cmds.popupMenu( "SubdivisionPopUp", parent = "BasePicture" )
             cmds.menuItem( label='TopLeft'    , p = "SubdivisionPopUp", c = functools.partial(SubdivisionTextClass.ChangePos,  "lt") )  
             cmds.menuItem( label='TopRight'   , p = "SubdivisionPopUp", c = functools.partial(SubdivisionTextClass.ChangePos,  "rt") ) 
             cmds.menuItem( label='BottomLeft' , p = "SubdivisionPopUp", c = functools.partial(SubdivisionTextClass.ChangePos,  "lb") ) 
             cmds.menuItem( label='BottomRight', p = "SubdivisionPopUp", c = functools.partial(SubdivisionTextClass.ChangePos,  "rb") )
             cmds.menuItem( label='ToggleColor', p = "SubdivisionPopUp", c = SubdivisionTextClass.toggleSubdivisionColour )
             cmds.showWindow("SubdivisionsTextWindow")
     else:
         cmds.confirmDialog(m = "The signature camera must be created before running this tool")
Beispiel #9
0
 def remapNamespaces(self, *args):
     winName = "remapNamespacesWindow"
     if cmds.window(winName, query=True, exists=True): cmds.deleteUI(winName)
     window = cmds.window( winName, title = "Remap Namespaces")
 
     cmds.columnLayout(adjustableColumn=True)
     cmds.rowColumnLayout( numberOfColumns=3)
     
     animData            = aToolsMod.loadInfoWithUser("copyPasteAnim", "animData")
     inputNameSpaces     = list(set(utilMod.getNameSpace(animData["objects"])[0]))
     outputNameSpaces    = utilMod.listAllNamespaces()
     
     for loopNameSpace in inputNameSpaces:  
         
         nameSpace = loopNameSpace[:-1]
         
         eval("cmds.text('input%s', align='right', w=150, h=26, label='%s:   ')"%(nameSpace, nameSpace))
         eval("cmds.textField('output%s', w=150, h=26, text='%s')"%(nameSpace, nameSpace))
         eval("cmds.button('output%s', w=26, h=26, label='...')"%(nameSpace))
         if outputNameSpaces:
             cmds.popupMenu(button=1)
             for loopOutput in outputNameSpaces:
                 cmds.menuItem       ("menu%s"%loopOutput, label=str(loopOutput), command=lambda x, loopOutput=loopOutput, nameSpace=nameSpace, *args: self.setOutputValue(loopOutput, nameSpace))    
     
     cmds.setParent( '..' )
     
     
     cmds.button(label="Paste Animation in Place",     command=lambda *args: self.remapAndPasteAnimation(animData, inputNameSpaces, pasteInPlace=True))
     cmds.button(label="Paste Original Animation",     command=lambda *args: self.remapAndPasteAnimation(animData, inputNameSpaces, pasteInPlace=False))
     
     cmds.showWindow( window )
Beispiel #10
0
	def show( self ) :
		
		if mc.window( self.win , exists=True ) :
			mc.deleteUI( self.win )
		
		mc.window( self.win , t='pkControlMaker' , rtf=True )
		
		mc.columnLayout( '%sMainCL'%self.ui , adj=True )
		
		mc.button( '%sCurveBUT'%self.ui , l='plus' , w=50 , h=100 , c=partial( self.createCurve ) )
		
		mc.popupMenu()
		
		labels = ( 'plus' , 'crossArrow' , 'circle' , 'cube' ,
			'capsule' , 'stick' , 'doubleStick' , 'square' )
		
		for label in labels :
			mc.menuItem( l=label , c=partial( self.changeButLabel , label ) )
		
		nc = 6
		wid = 180
		cw = ( wid / nc )
		mc.rowLayout( numberOfColumns=nc , columnWidth6=(cw,cw,cw,cw,cw,cw) )
		mc.button( w=cw , l='N' , c=partial(self.assignColor,'none') )
		mc.button( w=cw , l='R' , bgc=[1,0,0] , c=partial(self.assignColor,'red') )
		mc.button( w=cw , l='G' , bgc=[0,1,0] , c=partial(self.assignColor,'green') )
		mc.button( w=cw , l='B' , bgc=[0,0,1] , c=partial(self.assignColor,'blue') )
		mc.button( w=cw , l='Y' , bgc=[1,1,0] , c=partial(self.assignColor,'yellow') )
		mc.button( w=cw , l='W' , bgc=[1,1,1] , c=partial(self.assignColor,'white') )
		
		mc.showWindow( self.win )
		mc.window( self.win , e=True , w=wid+8 )
		mc.window( self.win , e=True , h=150 )
    def __init__(self):
        """
		Initializes the pop up menu class call
		"""
        self.optionVars = []
        self.IsClickedOptionVar = OptionVarFactory("cgmVar_IsClicked", "int", 0)
        self.mmActionOptionVar = OptionVarFactory("cgmVar_mmAction", "int", 0)

        self.setupVariables()

        panel = mc.getPanel(up=True)
        if panel:
            # Attempt at fixing a bug of some tools not working when the pop up parent isn't 'viewPanes'
            if "MayaWindow" in mc.panel(panel, q=True, ctl=True):
                panel = "viewPanes"

        sel = search.selectCheck()

        self.IsClickedOptionVar.set(0)
        self.mmActionOptionVar.set(0)

        if mc.popupMenu("cgmMM", ex=True):
            mc.deleteUI("cgmMM")

        if panel:
            if mc.control(panel, ex=True):
                try:
                    mc.popupMenu(
                        "cgmMM", ctl=0, alt=0, sh=0, mm=1, b=1, aob=1, p=panel, pmc=lambda *a: self.createUI("cgmMM")
                    )
                except:
                    guiFactory.warning("cgm.setMenu failed!")
Beispiel #12
0
def showUI():
    win = 'lsWireOffset_window'
    
    # if window exists, delete
    if mc.window(win, ex=True):
        mc.deleteUI(win, wnd=True)
        
    # delete window prefs... if you want...
    mc.windowPref(win, remove=True)
    
    # create window
    mc.window(win, t='lsWireOffset v0.1', wh=(200,335), mxb=False)
    
    # main column
    mainCol = mc.columnLayout(columnAttach=('both', 5), rowSpacing=10, columnWidth=200)
    
    # creation frame
    createFrm = mc.frameLayout(p=mainCol, cl=False, l='Create New Module')
    createCol = mc.columnLayout(columnAttach=('both', 5), rowSpacing=5, columnWidth=188)
    nameTxtFld = mc.textFieldGrp( label='Name: ', text='', cw2=(40,125), p=createCol)
    mc.text(l='Select edge loop OR \n vertices and...')
    creationBtn = mc.button(l='Create', c="lsWireOffset.ui.createNew('%s')"%nameTxtFld)
    
    # edit frame
    editFrm = mc.frameLayout(p=mainCol, cl=False, l='Edit Existing Modules')
    editCol = mc.columnLayout(columnAttach=('both', 5), rowSpacing=5, columnWidth=188)
    scrollList = mc.textScrollList(win+'_wTSL')
    
    refreshTSL(scrollList)
    
    # popop menu for right click
    mc.popupMenu(win+'_wTSL_MM', p=scrollList, mm=True, button=3, pmc=buildMM)
    
    mc.showWindow(win)
def popAnimMenu( tsl ):
	'''
	Function that updates the popupMenu to list and delete only the current numer of indexes on an animation curve
	'''
	
	# query selected item from the textScrollList
	selItem = cmds.textScrollList( tsl, q=True, selectItem=True )
	
	# query number of keyframes in animation curve
	animSize = cmds.keyframe( selItem[0], query=True, keyframeCount=True )
	
	
	# delete all the items from the popupMenu
	cmds.popupMenu( animIndexMenu, e=True, deleteAllItems=True )
	
	# add the universal items to the popupMenu
	cmds.menuItem( label="Del Index:", parent=animIndexMenu )
	cmds.menuItem( divider=True, parent=animIndexMenu )
	
	# declare counter
	i=0
	
	# add the required number of items to the popupMenu based on the index numbers from the animation curve
	while ( i < animSize ):
		
		#cmds.menuItem( label=str(i), parent=animIndexMenu, c=scriptName + ".delAnimIndex(%s, '%s')" %(i, dTSL.getName() ) )
		cmds.menuItem( label=str(i), parent=animIndexMenu, c= Callback( delAnimIndex, i, tsl ) )
		
		# increment counter
		i+=1
	def __init__( self ):
		baseMelUI.BaseMelWindow.__init__( self )

		mel.zooVisManUtils()
		mel.zooVisInitialSetup()

		self.setSceneChangeCB( self.populate )
		self.UI_form = cmd.formLayout(docTag=0)
		self.UI_check_state = cmd.checkBox(v=self.state(), al="left", l="turn ON", cc=self.on_state_change)
		self.UI_button_marks = cmd.button(l="bookmarks")
		self.UI_tsl_sets = cmd.textScrollList(ams=1, dcc=self.on_collapse, nr=18, sc=self.on_select)

		self.POP_marks = cmd.popupMenu(p=self.UI_button_marks, b=1, aob=1, pmc=self.popup_marks)
		self.POP_marks_sh = cmd.popupMenu(p=self.UI_button_marks, sh=1, b=1, aob=1, pmc=self.popup_marks_add)
		self.POP_sets = cmd.popupMenu(p=self.UI_tsl_sets, b=3, pmc=self.popup_sets)

		self.reparentUI = None

		cmd.formLayout(self.UI_form, e=True,
				   af=((self.UI_check_state, "top", 3),
					 (self.UI_check_state, "left", 3),
					 (self.UI_button_marks, "top", 0),
					 (self.UI_button_marks, "right", 0),
					 (self.UI_tsl_sets, "left", 0),
					 (self.UI_tsl_sets, "bottom", 0)),
				   ac=((self.UI_button_marks, "left", 5, self.UI_check_state),
					 (self.UI_tsl_sets, "top", 0, self.UI_button_marks)),
				   ap=((self.UI_tsl_sets, "right", 0, 100)) )

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

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

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

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

    # Show Window
    cmds.showWindow(locParticleUI)
 def popupSetting(self):
     
     popupFieldMesh = cmds.popupMenu( p = self.field_mesh.txf )
     sgBFunction_ui.updatePathPopupMenu( self.field_mesh.txf, popupFieldMesh )
     
     popupFieldUV   = cmds.popupMenu( p = self.field_uv.txf )
     sgBFunction_ui.updatePathPopupMenu( self.field_uv.txf, popupFieldUV )
Beispiel #17
0
 def createLayout(self):     
    
     mainLayout = cmds.rowLayout(numberOfColumns=6, parent=self.parentLayout)
     
     #manipulator orientation
     #cmds.iconTextButton("manipOrientButton", style='textOnly',  label='-', h=self.hb, annotation="Selected objects", command=updateManipOrient)  
     #launchManipOrient()
     
     self.autoSmartSnapKeys       = AutoSmartSnapKeys()
     self.selectionCounter        = SelectionCounter()
       
     #selection        
     cmds.iconTextButton("selectionCounterButton", style='textOnly', font="smallPlainLabelFont", label='0', h=self.hb, annotation="Selected objects")  
     cmds.popupMenu("selectionCounterButtonMenu", button=1, postMenuCommand=self.selectionCounter.populateMenu)      
     
     #animation crash recovery
     cmds.image("animationCrashRecoveryLed", w=14, h=14, annotation="Test")  
             
     #menu
     cmds.iconTextButton(style='iconOnly',   w=self.wb, h=self.hb, image= uiMod.getImagePath("aTools"), highlightImage= uiMod.getImagePath("aTools copy"), annotation="aTools Menu")
     self.popUpaToolsMenu()
      
     self.update = Update()
     self.update.about = self.about
     self.update.checkUpdates(self, mainLayout)
  
     # set default config and startup scripts
     self.setDefaultConfig() 
 def menu_item_comments(self, *args):
     cmds.popupMenu(parent=self.mainScroll)
     for comment in self.comments:
         if comment == 'Custom':
             cmds.menuItem(l=comment, c=self.create_comment)
         else:
             cmds.menuItem(l=comment, c=pm.Callback(self.adding_text, comment))
Beispiel #19
0
	def __init__(self):	
		"""
		Initializes the pop up menu class call
		"""
		self.optionVars = []
		IsClickedOptionVar = OptionVarFactory('cgmVar_IsClicked', 0)
		mmActionOptionVar = OptionVarFactory('cgmVar_mmAction',0)			
		
		panel = mc.getPanel(up = True)
		if panel:
			# Attempt at fixing a bug of some tools not working when the pop up parent isn't 'viewPanes'
			if 'MayaWindow' in mc.panel(panel,q = True,ctl = True):
				panel = 'viewPanes'
			
		sel = search.selectCheck()
		
		IsClickedOptionVar.set(0)
		mmActionOptionVar.set(0)
		
		if mc.popupMenu('cgmMM',ex = True):
			mc.deleteUI('cgmMM')
			
		if panel:
			if mc.control(panel, ex = True):
				try:
					mc.popupMenu('cgmMM', ctl = 0, alt = 0, sh = 0, mm = 1, b =1, aob = 1, p = panel,
						         pmc = lambda *a: self.createUI('cgmMM'))
				except:
					guiFactory.warning('Exception on set key marking menu')
					mel.eval('performSetKeyframeArgList 1 {"0", "animationList"};')		
	def setupCtrlEnv(self):
		# Loop through all the controls
		for i, row in self.charSel.rows.items():
			for m, ctrl in enumerate( row ):
				if( type(ctrl) != list):
					if( ctrl.ctrlType == "ctrl" or ctrl.ctrlType == "chk" ):
						# self.ctrls[self.charSel.rows[i][m]] = "It's a control"   # Temp for setting up the control
						self.ctrls[ctrl.fileName] = [[], None]
						ctrl.setCommand( Callback(self.ctrlSystem, ctrl.fileName ) )
						pop = cmds.popupMenu( parent=ctrl.gui )
						rbCol = cmds.radioMenuItemCollection( parent=pop)
						cmds.menuItem(label="Rotate", cl=rbCol, rb=False, c=Callback( self._setSwitch, ctrl.fileName, "rotate" ))
						cmds.menuItem(label="Translate", cl=rbCol, rb=False, c=Callback( self._setSwitch, ctrl.fileName, "trans" ))
						cmds.menuItem( divider=True )
						cmds.menuItem(label="None", cl=rbCol, rb=True, c=Callback( self._setSwitch, ctrl.fileName, None ))
				elif( type(ctrl) == list):	
					for subCol in range( 0, len(ctrl)):
						if(ctrl[subCol].ctrlType == "ctrl" or ctrl[subCol].ctrlType == "chk" ):
							self.ctrls[ctrl[subCol].fileName] = [[], None]
							ctrl[subCol].setCommand( Callback(self.ctrlSystem, ctrl[subCol].fileName ) )
							pop = cmds.popupMenu( parent=ctrl[subCol].gui )
							rbCol = cmds.radioMenuItemCollection( parent=pop)
							cmds.menuItem(label="Rotate", cl=rbCol, rb=False, c=Callback( self._setSwitch, ctrl[subCol].fileName, "rotate" ))
							cmds.menuItem(label="Translate", cl=rbCol, rb=False, c=Callback( self._setSwitch, ctrl[subCol].fileName, "trans" ))
							cmds.menuItem( divider=True )
							cmds.menuItem(label="None", cl=rbCol, rb=True, c=Callback( self._setSwitch, ctrl[subCol].fileName, None ))							
    def addBaseBtn(s, joint, parent):

        def addNew():
            s.setAttr(joint, POSITION)
            s.setAttr(joint, ROTATION)
            s.setAttr(joint, SCALE)

        def addExisting():
            if position: s.setAttr(joint, POSITION, [position])
            if rotation: s.setAttr(joint, ROTATION, [rotation])
            if scale: s.setAttr(joint, SCALE, [scale])

        position = joint.get(POSITION, "")
        rotation = joint.get(ROTATION, "")
        scale = joint.get(SCALE, "")
        position = position if cmds.objExists(position) else None
        rotation = rotation if cmds.objExists(rotation) else None
        scale = scale if cmds.objExists(scale) else None

        btn = joint.btn["joint"] = cmds.button(
            h=30,
            bgc=COLOUR["blue"],
            l=shorten(joint.name),
            p=parent,
            c=Callback(addNew)
            )
        cmds.popupMenu(p=btn)
        if position or rotation or scale:
            cmds.menuItem(l="Use existing targets", c=Callback(addExisting))
        else:
            cmds.menuItem(l="Select a target to pick it", en=False)
Beispiel #22
0
 def create(self):
     
     form = cmds.formLayout()
     text  = cmds.text( l= self._label, al='right', h=20, width = self._textWidth )
     field = cmds.textField(h=21)
     cmds.popupMenu()
     cmds.menuItem( l=self._popup, c=self.cmdPopup )
     
     cmds.formLayout( form, e=1,
                      af=[(text,'top',0), (text,'left',0),
                          (field,'top',0),(field,'right',0)],
                      ac=[(field, 'left', 0, text)] )
     
     if self._position:
         cmds.formLayout( form, e=1,
                          ap=[(text,'right',0,self._position)])
         
     cmds.setParent( '..' )
     
     self._text = text
     self._field = field
     self._form = form
     
     self._globalForm = form
     self._globalField = field
     
     return form
    def expose_component(self,tabAnchor,rootData):
        attrib_link = rootData[0]
        ctrlHgt = 24
        nodeData = attrib_link.split('.') 
        typeChk = mc.attributeQuery(  nodeData[-1], node=nodeData[0], attributeType=True  )
        numericType = ['float','double','short','long','int','bool','enum','string']
        clm = mc.columnLayout( adjustableColumn=True, rs=5 ,p=tabAnchor, w=420 -30 )
        
        stringType = mc.getAttr(attrib_link,type=True)
        fildCaption = mc.textField(  tx=rootData[1],ed=False,w=410 -30 ,p=clm , font="boldLabelFont",bgc=[0.8,0.8,0.8])    
        mc.popupMenu( button=3 ,p=fildCaption)
        mc.menuItem(l='Open in connection Editor' )


        if stringType == 'string':  
            attrFld = mc.textField(  ed=True,w=410 -30 ,p=clm )              
            mc.connectControl( attrFld, attrib_link )

        else:
            if typeChk in numericType:
                mc.attrFieldSliderGrp( attribute=rootData[0],p=clm )
            else:        
                flw = mc.flowLayout( columnSpacing=4  , p=clm )
                fldLnk = mc.textField(  tx=rootData[0],ed=False ,w=385,h=ctrlHgt,p=flw)
                mc.button( label='<',p=flw)
Beispiel #24
0
 def __init__(s, i18n, parent, char, clip, sendRunClip, refresh):
     s.wrapper = cmds.columnLayout(adj=True, bgc=[0.18,0.18,0.18], p=parent) # Main block
     s.i18n = i18n
     s.char = char
     s.clip = clip
     s.name = clip.metadata.get("name", "CLIP").title()
     length = clip.metadata.get("length", None)
     if length is not None:
         s.name = "%s - %s" % (s.name, length)
     s.thumbs = list(clip.thumbs) if clip.thumbs else ["savePaintSnapshot.png"]
     s.thumbs.reverse()
     s.index = 0
     s.imgbtn = cmds.iconTextButton(
         ann=i18n["clips.addClip"],
         style="iconOnly",#"iconAndTextVertical",
         image=s.thumbs[-1],
         c=lambda: warn.run(sendRunClip, char, clip)
         )
     s.label = cmds.text(l=s.name, h=20)
     cmds.popupMenu(p=s.imgbtn)
     cmds.menuItem(l=s.name, en=False, itl=True)
     cmds.menuItem(l=i18n["clips.ignoreSel"], c=lambda x: warn.run(sendRunClip, char, clip, ignore=True))
     cmds.menuItem(ob=True, obi="channelBoxMedium.png")
     cmds.menuItem(l=i18n["clips.includeSel"], c=lambda x: warn.run(sendRunClip, char, clip, include=True))
     cmds.menuItem(ob=True, obi="channelBoxSlow.png")
     cmds.menuItem(d=True)
     cmds.menuItem(l=i18n["clips.renameClip"], c=lambda x: s.rename(char, clip))
     cmds.menuItem(ob=True, obi="pencilCursor.png")
     cmds.menuItem(l=i18n["clips.deleteClip"], c=lambda x: s.delete())
     cmds.menuItem(ob=True, obi="SP_TrashIcon.png")
Beispiel #25
0
	def __init__(self):	
		"""
		Initializes the pop up menu class call
		"""
		self.optionVars = []
		self.toolName = 'cgm.snapMM'
		IsClickedOptionVar = OptionVarFactory('cgmVar_IsClicked', 'int')
		mmActionOptionVar = OptionVarFactory('cgmVar_mmAction', 'int')	
		surfaceSnapAimModeVar = OptionVarFactory('cgmVar_SurfaceSnapAimMode', 'int')	
		UpdateRotateOrderOnTagVar = OptionVarFactory('cgmVar_TaggingUpdateRO', 'int')	
		self.LocinatorUpdateObjectsBufferOptionVar = OptionVarFactory('cgmVar_LocinatorUpdateObjectsBuffer',defaultValue = [''])
		
		self.LocinatorUpdateObjectsOptionVar = OptionVarFactory('cgmVar_SnapMMUpdateMode',defaultValue = 0)
		guiFactory.appendOptionVarList(self,self.LocinatorUpdateObjectsOptionVar.name)
		
		self.SnapModeOptionVar = OptionVarFactory('cgmVar_SnapMatchMode',defaultValue = 0)
		guiFactory.appendOptionVarList(self,self.SnapModeOptionVar.name)
				
		
		panel = mc.getPanel(up = True)
		sel = search.selectCheck()
		
		IsClickedOptionVar.set(0)
		mmActionOptionVar.set(0)
		
		if mc.popupMenu('cgmMM',ex = True):
			mc.deleteUI('cgmMM')
			
		if panel:
			if mc.control(panel, ex = True):
				mc.popupMenu('cgmMM', ctl = 0, alt = 0, sh = 0, mm = 1, b =1, aob = 1, p = 'viewPanes',
					         pmc = lambda *a: self.createUI('cgmMM'))
    def expose_list(self,tabAnchor,rootData):
        samplingConnections     = rootData[0]
        caption                 = rootData[1]
        mc.textField(  tx=caption,ed=False ,p=tabAnchor , font="boldLabelFont",bgc=[0.8,0.8,0.8])
        mc.optionMenu( label=' Options: ' ,p=tabAnchor , w=432  -30)
        mc.menuItem( label='select' )
        mc.menuItem( label='connect' )
        mc.menuItem( label='swap' )
        mc.menuItem( label='constraint' )
        mc.menuItem( label='Manage Input' )
        scrollWdth = mc.scrollLayout(	horizontalScrollBarThickness=0,verticalScrollBarThickness=8, p=tabAnchor ,h=150,childResizable=True )

        inputIdxList = mc.getAttr(samplingConnections,mi=True )
        ctrlHgt = 24
        for idx  in inputIdxList:
            input = mc.listConnections(samplingConnections+'[%s]'%idx)
            
            if input is not None and len(input)>0:
                input = input[0]
            else:
                input = samplingConnections+'[%s]'%idx

            mc.separator(style='none', p=scrollWdth,h=6 )
            mc.flowLayout( columnSpacing=4  , p=scrollWdth )
            fldLnk = mc.textField(  tx=input,ed=False ,w=395 -30,h=ctrlHgt)
            mc.popupMenu( button=3 ,p=fldLnk)
            mc.menuItem(l='moveUP' )
            mc.menuItem(l='moveDown' )
            mc.menuItem(l='Delete' )
            mc.button( label='<')
	def __init__( self ):
		mel.zooVisManUtils()
		mel.zooVisInitialSetup()

		if cmd.window(self.WINDOW_NAME, ex=True): cmd.deleteUI(self.WINDOW_NAME)

		cmd.window(self.WINDOW_NAME, t="vis set manager", wh=(254, 375))
		api.mel.eval(r'''scriptJob -p %s -e "SceneOpened" "python(\"visManagerUI.ui.populate()\");";''' % self.WINDOW_NAME)
		self.UI_form = cmd.formLayout(docTag=0)
		self.UI_check_state = cmd.checkBox(v=self.state(), al="left", l="turn ON", cc=self.on_state_change)
		self.UI_button_marks = cmd.button(l="bookmarks")
		self.UI_tsl_sets = cmd.textScrollList(ams=1, dcc=self.on_collapse, nr=18, sc=self.on_select)

		self.POP_marks = cmd.popupMenu(p=self.UI_button_marks, b=1, aob=1, pmc=self.popup_marks)
		self.POP_marks_sh = cmd.popupMenu(p=self.UI_button_marks, sh=1, b=1, aob=1, pmc=self.popup_marks_add)
		self.POP_sets = cmd.popupMenu(p=self.UI_tsl_sets, b=3, pmc=self.popup_sets)

		self.reparentUI = None

		cmd.formLayout(self.UI_form, e=True,
				   af=((self.UI_check_state, "top", 3),
					 (self.UI_check_state, "left", 3),
					 (self.UI_button_marks, "top", 0),
					 (self.UI_button_marks, "right", 0),
					 (self.UI_tsl_sets, "left", 0),
					 (self.UI_tsl_sets, "bottom", 0)),
				   ac=((self.UI_button_marks, "left", 5, self.UI_check_state),
					 (self.UI_tsl_sets, "top", 0, self.UI_button_marks)),
				   ap=((self.UI_tsl_sets, "right", 0, 100)) )

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

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

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

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

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

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

    # Show Window
    cmds.showWindow(particleLocatorsUI)
Beispiel #29
0
def aiSwatchDisplayNew(plugName) :
    nodeAndAttrs = plugName.split(".")
    node = nodeAndAttrs[0]
        
    cmds.formLayout('swatchDisplayForm')
    cmds.text('swatchLabel', label=aiSwatchLabel(node))
    cmds.swatchDisplayPort('swatchDisplay',
                           wh=(64, 64), rs=64)
    cmds.popupMenu('swatchPopup', button=3)
    cmds.menuItem( 'swatchSmall', label='Small' )
    cmds.menuItem( 'swatchMedium', label='Medium' )
    cmds.menuItem( 'swatchLarge', label='Large' )
    cmds.setParent(upLevel=True)
    gTextColumnWidthIndex = mel.eval("$tempVar=$gTextColumnWidthIndex;")
    cmds.formLayout('swatchDisplayForm',
                    edit=True,
                    af=[('swatchLabel',"top", 0),
                        ('swatchLabel', "bottom", 0),
                        ('swatchDisplay',"top", 0),
                        ('swatchDisplay', "bottom", 0),],
                    aof=[('swatchLabel', "right", -gTextColumnWidthIndex)],
                    an=[('swatchLabel', "left"),
                        ('swatchDisplay', "right")],
                    ac=[('swatchDisplay', "left", 5, 'swatchLabel')]
                    )

    aiSwatchDisplayReplace(plugName)
Beispiel #30
0
def typeFinderUI(*args):
    if cmds.window("typeFinderWin", exists=True):
        cmds.deleteUI("typeFinderWin")

    widgets["win"] = cmds.window("typeFinderWin",
                                 w=400,
                                 h=400,
                                 t="zbw_typeFinder")
    widgets["mainCLO"] = cmds.columnLayout(w=400, h=400, bgc=(.2, .2, .2))

    #---------------- right click on an item and get option to replace with parent or go down to shape

    cmds.text(
        l="Note: Rt-click on the below field to get suggestions from your sub-string"
    )
    cmds.separator(h=10)

    widgets["typeTFBG"] = cmds.textFieldButtonGrp(l="Node Type",
                                                  bl="Find",
                                                  cal=[(1, "left"),
                                                       (2, "left"),
                                                       (3, "left")],
                                                  cw=[(1, 75), (2, 250),
                                                      (3, 50)],
                                                  bc=getObjectList)
    widgets["searchPUM"] = cmds.popupMenu(postMenuCommand=populateMenuItems)

    widgets["searchSelCB"] = cmds.checkBox(l="Only search current selection?",
                                           v=0)
    widgets["shpsToXformCB"] = cmds.checkBox(
        l="List transforms of found shapes (mesh, etc)?", v=1)

    widgets["stringMatchCB"] = cmds.checkBox(
        l="Additional name/string search?",
        v=0,
        changeCommand=toggleStringSearchEnable)
    widgets["stringSearchTFG"] = cmds.textFieldGrp(l="String:",
                                                   en=False,
                                                   cal=[(1, "left"),
                                                        (2, "left")],
                                                   cw=[(1, 75), (2, 250)],
                                                   changeCommand=getObjectList)

    cmds.separator(h=10)

    widgets["resultsTSL"] = cmds.textScrollList(w=400,
                                                h=200,
                                                bgc=(0, 0, 0),
                                                allowMultiSelection=True)
    #---------------- checkbox here to expand selection? for sets (true-select objects in set, false - just seletc the set)

    widgets["selectAllBut"] = cmds.button(l="Select All in List", h=30)
    widgets["selectSelBut"] = cmds.button(l="Select Selected in List", h=30)
    widgets["selectParOfSelBut"] = cmds.button(
        l="Select Parent/Transform of Selected in List", h=30)
    widgets["deleteAllBut"] = cmds.button(l="Delete All in List", h=30)
    widgets["deleteSelBut"] = cmds.button(l="Delete Selected in List", h=30)
    widgets["clearListBut"] = cmds.button(l="Clear List",
                                          h=30,
                                          c=clearScrollList)
    #widgets["connectDecompBut"] = cmds.button(l="Clear List", h= 30, c=clearList)
    #---------------- button to promote all shape to transforms?
    #---------------- button to select shapes of all in list

    cmds.showWindow(widgets["win"])
Beispiel #31
0
def selectHistoryUI(mainSelDict, dock=False):
    windowWidth = 300
    windowHeight = 350
    horizontalSpacing = int(windowHeight * 0.01)
    verticalSpacing = int(windowWidth * 0.02)

    if cmds.window("selectHistory", q=1, exists=True):
        cmds.deleteUI("selectHistory")

    if cmds.dockControl("selectionHistoryDock", q=1, exists=1) == True:
        cmds.deleteUI("selectionHistoryDock")

    selectHistoryWindow = cmds.window("selectHistory",
                                      title="Selection History",
                                      w=windowWidth,
                                      h=windowHeight,
                                      mnb=True,
                                      mxb=False,
                                      sizeable=False,
                                      menuBar=True)

    selectHistoryMenu = cmds.menu("selectHistoryUIMenu",
                                  label="File",
                                  parent=selectHistoryWindow)
    cmds.menuItem(
        label="Export Selection Set to JSON",
        command=lambda *args: selHistoryJSON(mainSelDict, method="export"),
        parent=selectHistoryMenu)
    cmds.menuItem(
        label="Import Selection Set",
        command=lambda *args: selHistoryJSON(mainSelDict, method="import"),
        parent=selectHistoryMenu)

    #layout
    mainLayout = cmds.columnLayout("selhisLayout",
                                   rowSpacing=horizontalSpacing,
                                   w=windowWidth,
                                   h=windowHeight)

    cmds.separator(parent=mainLayout)
    cmds.text(label="Nickname (Alias) for Selection: ",
              parent=mainLayout,
              width=windowWidth,
              align="center")
    reqName = cmds.textField("selNickname",
                             width=windowWidth,
                             annotation="Tip: Keypad 'Enter' key to add entry",
                             enterCommand=lambda *args: selectHistoryCommand(
                                 mainSelDict, command="add"),
                             parent=mainLayout)

    cmds.button(
        "AddSelection",
        label="Add New Selection",
        backgroundColor=[
            0.46045002341270447, 0.81176471710205078, 0.41065746545791626
        ],
        width=windowWidth,
        c=lambda *args: selectHistoryCommand(mainSelDict, command="add"),
        parent=mainLayout)

    cmds.separator(parent=mainLayout, width=windowWidth, height=10)

    cmds.text(label="Selection History Recorded: ",
              parent=mainLayout,
              width=windowWidth,
              align="center")

    selectHistoryLst = cmds.textScrollList(
        "selectHistoryList",
        deleteKeyCommand=lambda *args: selectHistoryCommand(mainSelDict,
                                                            command="remove"),
        doubleClickCommand=lambda *args: selectHistoryCommand(
            mainSelDict, command="select"),
        annotation=
        "Tip: 'Double-click' to Select or 'Delete' key to Remove Selected Entry ",
        width=windowWidth,
        numberOfRows=8,
        parent=mainLayout)

    optionPopup = cmds.popupMenu(parent=selectHistoryLst)
    cmds.menuItem(label="Sort Ascending",
                  command=lambda *args: selectHistoryOrganize(mainSelDict,
                                                              order="alpha"))
    cmds.menuItem(label="Sort Descending",
                  command=lambda *args: selectHistoryOrganize(
                      mainSelDict, order="alpha_ZA"))
    cmds.menuItem(label="Sort by Added",
                  command=lambda *args: selectHistoryOrganize(mainSelDict,
                                                              order="added"))
    cmds.menuItem(
        label="Sort by Type",
        command=lambda *args: selectHistoryOrganize(mainSelDict, order="type"))

    if len(mainSelDict.keys()) > 0:
        for key in mainSelDict.keys():
            cmds.textScrollList("selectHistoryList", e=1, append=key)

    cmds.text(label="Modify Current Selection in Scene: ",
              parent=mainLayout,
              width=windowWidth,
              align="center")
    cmds.radioButtonGrp("selectType",
                        width=windowWidth,
                        labelArray3=['Single', 'Add', 'Remove'],
                        select=1,
                        numberOfRadioButtons=3)
    cmds.text(label="Comparitive Functions: ",
              parent=mainLayout,
              width=windowWidth,
              align="center")
    cmds.radioButtonGrp("setSpecific",
                        width=windowWidth,
                        labelArray3=['None', 'Common', 'Difference'],
                        select=1,
                        numberOfRadioButtons=3)

    cmds.button(
        "SelectButton",
        label="Select",
        backgroundColor=[
            0.37993082404136658, 0.60194522142410278, 0.71764707565307617
        ],
        width=windowWidth,
        c=lambda *args: selectHistoryCommand(mainSelDict, command="select"),
        parent=mainLayout)

    cycleButtonLayout = cmds.rowLayout("cycButLayout",
                                       numberOfColumns=2,
                                       w=windowWidth,
                                       parent=mainLayout)
    cmds.button("cycBack",
                label="<< Cycle Backward",
                backgroundColor=[
                    0.58823531866073608, 0.57949936389923096,
                    0.48442909121513367
                ],
                width=windowWidth / 2,
                c=lambda *args: selectHistoryCommand(
                    mainSelDict, command="cycle", iterDir="backward"),
                parent=cycleButtonLayout)
    cmds.button(
        "cycForward",
        label="Cycle Forward >>",
        backgroundColor=[
            0.58823531866073608, 0.57949936389923096, 0.48442909121513367
        ],
        width=windowWidth / 2,
        c=lambda *args: selectHistoryCommand(mainSelDict, command="cycle"),
        parent=cycleButtonLayout)

    cmds.separator(parent=mainLayout)
    mirrorOpLyt = cmds.rowColumnLayout(
        "mirrorOpLyt",
        numberOfColumns=3,
        columnWidth=[[1, (windowWidth / 2) - 5], [2, (windowWidth / 2) - 10],
                     [3, 15]],
        width=windowWidth,
        height=50,
        parent=mainLayout)
    cmds.text(label="Find", height=25)
    cmds.text(label="Replace", height=25)
    cmds.text(label="", height=25)
    cmds.textField("originalPrefix",
                   width=(windowWidth / 3),
                   height=20,
                   parent=mirrorOpLyt)
    cmds.textField("mirrorPrefix",
                   width=(windowWidth / 3),
                   height=20,
                   parent=mirrorOpLyt)
    cmds.checkBox("mirrorSelCB", label="Mirror", parent=mirrorOpLyt)

    # Add/Remove from Selection Buttons
    modSelLyt = cmds.rowColumnLayout("modifySelLyt",
                                     numberOfColumns=2,
                                     width=windowWidth,
                                     height=25,
                                     parent=mainLayout)
    cmds.button(
        "AddToSelection",
        label="Add To Selection",
        backgroundColor=[
            0.49328723549842834, 0.63529413938522339, 0.5444866418838501
        ],
        width=windowWidth / 2,
        c=lambda *args: selectHistoryCommand(mainSelDict, command="addTo"),
        parent=modSelLyt)

    cmds.button("RemoveFromSelection",
                label="Remove From Selection",
                backgroundColor=[
                    0.68235296010971069, 0.56193774938583374,
                    0.56193774938583374
                ],
                width=windowWidth / 2,
                c=lambda *args: selectHistoryCommand(mainSelDict,
                                                     command="removeFrom"),
                parent=modSelLyt)

    if dock != True:
        cmds.showWindow(selectHistoryWindow)
    else:
        allowedAreas = ['right', 'left']
        cmds.dockControl("selectionHistoryDock",
                         area='left',
                         label="Selection History",
                         content=selectHistoryWindow,
                         allowedArea=allowedAreas)
Beispiel #32
0
 def popupMenu(self, *args):
     menu = cmds.popupMenu()
     cmds.popupMenu(menu,
                    edit=True,
                    postMenuCommand=self.populateMenu,
                    postMenuCommandOnce=True)
Beispiel #33
0
 def _python(module_name, **kwargs):
     """show python generated temp menu"""
     importlib.import_module("MMtoKey.menus." + module_name).run(cmds.popupMenu("mm_%i" % kwargs["b"], **kwargs))
Beispiel #34
0
 def _mel(file_name, **kwargs):
     """show static marking menu"""
     cmds.popupMenu("mm_%i" % kwargs["b"], **kwargs)
     mel.eval("source menu_%s.mel" % file_name)
Beispiel #35
0
    sels = cmds.ls(sl=1)
    if not sels:
        targetClass('locusChrigPopup', sels).openMenu()
        return None

    namespace = getNamespace(sels[-1])

    target = sels[-1].replace('_L_', '_').replace('_R_',
                                                  '_').replace(namespace, '')

    for module in [
            allCtlsMenu, initCtlsMenu, headCtlsMenu, torsoCtlsMenu,
            armandlegCtlsMenu, bjtsMenu
    ]:
        targetClass = getProperClassInMenuModule(target, module, targetClass)
        if targetClass != allCtlsMenu.CTL_basic:
            break
    targetClass('locusChrigPopup', sels).openMenu()


if cmds.popupMenu('locusChrigPopup', ex=1):
    cmds.deleteUI('locusChrigPopup')
cmds.popupMenu('locusChrigPopup',
               sh=1,
               alt=1,
               button=3,
               mm=1,
               p='viewPanes',
               pmc=openMarkingMenu)
Beispiel #36
0
 def postMenuCommand(self, command):
     cmds.popupMenu(self.name, e=True, postMenuCommand=command)
Beispiel #37
0
    def initUI(self):
        super(self.__class__, self).initUI()

        cmds.columnLayout(adjustableColumn=True, rowSpacing=3)

        self.actionWidget = cmds.radioButtonGrp(label='Action',
                                                numberOfRadioButtons=3,
                                                label1='Copy',
                                                label2='Flip',
                                                label3='Mirror',
                                                select=3,
                                                changeCommand=self._refreshUI)

        self.directionWidget = cmds.radioButtonGrp(label="Direction",
                                                   numberOfRadioButtons=2,
                                                   label1="Left to Right",
                                                   label2="Right To Left",
                                                   select=1)

        cmds.separator()

        self.sourceMeshWidget = cmds.textFieldButtonGrp(label='Source Mesh',
                                                        buttonLabel='<<<',
                                                        text="",
                                                        editable=False)

        self.sourceDeformerWidget = cmds.textFieldGrp(label='Source Deformer',
                                                      text='',
                                                      editable=False)

        cmds.textFieldButtonGrp(self.sourceMeshWidget,
                                edit=True,
                                buttonCommand=functools.partial(
                                    self._handleLoadSelectedMeshClick,
                                    meshWidget=self.sourceMeshWidget,
                                    deformerWidget=self.sourceDeformerWidget))

        cmds.popupMenu(postMenuCommand=functools.partial(
            self._handleDeformerMenuOpen,
            meshWidget=self.sourceMeshWidget,
            deformerWidget=self.sourceDeformerWidget))

        cmds.separator()

        self.destinationMeshWidget = cmds.textFieldButtonGrp(
            label='Destination Mesh',
            buttonLabel='<<<',
            text="",
            editable=False)

        self.destinationDeformerWidget = cmds.textFieldGrp(
            label='Destination Deformer', text='', editable=False)

        cmds.textFieldButtonGrp(
            self.destinationMeshWidget,
            edit=True,
            buttonCommand=functools.partial(
                self._handleLoadSelectedMeshClick,
                meshWidget=self.destinationMeshWidget,
                deformerWidget=self.destinationDeformerWidget))

        cmds.popupMenu(postMenuCommand=functools.partial(
            self._handleDeformerMenuOpen,
            meshWidget=self.destinationMeshWidget,
            deformerWidget=self.destinationDeformerWidget))
Beispiel #38
0
 def setUseRightMouseButton(self):
     return cmds.popupMenu(self.name, e=True, button=2)
Beispiel #39
0
 def setAltModifier(self, state):
     return cmds.popupMenu(self.name, e=True, altModifier=state)
Beispiel #40
0
 def setCtrlModifier(self, value):
     return cmds.popupMenu(self.name, e=True, ctrlModifier=value)
Beispiel #41
0
 def setShiftModifier(self, value):
     return cmds.popupMenu(self.name, e=True, shiftModifier=value)
Beispiel #42
0
 def shiftModifier(self):
     return cmds.popupMenu(self.name, q=True, shiftModifier=True)
Beispiel #43
0
 def postMenuCommandOnce(self, state):
     cmds.popupMenu(self.name, e=True, postMenuCommandOnce=state)
Beispiel #44
0
 def markingMenu(self):
     return cmds.popupMenu(self.name, q=True, markingMenu=True)
Beispiel #45
0
 def numberOfItems(self):
     return cmds.popupMenu(self.name, q=True, numberOfItems=True)
Beispiel #46
0
 def exists(self):
     return cmds.popupMenu(self.name, exists=True)
Beispiel #47
0
 def itemArray(self):
     return cmds.popupMenu(self.name, q=True, itemArray=True)
Beispiel #48
0
 def ctrlModifier(self):
     return cmds.popupMenu(self.name, q=True, ctrlModifier=True)
Beispiel #49
0
 def deleteAllItems(self):
     try:
         cmds.popupMenu(self.name, e=True, deleteAllItems=True)
     except Exception:
         return False
     return True
Beispiel #50
0
 def altModifier(self):
     return cmds.popupMenu(self.name, q=True, altModifier=True)
Beispiel #51
0
 def button(self):
     return cmds.popupMenu(self.name, q=True, button=True)
Beispiel #52
0
 def kill(self):
     if cmds.popupMenu(self.name, ex=True):
         cmds.deleteUI(self.name)
Beispiel #53
0
 def allowOptionBoxes(self):
     return cmds.popupMenu(self.name, q=True, allowOptionBoxes=True)
Beispiel #54
0
 def setUseMiddleMouseButton(self):
     return cmds.popupMenu(self.name, e=True, button=3)
Beispiel #55
0
def exportPointDataUI():
    '''
	Main UI for the exportPointData module
	'''
    # Get current frame range
    startFrame = mc.playbackOptions(q=True, min=True)
    endFrame = mc.playbackOptions(q=True, max=True)

    # Window
    window = 'exportPointDataUI'
    if mc.window(window, q=True, ex=True): mc.deleteUI(window)
    window = mc.window(window, t='Export Point Data', s=False)

    # Layout
    CL = mc.columnLayout(adj=True)

    # UI Elements
    pathTBG = mc.textFieldButtonGrp('exportPoint_pathTBG',
                                    label='Path',
                                    buttonLabel='...')
    camTBG = mc.textFieldButtonGrp('exportPoint_camTBG',
                                   label='Camera (2D only)',
                                   buttonLabel='Select')
    rangeIFG = mc.intFieldGrp('exportPoint_rangeIFG',
                              nf=2,
                              label='Frame Range',
                              v1=startFrame,
                              v2=endFrame)
    resIFG = mc.intFieldGrp('exportPoint_resIFG',
                            nf=2,
                            label='Resolution',
                            v1=2348,
                            v2=1152)
    refIFG = mc.intFieldGrp('exportPoint_refIFG',
                            nf=1,
                            label='Offset Base Frame',
                            v1=startFrame)
    resOMG = mc.optionMenuGrp('exportPoint_resOMG', label='Resolution Preset')
    export2DB = mc.button('exportPoint_export2DB',
                          label='Export 2D Point Data',
                          c='glTools.ui.exportPointData.export2DFromUI()')
    export2DOffsetB = mc.button(
        'exportPoint_export2DOffsetB',
        label='Export 2D Offset Data',
        c='glTools.ui.exportPointData.export2DOffsetFromUI()')
    export3DB = mc.button('exportPoint_export3DB',
                          label='Export 3D Point Data',
                          c='glTools.ui.exportPointData.export3DFromUI()')
    export3DRotB = mc.button(
        'exportPoint_export3DRotB',
        label='Export 3D Rotate Data',
        c='glTools.ui.exportPointData.export3DRotationFromUI()')
    closeB = mc.button('exportPoint_closeB',
                       label='Close',
                       c='mc.deleteUI("' + window + '")')

    # Resolution presets
    mc.setParent(resOMG)
    mc.menuItem(label='WIDE(full)')
    mc.menuItem(label='WIDE(half)')
    mc.menuItem(label='WIDE(quarter)')

    # UI Callbacks
    mc.textFieldButtonGrp(pathTBG,
                          e=True,
                          bc='glTools.ui.utils.exportFolderBrowser("' +
                          pathTBG + '")')
    mc.textFieldButtonGrp(camTBG,
                          e=True,
                          bc='glTools.ui.utils.loadTypeSel("' + camTBG +
                          '",selType="transform")')
    mc.optionMenuGrp(resOMG,
                     e=True,
                     cc='glTools.tools.exportPointData.setResolution()')

    # Popup menu
    mc.popupMenu(parent=camTBG)
    for cam in mc.ls(type='camera'):
        if mc.camera(cam, q=True, orthographic=True): continue
        camXform = mc.listRelatives(cam, p=True, pa=True)[0]
        mc.menuItem(
            l=camXform,
            c='mc.textFieldButtonGrp("exportPoint_camTBG",e=True,text="' +
            camXform + '")')

    # Show Window
    mc.window(window, e=True, w=435, h=275)
    mc.showWindow(window)
def Edit_UI():
	cmds.columnLayout(adj=True)

	cmds.rowColumnLayout( numberOfColumns=3, columnWidth=[(1, 300), (2,23),(3, 100)] )

	cmds.text('availableText',l='Available blendShape target: ')
	cmds.text(l='')
	cmds.text('InbetweenText',l='Inbetween weight:')
	
	cmds.columnLayout()
	cmds.popupMenu(mm=True)
	cmds.menuItem(l ="Append",rp= "N",c= lambda *args: CreativeBlendShape().AppendTarget() and freshTargetBlendShape("append"))
	cmds.menuItem(l= "Delete",rp ="S",c= lambda *args: CreativeBlendShape().RemoveTarget() and freshTargetBlendShape("remove"))
	cmds.menuItem(l= "Gian",rp ="W",c= lambda *args: CreativeBlendShape().GainTarget())
	cmds.menuItem(l= "Rename",rp ="E",c= lambda *args: CreativeBlendShape().RenameTarget() and freshTargetBlendShape("append"))
	
	def cbTBS():
		inbetweenWieght(),getBlendShapeIndex()
	
	cmds.textScrollList('targetBlendShapeText',height =  200,width = 300,sc = cbTBS)

	cmds.setParent('..')

	cmds.text(l=' => ')

	cmds.columnLayout()
	text2 = cmds.textScrollList('targetInbetweenText',allowMultiSelection=True, height =  150,width = 100,sc=lambda *args:setBlendShape())
	cmds.floatField('InbetweenField',w=100,en=False)
	cmds.button( l='inputGeomTarget',c=lambda *args:CreativeBlendShape().inputGeomTarget())
	cmds.setParent( '..' )
	cmds.setParent( '..' )

	cmds.text(l= '',h=5)
	b2=cmds.button('EditFinsihButton',label = 'Edit',c=lambda *args: EditFinishButton(),width = 60)
	cmds.setParent('..')


	cmds.columnLayout()
	cmds.frameLayout( w= 425,label='In-between', collapsable = True,labelAlign='top', borderStyle='etchedIn',marginHeight =2,marginWidth =2 ,collapse =True )
	cmds.columnLayout(adj=1)
	cmds.checkBoxGrp('Inbetween',label='Add in-between target:',columnWidth=( 1, 160),of1=lambda *args:inbetweenBox(),on1=lambda *args:inbetweenBox())

	cmds.floatSliderGrp('InbetweenSlider',label ='In-between weight:', field= True,min= -10.00, max =10.00 ,pre =2, enable =False ,adj= 3 ,cw3=( 140, 80,200))
	cmds.button('EditAddbetweenButton',label = 'inbetweenEdit',c=lambda *args: inbetweenEditAddButton(), width = 50,enable=False)
	cmds.setParent( '..' )
	cmds.setParent( '..' )

	cmds.frameLayout( w= 425,label='Mirror Target', collapsable = True, labelAlign='top', borderStyle='etchedIn',marginHeight =2,marginWidth =2 ,collapse =True )
	cmds.columnLayout()
	cmds.textFieldButtonGrp('MirrorTargetText',label='          >>',cw3= (150 ,150,120),bl=' Mirror ',bc= lambda *args: CreativeBlendShape().MirrorBlendShape(0) and freshTargetBlendShape("append"))
	cmds.setParent( '..' )
	cmds.setParent( '..' )
#############################################	
	cmds.frameLayout( w= 425,label='Mirror>Target', collapsable = True, labelAlign='top', borderStyle='etchedIn',marginHeight =2,marginWidth =2 ,collapse =True )
	cmds.columnLayout()
	cmds.rowColumnLayout( numberOfColumns=3, columnWidth=[(1, 160), (2, 100), (3, 160)] )
	cmds.textField("targetField",tx="Target",en=0)
	cmds.text(l="       ==>>==")
	cmds.textField("sourceField",tx="Source",en=0)
	cmds.button(l="Target",c=lambda *args:editField("targetField"))
	cmds.text(l="")
	cmds.button(l="Source",c=lambda *args:editField("sourceField"))
	cmds.setParent( '..' )
	cmds.button(l="Apply",w=420,c=lambda *args: CreativeBlendShape().MirrorBlendShape(1))
	cmds.setParent( '..' )
	cmds.setParent( '..' )
##########################################	
	cmds.frameLayout( w= 425,label='BlendTwoAttr', collapsable = True, labelAlign='top', borderStyle='etchedIn',marginHeight =2,marginWidth =2 ,collapse =True )
	cmds.columnLayout()
	cmds.rowColumnLayout( numberOfColumns=3, columnWidth=[(1, 120), (2, 120), (3, 160)] )
	cmds.textField("target_1Field",tx="Target1",en=0)
	cmds.textField("target_2Field",tx="Target2",en=0)
	cmds.text(l="")	
	cmds.button(l="Target1",c=lambda *args:editField("target_1Field"))
	cmds.button(l="Target2",c=lambda *args:editField("target_2Field"))
	cmds.setParent( '..' )
	cmds.button(l="create",w=420,c=lambda *args:CreativeBlendShape().blendTwoAttrCreate())
	cmds.button(l="finish",w=420,c=lambda *args:CreativeBlendShape().blendTwoAttrConnect())

	cmds.setParent( '..' )
	cmds.setParent( '..' )
###################################################

	cmds.setParent( '..' )
Beispiel #57
0
 def hide(cls, *buttons):
     """destroy marking menu"""
     for button in buttons or (cls.LMB, cls.MMB):
         while cmds.popupMenu("mm_%i" % button, q=True, ex=True):
             cmds.deleteUI("mm_%i" % button)
Beispiel #58
0
 def setParent(self, parent):
     return cmds.popupMenu(self.name, e=True, parent=parent.objectName())
Beispiel #59
0
def killUI():
    log.info("killUI...")
    if mc.popupMenu(_str_popWindow, ex=True):
        mc.deleteUI(_str_popWindow)
Beispiel #60
-2
    def __enter__(self):
        '''
        Initialize the UI
        '''
        if mc.window(self.name, exists=True):
            mc.deleteUI(self.name)

        mc.window(self.name, title='ml :: '+self.title, iconName=self.title, width=self.width, height=self.height, menuBar=self.menu)
        
        
        if self.menu:
            self.createMenu()
        
        self.form = mc.formLayout()
        self.column = mc.columnLayout(adj=True)

        
        mc.rowLayout( numberOfColumns=2, columnWidth2=(34, self.width-34), adjustableColumn=2, 
                    columnAlign2=('right','left'),
                    columnAttach=[(1, 'both', 0), (2, 'both', 8)] )

        #if we can find an icon, use that, otherwise do the text version
        if self.icon:
            mc.iconTextStaticLabel(style='iconOnly', image1=self.icon)
        else:
            mc.text(label=' _ _ |\n| | | |')
            
        if not self.menu:
            mc.popupMenu(button=1)
            mc.menuItem(label='Help', command=(_showHelpCommand(wikiURL+'#'+self.name)))
        
        mc.text(label=self.info)
        mc.setParent('..')
        mc.separator(height=8, style='single')
        return self