def show(): if pm.menu('alfredTools2', exists=True): pm.deleteUI('alfredTools2') gMainWindow = pm.melGlobals['gMainWindow'] # 마야 상단에 메뉴 생성 alfredToolsMenu = pm.menu('alfredTools2', label = "Alfred Tools 2", parent = gMainWindow, tearOff = True, allowOptionBoxes = True, #familyImage = familyImage, #mnemonic = 'alfred', # 뭔지 모르겠음. #helpMenu = True, # help메뉴 뒤로감 ) pm.menuItem( dl='Asset', divider=True, p=alfredToolsMenu ) pm.menuItem( l='Modeling', p=alfredToolsMenu, en=False ) pm.menuItem( l='Surfacing', p=alfredToolsMenu, c=pm.Callback( menuCmd_surfacing ) ) pm.menuItem( l='Rigging', p=alfredToolsMenu, c=pm.Callback( menuCmd_rig ) ) pm.menuItem( dl='Layout', divider=True, p=alfredToolsMenu ) pm.menuItem( l='Shot', p=alfredToolsMenu, c=pm.Callback(menuCmd_layout) ) pm.menuItem( dl='Animation', divider=True, p=alfredToolsMenu ) pm.menuItem( l='Animation', p=alfredToolsMenu, en=False ) pm.menuItem( l='Motion Capture', p=alfredToolsMenu, c=pm.Callback( menuCmd_motionCapture ) ) pm.menuItem( dl='FX', divider=True, p=alfredToolsMenu ) pm.menuItem( l='FX', p=alfredToolsMenu, en=False ) pm.menuItem( dl='Render', divider=True, p=alfredToolsMenu ) pm.menuItem( l='Scene Assembly', p=alfredToolsMenu, c=pm.Callback(menuCmd_sceneAssembly) ) pm.menuItem( l='Surfacing', p=alfredToolsMenu, c=pm.Callback( menuCmd_surfacing ) ) pm.menuItem( l='Lighting', p=alfredToolsMenu, en=False ) pm.menuItem( l='Render', p=alfredToolsMenu, c=pm.Callback(menuCmd_render) )
def show( reset=False ): if pm.about(batch=True): print 'menu not available in batch mode.' return else: # -- get things ready for building the menu menu_name = "Impress Example" pm.setParent( MAYA_WINDOW ) if pm.menu( menu_name, exists=True ): if reset: pm.deleteUI( menu_name ) else: main_menu = pm.menu( menu_name, edit=True ) return main_menu if not pm.menu( menu_name, exists=True ): main_menu = pm.menu( menu_name, tearOff=True ) # -- build the menu with main_menu: with pm.subMenuItem( 'Display', aob=True, tearOff=True ): ui.commandMenuItem( performExample )
def mantraMainMenu(): log.debug("Creating mantra main menu") menuName = "Mantra" if pm.menu(menuName, query=True, exists=True): pm.deleteUI(menuName) gMainWindow = pm.mel.eval('$tmpVar=$gMainWindow') mantraMenu = pm.menu(menuName, label=menuName, parent=gMainWindow, tearOff=True) pm.menuItem(label='Create Geo Standin', command=pm.Callback(menuCallback, "GeoStandin")) pm.setParent("..", menu=True)
def create_tank_disabled_menu(menu_name): """ Render a special "shotgun is disabled menu" """ if pm.menu("ShotgunMenu", exists=True): pm.deleteUI("ShotgunMenu") sg_menu = pm.menu("ShotgunMenuDisabled", label=menu_name, parent=pm.melGlobals["gMainWindow"]) pm.menuItem(label="Sgtk is disabled.", parent=sg_menu, command=lambda arg: tank_disabled_message())
def ui(): if pm.window("Depth tool", q=True, exists=True): pm.deleteUI("Depth tool") with pm.window("Depth tool", menuBar=True, s=False): pm.menu(l="help") pm.menuItem(l="document", c=pm.Callback(os.system, "D:/Users/blood/Desktop/eyeTest_01.mov")) pm.menuItem(l="tutorial", c=pm.Callback(pm.launch, web="https://www.youtube.com/watch?v=-JwXfnrX1wM")) with pm.columnLayout(adj=True): with pm.rowLayout(nc=2): pm.button(l="Create" + "\n" + "Depth", w=64, h=64, bgc=(0.2, 0.2, 0.2), c=creatAll) pm.button(l="Adjust" + "\n" + "Min&&Max", w=64, h=64, bgc=(0.8, 0.8, 0.8), c=adjustAll)
def __init__(self): if pm.window(self.uiID, exists=True): pm.deleteUI(self.uiID) win = pm.window(self.uiID, title=self.title, menuBar=True) with win: pm.menu( label='CageDeformer', tearOff=True ) pm.menuItem( label="CageDeformer", c=pm.Callback( self.initPlugin, "cage") ) pm.menuItem( label="CageDeformerARAP", c=pm.Callback( self.initPlugin, "cageARAP") ) self._parentLayout = pm.columnLayout( adj=True ) with self._parentLayout: self.createUISet()
def lcCameraToolsUI(dockable=False, *args, **kwargs): ''' ''' ci = 0 #color index iterator windowName = 'lcCameraTools' shelfCommand = 'import lct.src.lcCameraTools.lcCameraTools as lcCam\nreload(lcCam)\nlcCam.lcCameraToolsUI()' icon = basePath+'lcCameraTools.png' winWidth = 204 winHeight = 209 mainWindow = lcWindow(windowName=windowName, width=winWidth, height=winHeight, icon=icon, shelfCommand=shelfCommand, annotation=annotation, dockable=dockable, menuBar=True) mainWindow.create() pm.menu(l='Options', helpMenu=True) pm.menuItem(l='Reset Gradient Colors', command=lambda *args: cam_set_default_colors() ) # pm.columnLayout(prefix+'_columLayout_main') # pm.rowColumnLayout(nc=2, cw=([1,50], [2,150]) ) pm.text(l='Edit:', al='right') cameraListDropdown = pm.optionMenu(prefix+'_optionMenu_camera_list', bgc=colorWheel.getColorRGB(ci), w=150, h=25 ) ci+=1 cameraListDropdown.changeCommand(lambda *args: cam_get_cam_attrs(cameraListDropdown) ) pm.setParent(prefix+'_columLayout_main') # pm.rowColumnLayout(nc=2, cw=([1,125], [2,75]) ) pm.text(l='Focal Length:', al='right') pm.floatField(prefix+'_floatField_focal_length', min=0.0, v=0.0, pre=1, w=75, changeCommand=lambda *args: cam_set_cam_attrs(cameraListDropdown), receiveFocusCommand=lambda *args: cam_set_cam_attrs(cameraListDropdown) ) pm.text(l='Near Clip Plane:', al='right') pm.floatField(prefix+'_floatField_near_clip_plane', min=0.0, v=0.0, pre=4, w=75, changeCommand=lambda *args: cam_set_cam_attrs(cameraListDropdown), receiveFocusCommand=lambda *args: cam_set_cam_attrs(cameraListDropdown) ) pm.text(l='Far Clip Plane:', al='right') pm.floatField(prefix+'_floatField_far_clip_plane', min=0.0, v=0.0, pre=0, w=75, changeCommand=lambda *args: cam_set_cam_attrs(cameraListDropdown), receiveFocusCommand=lambda *args: cam_set_cam_attrs(cameraListDropdown) ) pm.text(l='Overscan:', al='right') pm.floatField(prefix+'_floatField_overscan', min=0.0, v=0.0, pre=3, w=75, changeCommand=lambda *args: cam_set_cam_attrs(cameraListDropdown), receiveFocusCommand=lambda *args: cam_set_cam_attrs(cameraListDropdown) ) pm.text(l='Background Color:', al='right') pm.colorSliderGrp(prefix+'_colorSliderGrp_background_color', cw1=50, rgb=(0.0,0.0,0.0), changeCommand=lambda *args: cam_set_cam_attrs(cameraListDropdown) ) pm.text(l='Gradient Top:', al='right') pm.colorSliderGrp(prefix+'_colorSliderGrp_gradient_top', cw1=50, rgb=(0.54,0.62,0.70), changeCommand=lambda *args: cam_set_cam_attrs(cameraListDropdown) ) pm.text(l='Gradient Bottom:', al='right') pm.colorSliderGrp(prefix+'_colorSliderGrp_gradient_bottom', cw1=50, rgb=(0.1,0.1,0.1), changeCommand=lambda *args: cam_set_cam_attrs(cameraListDropdown) ) pm.setParent(prefix+'_columLayout_main') # pm.rowColumnLayout(nc=2, cw=([1,175], [2,25]) ) pm.button(prefix+'_button_toggle_bkgd', l='Toggle Background', bgc=colorWheel.getColorRGB(ci), w=200, h=25, annotation='Toggle between flat color and gradient background', command=lambda *args: camera.toggleBackground() ) ci+=1 pm.iconTextButton(w=25, h=25, style='iconOnly', image=iconBasePath+'addToShelf.png', highlightImage=iconBasePath+'addToShelf_over.png', annotation='Add to Shelf', command=lambda *args: shelf.makeShelfButton('Toggle Camera Background', 'from lct.src.core.lcUtility import Camera as camera\ncamera.toggleBackground()', iconBasePath+'toggleBackground.png', "Toggle Camera's Viewport Background") ) # mainWindow.show() cam_populate_camera_list(cameraListDropdown) cam_get_cam_attrs(cameraListDropdown)
def __init__(self): if pm.window(self.uiID, exists=True): pm.deleteUI(self.uiID) win = pm.window(self.uiID, title=self.title, menuBar=True) with win: pm.menu( label='Create', tearOff=True ) for type in deformerTypes: pm.menuItem( label=type, c=pm.Callback( self.initPlugin, type) ) self._parentLayout = pm.columnLayout( adj=True ) with self._parentLayout: self.createUISet()
def __init__(self): if pm.window(self.uiID, exists=True): pm.deleteUI(self.uiID) win = pm.window(self.uiID, title=self.title, menuBar=True) with win: pm.menu(label='CageDeformer', tearOff=True) for type in deformerTypes: pm.menuItem(label=type, c=pm.Callback(self.initPlugin, type)) self._parentLayout = pm.columnLayout(adj=True) with self._parentLayout: self.createUISet()
def __init__(self): if pm.window(self.uiID, exists=True): pm.deleteUI(self.uiID) win = pm.window(self.uiID, title=self.title, menuBar=True) with win: pm.menu(label='Plugin', tearOff=True) pm.menuItem(label="Create", c=pm.Callback(self.initPlugin)) self._parentLayout = pm.columnLayout(adj=True) with self._parentLayout: self.createUISet()
def create(self, *args, **kwargs): ''' ''' if pm.control(self.windowName, exists=True): pm.deleteUI(self.windowName) if pm.control(self.dockName, exists=True): pm.deleteUI(self.dockName) if self.dockable: self.mainWindow = pm.window(self.windowName, t=self.windowName) else: self.mainWindow = pm.window(self.windowName, t=self.windowName, widthHeight=[self.width, self.height], rtf=self.rtf, mnb=self.mnb, mxb=self.mxb, s=self.sizeable, **self.kwargs) if self.menuBar: self.menuBarLayout = pm.menuBarLayout(self.prefix + '_menuBarLayout') #### Help menu pm.menu(self.prefix + '_help', l='Help', helpMenu=True) pm.menuItem(parent=self.prefix + '_help', l='Online Help', image='help.png', command=lambda *args: webbrowser.open('http://lct.leocov.com/help', new=2)) pm.menuItem(parent=self.prefix + '_help', l='Contact / Bug Report', image=os.path.join(self.srcPath, 'icons', 'lc_bug.png'), command=lambda *args: self.bug_report_window()) errorLogMenuItem = pm.menuItem(parent=self.prefix + '_help', l='Send Error Logs', checkBox=self.global_cfg.get('g_send_errors'), annotation="Automatically send error logs to the developer", command=lambda *args: self.global_cfg.set('g_send_errors', pm.menuItem(errorLogMenuItem, q=True, checkBox=True))) updateMenuItem = pm.menuItem(parent=self.prefix + '_help', l='Update', enable=False, image='', command=lambda *args: lcUpdate.Update.lct_auto_update(confirmDiag=True)) pm.menuItem(parent=self.prefix + '_help', l='About', image='channelBox.png', command=lambda *args: self.about()) #### Options menu pm.menu(self.prefix + '_options', l='Options') sceneSettingsMenuItem = pm.menuItem(parent=self.prefix + '_options', l="Use scene settings node", checkBox=self.global_cfg.get('g_scene_settings'), annotation="Store tool settings in a scene node. This applies to all scenes.", command=lambda *args: self.global_cfg.set('g_scene_settings', pm.menuItem( sceneSettingsMenuItem, q=True, checkBox=True))) pm.menuItem(parent=self.prefix + '_options', l='Reset {0}'.format(self.windowName), image='airField.svg', command=lambda *args: self.lct_cfg.reset_tool_config(self.windowName)) # pm.menuItem(parent = self.prefix+'_options', l='Make Shelf Icon', command=lambda *args: lcShelf.Shelf.makeShelfButton(self.windowName, self.shelfCommand, self.icon, self.annotation) ) # get the current toolset version and release codes release, version = lcUpdate.Update.update_get_current_version() if release: # check if there is a new version on the server and get it updatePath = lcUpdate.Update.update_get_new_version(version=version, release=release) if updatePath: pm.menuItem(updateMenuItem, edit=True, l='Update Available', enable=True, image='activeSelectedAnimLayer.png')
def createMenu(self): print 'initiating session' if pm.menu('PipeMenu', exists=True): pm.deleteUI('PipeMenu') pm.menu('PipeMenu', label='PipeMenu', p='MayaWindow', to=True) pm.menuItem(label="Browser", command=self.browserCallback) pm.menuItem(label="Publish Scene", command=self.publishCallback) pm.menuItem(label="Update Scene", command=self.sceneCheckCallback) pm.menuItem(label="scriptJob Update Scene", command=self.scriptJobSceneCheckCallback) pm.menuItem(label="scriptJob kill", command=self.killall)
def mantraMainMenu(): log.debug("Creating mantra main menu") menuName = "Mantra" if pm.menu(menuName, query=True, exists=True): pm.deleteUI(menuName) gMainWindow = pm.mel.eval('$tmpVar=$gMainWindow') mantraMenu = pm.menu(menuName, label = menuName, parent = gMainWindow, tearOff = True ) pm.menuItem( label = 'AttributeManager', command = Callback(menuCallback, "AttributeManager") ) pm.menuItem( label = 'DummyMenu' , command = Callback(menuCallback, "Dummy") ) pm.menuItem( label = '', divider = True ) pm.menuItem( label = 'DummyMenuA' , command = Callback(menuCallback, "DummyA") ) pm.setParent("..", menu = True)
def add_ldt_menus(): """Add Look dev Tools menus to dccs.""" from ldt import context dcc = context.dcc() if dcc == 'Maya': import pymel.core as pm if pm.menu('LookDevTools', l=u'LookDevTools', ex=True): logger.info('menu already exists.') else: pm.menu('LookDevTools', l=u'LookDevTools', to=True) pm.menuItem(l=u'Open', c='import ldt;reload(ldt)') pm.setParent("..")
def update_shelf_top_menu(menu): """ Populate the shelves menu with one menu item per shelf tab. """ # Clear the menu so it can be repopulated. pm.setParent(menu, menu=True) pm.menu(menu, e=True, deleteAllItems=True) shelves = Shelf.get_shelves() for shelf in shelves: create_shelf_button_menu(shelf, menu)
def unload_menus( ): # Get gMainWindow from mel command main_window = mel.eval("$temp=$gMainWindow") # search and delete old menuName menu_list = pm.window(main_window, query=True, menuArray=True) for menu in menu_list: if menu == menu_name: pm.menu(menu, edit=True, deleteAllItems=True) pm.deleteUI(menu) print ('Unloading Menu : ' + menu_name) break
def mvgCreateMenu(): gMainWindow = pm.mel.eval('$tmpVar=$gMainWindow') menuName = "mvgMenu" menuLabel = "MayaMVG" if(pm.menu(menuName, exists=True)): pm.deleteUI(menuName) if(gMainWindow != ""): pm.setParent(gMainWindow) menu = pm.menu(menuName, label=menuLabel, tearOff=True) pm.menuItem(parent=menu, label='Open...', command=pm.Callback(openMVGWindow_CB)) pm.menuItem(parent=menu, label='Export selection as ABC', command=pm.Callback(exportSelectionAsABC_CB)) pm.menuItem(parent=menu, label='Create locator from vertex', command=pm.Callback(createLocatorFromVertex_CB)) pm.menuItem(parent=menu, divider=True)
def UI_Build(self): """Build the static UI and define the main layouts. Keyword arguments: none """ # Delete windows if already existing if pc.window("lookdevAssistant", exists=True): pc.deleteUI("lookdevAssistant") # Main window self.globalWidgets['window'] = pc.window("lookdevAssistant", menuBar=True, title="Arnold Lookdev assistant", sizeable=False, h=430, w=500) # Menu bar # |-- Creation Menu self.globalWidgets['windowMenuCreate'] = pc.menu(label="Create") pc.menuItem(label='new aiStandard', parent=self.globalWidgets['windowMenuCreate'], c=partial(self.Maya_createNode, 'aiStandard')) pc.menuItem(label='new File', parent=self.globalWidgets['windowMenuCreate'], c=partial(self.Maya_createNode, 'file')) pc.menuItem(label='new ygColorCorrect', parent=self.globalWidgets['windowMenuCreate'], c=partial(self.Maya_createNode, 'ygColorCorrect')) pc.menuItem(divider=True) # --|-- Create complete network Menu self.globalWidgets['completeNetworkMenu'] = pc.menuItem(label='Complete network', parent=self.globalWidgets['windowMenuCreate'], subMenu=True, pmc=self.UI_refreshMenu) self.globalWidgets['fromFile'] = pc.menuItem(l="from existing File...", subMenu=True, p=self.globalWidgets['completeNetworkMenu']) pc.menuItem(l="from new File", c=partial(self.Maya_createFullNetwork, False, ''), p=self.globalWidgets['completeNetworkMenu']) # |-- See on flat Menu self.globalWidgets['windowMenuSeeOnFlat'] = pc.menu(label="See on flat") pc.menuItem(label='Diffuse Color', parent=self.globalWidgets['windowMenuSeeOnFlat'], c=partial(self.Maya_focusOn, 'color')) pc.menuItem(label='Specular Color', parent=self.globalWidgets['windowMenuSeeOnFlat'], c=partial(self.Maya_focusOn, 'KsColor')) pc.menuItem(label='Specular Roughness', parent=self.globalWidgets['windowMenuSeeOnFlat'], c=partial(self.Maya_focusOn, 'specularRoughness')) pc.menuItem(label='Bump', parent=self.globalWidgets['windowMenuSeeOnFlat'], c=partial(self.Maya_focusOn, 'normalCamera')) pc.menuItem(divider=True, parent=self.globalWidgets['windowMenuSeeOnFlat']) pc.menuItem(label='Revert to aiStandard', parent=self.globalWidgets['windowMenuSeeOnFlat'], c=self.Maya_revertToAiStd) # Main layout : 2 columns / 1 for the list of the ai* shaders / 1 to access selected shader attributes self.globalWidgets['mainLayout'] = pc.rowColumnLayout(nc=2, cw=[(1, 150), (2, 240)]) # Shaders list layout self.globalWidgets['sListLayout'] = pc.frameLayout(label='Shaders list', borderStyle='etchedIn', cll=True, h=430 , parent=self.globalWidgets['mainLayout']) self.sListWidgets['layout'] = pc.columnLayout(parent=self.globalWidgets['sListLayout']) self.sListWidgets['list'] = pc.textScrollList(h=340, parent=self.sListWidgets['layout']) self.sListWidgets['listRefreshButton'] = pc.button(l='Refresh', w=95, c=self.UI_refreshShaders) # Shaders attributes layout self.globalWidgets['sAttrLayout'] = pc.frameLayout(label='Shaders attributes', borderStyle='etchedIn', cll=True, h=430, parent=self.globalWidgets['mainLayout']) # Setup all callbacks self.UI_Callbacks()
def create_sgtk_disabled_menu(menu_name): """ Render a special "shotgun is disabled" menu """ if cmds.about(batch=True): # don't create menu in batch mode return if pm.menu("ShotgunMenu", exists=True): pm.deleteUI("ShotgunMenu") sg_menu = pm.menu("ShotgunMenuDisabled", label=menu_name, parent=pm.melGlobals["gMainWindow"]) pm.menuItem(label="Sgtk is disabled.", parent=sg_menu, command=lambda arg: sgtk_disabled_message())
def _add_standalone_menu_item(self, name, top_level_path, *args, **kwargs): if not _menu_registration.show_top_level_menu: return None assert 'top_level_path' not in kwargs # Make sure the edit menu is built so we can add to it. Maya defers this # for "heap memory reasons", but that was in 2009 and it doesn't really # make sense anymore. pm.mel.eval('buildDeferredMenus') path_parts = top_level_path.split('|') assert len(path_parts) >= 1, top_level_path # Find or create our menu. parent_submenu = 'zMayaTools_Menu' pm.setParent('MayaWindow') # Create the top-level menu. if not pm.menu(parent_submenu, q=True, exists=True): item = pm.menu(parent_submenu, label='zMayaTools', tearOff=True) # All but the final entry in top_level_path is a submenu name. Create # the submenu tree. path_so_far = [] for part in path_parts[:-1]: path_so_far.append(part.replace(' ', '_')) # Prefix the submenu to make sure it's unique. submenu_item_name = 'zMayaTools_Menu_' + '_'.join(path_so_far) # We can add menu items in any order. Make the menu ordering consistent: always put # submenus above regular menu items, and sort alphabetically within that. submenu_items = pm.menu(parent_submenu, q=True, ia=True) if submenu_item_name not in submenu_items: parent_submenu = self._add_menu_item_internal(submenu_item_name, label=part, parent=parent_submenu, subMenu=True, tearOff=True, insert_sorted=True) else: parent_submenu = submenu_item_name # Remove options that only apply when adding the integrated menu item, since # we're adding the standalone one. kwargs = dict(kwargs) kwargs['parent'] = parent_submenu if 'insertAfter' in kwargs: del kwargs['insertAfter'] name = '_'.join(path_parts).replace(' ', '_') return self._add_menu_item_internal(name, insert_sorted=True, *args, **kwargs)
def ui(): #masking이란 윈도우가 있는지를 확인한다. q는 확인하다. exists는 존재여부를 체크한다. if pm.window('masking', q=True, exists=True) : pm.deleteUI('masking') with pm.window('masking',menuBar=True, s=True): pm.menu(l='help') pm.menuItem(l='document', c=pm.Callback( os.system, "D:/Users/blood/Desktop/eyeTest_01.mov" )) pm.menuItem(l='tutorial', c=pm.Callback( pm.launch, web="https://www.youtube.com/watch?v=-JwXfnrX1wM") ) with pm.columnLayout( adj=True ): with pm.rowLayout(nc=4): pm.button(l='', w=64, h=64, bgc=(1,0,0), c=redCmd ) pm.button(l='', w=64, h=64, bgc=(0,1,0), c=greenCmd ) pm.button(l='', w=64, h=64, bgc=(0,0,1), c=blueCmd) pm.button(l='matte', w=64, h=64, bgc=(0.2,0.2,0.2), c=alphaCmd)
def beginMenu(self): cls = self.__class__ sMayaMainWin = pm.mel.eval('$tempMelVar=$gMainWindow') sMenuName = cls.classMenuName if pm.menu(sMenuName, q=True, exists=True): pm.menu(sMenuName, e=True, dai=True) self.menu = pm.ui.PyUI("|".join([sMayaMainWin, sMenuName])) else: self.menu = pm.menu(sMenuName, label=cls.classMenuLabel, p=sMayaMainWin, to=True)
def remove_menu_items(self): """ Remove this menu's menu items. This should be overridden by the subclass. """ _menu_registration.unregister_menu(self) for item in self.menu_items: try: pm.deleteUI(item, menuItem=True) except RuntimeError: continue # Walk up the parent submenus, and remove them if they're empty. This cleans # up any submenus we created if all plugins with items inside them are unloaded. # Don't recurse all the way up to the top MayaWindow. parts = item.split('|') for end in xrange(len(parts) - 2, 0, -1): # See if the parent menu has any items left. parent_menu_path = '|'.join(parts[0:end + 1]) if len(pm.menu(parent_menu_path, q=True, itemArray=True)) == 0: pm.deleteUI(parent_menu_path) self.menu_items = set() self.related_items = {}
def Menubar(self,*args): self.menuBar = pm.menu(parent = 'MayaWindow', label = "Cloth Simulation CIS660", tearOff = True) pm.menuItem(label = "Create Cloth", command = self.CreateClothWindow) pm.menuItem(label = "Assign the selected objects as Collision Objects with CCD", command = self.AssignCCDCollision) pm.menuItem(label = "Assign the selected objects as Collision Objects with regular method", command = self.AssignRegularCollision) pm.menuItem(label = "Add a Sphere Collision object(basic method)", command = self.AddSphere) pm.menuItem(label = "Select the Solver", command = self.SelectSolver)
def build_options_menu( self ): pmc.setParent( menu = True ) menu = pmc.menu( label = 'Options', allowOptionBoxes = True ) pmc.menuItem( label = 'Set xNormal Location', command = self.set_xn_location ) pmc.menuItem( divider = True ) enable = utils.get_bake_normals( ) if enable == None: utils.set_bake_normals( True ) enable = True pmc.menuItem( label = 'Bake Normal Map', cb = enable, command = pmc.CallbackWithArgs( self.map_cbx_callback, 'normal' ) ) enable = utils.get_bake_ao( ) if enable == None: utils.set_bake_ao( False ) enable = False pmc.menuItem( optionBox = True ) pmc.menuItem( label = 'Bake Ambient Occlusion Map', cb = enable, command = pmc.CallbackWithArgs( self.map_cbx_callback, 'ao' ) ) pmc.menuItem( optionBox = True )
def removeKrakenMenu(): mainWindow = maya.mel.eval('$tmpVar=$gMainWindow') menus = pm.window(mainWindow, q=True, ma=True) if 'Kraken' in menus: menuParent = pm.menu('Kraken', query=True, parent=True) pm.deleteUI('|'.join([menuParent, 'Kraken']))
def addMenu(): print("Loading Pipeline...") # Name of the global variable for the Maya window MainMayaWindow = pm.language.melGlobals['gMainWindow'] # Build a menu and parent underthe Maya Window customMenu = pm.menu('Carbon Pipeline', parent=MainMayaWindow) # Build a menu item and parent under the 'customMenu' pm.menuItem(label="Launch Project", command="pipeline.maya_tools.MayaProjectLauncher()", parent=customMenu) pm.menuItem(label="Import", command="pipeline.maya_tools.MayaImporter()", parent=customMenu) pm.menuItem(label="Save", command="pipeline.maya_tools.MayaSaver()", parent=customMenu) pm.menuItem(divider=True, parent=customMenu) pm.menuItem(label="Version Up", command="pipeline.maya_tools.MayaTools().version_up()", parent=customMenu) pm.menuItem(label="Create Temporary Copy", command="pipeline.maya_tools.MayaTools().open_temp_file()", parent=customMenu) pm.menuItem(label="Publish", command="pipeline.maya_tools.MayaTools().publish()", parent=customMenu)
def _get_sorted_insertion_point(cls, name, subMenu, parent): # Get the label and submenu flag for the menu items that will be label's siblings. class Item(object): def __init__(self, label, submenu): self.label = label self.submenu = submenu def __cmp__(self, rhs): if self.submenu != rhs.submenu: # self.submenu true comes before self.submenu false. return cmp(not self.submenu, not rhs.submenu) if self.label != rhs.label: return cmp(self.label, rhs.label) return 0 submenu_items = pm.menu(parent, q=True, ia=True) sibling_labels = [] for item in submenu_items: # Ignore options boxes. if pm.menuItem(item, q=True, optionBox=True): continue label = Item(item, pm.menuItem(item, q=True, subMenu=True)) sibling_labels.append(label) item = Item(name, subMenu) insertion_point = bisect.bisect_left(sibling_labels, item) if insertion_point == 0: return None else: return sibling_labels[insertion_point - 1].label
def _delete_login_menu(): """ Deletes the displayed Shotgun user login menu. """ if pm.menu(MENU_LOGIN, exists=True): pm.deleteUI(MENU_LOGIN)
def addmenu(): global _menu global _menuItems with mayautils.undo_on_error(): _menu = pmc.menu('HDR Interpolation', parent=mayautils.get_main_window_name()) item = pmc.menuItem(parent=_menu, label='Show Menu', command=show) _menuItems.append(item)
def build_menu(self): """ build spore main menu """ self.logger.debug('Build menu...') main_wnd = pm.language.melGlobals['gMainWindow'] menu = pm.menu('Spore', parent=main_wnd) pm.menuItem( l='Spore Manager', c='import sys;sys._global_spore_dispatcher.spore_manager.show()', parent=menu) pm.menuItem(divider=True) pm.menuItem(l='Create Spore', c='cmds.spore()', parent=menu) pm.menuItem(divider=True) pm.menuItem( l='Spore Globals', c='import sys;sys._global_spore_dispatcher.spore_globals.show()', parent=menu) pm.menuItem( l='Spore Reporter', c='import sys;sys._global_spore_dispatcher.spore_reporter.show()', parent=menu) pm.menuItem(l='Help', c='print help', parent=menu) if os.environ.get('SPORE_DEV_MODE', '0') == '1': pm.menuItem(l='Run tests', c='import test_util;test_util.run_tests_from_maya', parent=menu) return menu
def MakeMenu(menuTitle): """ Creates & returns a new menu instance. :param menuTitle: string, title for the menu. """ return pm.menu(menuTitle)
def refresh_engine(engine_name, prev_context, menu_name): """ refresh the current engine """ current_engine = tank.platform.current_engine() # first make sure that the disabled menu is reset, if it exists... if pm.menu("ShotgunMenuDisabled", exists=True): pm.deleteUI("ShotgunMenuDisabled") # if the scene opened is actually a file->new, then maintain the current # context/engine. if pm.sceneName() == "": return current_engine new_path = pm.sceneName().abspath() # this file could be in another project altogether, so create a new Tank # API instance. try: tk = tank.tank_from_path(new_path) except tank.TankError, e: OpenMaya.MGlobal.displayInfo("Shotgun: Engine cannot be started: %s" % e) # render menu create_tank_disabled_menu(menu_name) # (AD) - this leaves the engine running - is this correct? return current_engine
def _create_login_menu(): """ Creates and displays a Shotgun user login menu. """ # Creates the menu entry in the application menu bar. menu = pm.menu(MENU_LOGIN, label=MENU_LABEL, parent=pm.melGlobals["gMainWindow"]) # Add the login menu item. pm.menuItem( parent=menu, label="Log In to Shotgun...", command=pm.Callback(_login_user) ) pm.menuItem(parent=menu, divider=True) # Add the website menu items. pm.menuItem( parent=menu, label="Learn about Shotgun...", command=pm.Callback(_jump_to_website) ) pm.menuItem( parent=menu, label="Try Shotgun for Free...", command=pm.Callback(_jump_to_signup) )
def loadMenu(): # get user menu from menu.xml menuXmlPath = digital37.path.path(__file__).parent.joinpath('menu.xml') # get gMainWindow from mel command gMainWindow = pm.mel.eval('$tmpVar=$gMainWindow') print gMainWindow if gMainWindow: if menuXmlPath.exists(): menuLabel = '' menuName = 'digital37Menu' print('Build Menu : ' + menuName) # open xml document menuXml = xml.dom.minidom.parse(menuXmlPath) # search menu node for item in menuXml.getElementsByTagName('menu'): val = item.attributes["name"].value menuLabel = val.encode('latin-1', 'replace') # search and delete old menuName menuList = pm.window(gMainWindow, query=True, menuArray=True) for menu in menuList: if pm.menu(menu, query=True, label=True) == menuLabel: pm.menu(menu, edit=True, deleteAllItems=True) pm.deleteUI(menu) break # Add userMenu to Maya Menu pm.menu(menuName, parent=gMainWindow, tearOff=True, label=menuLabel, allowOptionBoxes=True) # build each menu for child in item.childNodes: if child.nodeType == 1: #loadMenu_recursive(child) nodename = child.nodeName nodetype = child.attributes["type"].value loadMenu_recursive(child, menuName)
def _add_menu_item_internal(self, name, insert_sorted=False, *args, **kwargs): if 'optionBox' in kwargs: # Maya creates an option box by adding it as a separate menu item. We do it # by passing optionBox=function when creating the menu item itself, since it # makes things simpler. option_box = kwargs['optionBox'] del kwargs['optionBox'] else: option_box = None # We always need a label, even for dynamic menu names, so we can tell where to # put the menu item when insert_sorted is true. assert 'label' in kwargs # Don't create menu items in batch mode. It causes a warning. if pm.about(batch=True): return # In case this menu item has already been created, remove the old one. _delete_menu_item(name) if insert_sorted: assert 'insertAfter' not in kwargs kwargs['insertAfter'] = self._get_sorted_insertion_point(name=name, subMenu=kwargs.get('subMenu', False), parent=kwargs.get('parent')) # If insertAfter is '' then the insertion point is the beginning. However, Maya prints # an incorrect warning if you say insertAfter='' and there are no items in the submenu, # so remove it in this case. if not pm.menu(kwargs.get('parent'), q=True, ia=True): del kwargs['insertAfter'] elif 'insertAfter' in kwargs and kwargs['insertAfter'] is None: # insertAfter=None causes the menu item to be added at the beginning. We want # that to add at the end, so remove the argument. This way, if a search for # a menu insertion point fails and returns None, we put things at the end (putting # them at the beginning is obnoxious). del kwargs['insertAfter'] item = pm.menuItem(name, *args, **kwargs) # Add the option box, if any. if option_box is not None: option_box_name = name + 'Options' _delete_menu_item(option_box_name) # Maya option boxes are weird: they're regular menu items, and they appear over the # previous menu item, so we need to add if after the above menu item. item_name = item.split('|')[-1] name = pm.menuItem(optionBox=True, command=option_box, insertAfter=item_name, parent=kwargs['parent']) self.menu_items.add(name) # self.menu_items is a list of items that we need to remove. Don't add submenus # to this list. Rather than deleting them directly when we're unloaded, we leave # them alone and use the empty menu cleanup down below to remove them, so if two # plugins create the same submenu and one is unloaded, it doesn't remove the other # plugin's menu with it. if not kwargs.get('subMenu'): self.menu_items.add(item) return item
def create(self, *args, **kwargs): ''' ''' if pm.control(self.windowName, exists = True): pm.deleteUI(self.windowName) if pm.control(self.dockName, exists = True): pm.deleteUI(self.dockName) if self.dockable: self.mainWindow = pm.window(self.windowName, t=self.windowName, menuBar=self.menuBar) else: self.mainWindow = pm.window(self.windowName, t=self.windowName, widthHeight=[self.width, self.height], menuBar=self.menuBar, rtf=self.rtf, mnb=self.mnb, mxb=self.mxb, s=self.sizeable) if self.menuBar: pm.menu(l='Help', helpMenu=True) pm.menuItem(l='blog.leocov.com', command=lambda *args: webbrowser.open('http://blog.leocov.com', new=2) ) pm.menu(l='Tools') pm.menuItem(l='Make Shelf Icon', command=lambda *args: shelf.makeShelfButton(self.windowName, self.shelfCommand, self.icon, self.annotation) )
def initialize(): """ This will setup the menu and interface mechanisms for the Crab Rigging Tool. :return: """ # -- If the menu already exists, we will delete it to allow # -- us to rebuild it if pm.menu(CRAB_MENU_OBJ, exists=True): pm.deleteUI(CRAB_MENU_OBJ) # -- Create the new menu for Crab new_menu = pm.menu( CRAB_MENU_OBJ, label=CRAB_MENU_NAME, tearOff=True, parent=pm.language.melGlobals['gMainWindow'], ) add_menu_item('Creator', crab.creator.launch) add_menu_item('Animator', crab.animator.launch) pm.menuItem(divider=True, parent=new_menu) add_menu_item('Edit', _menu_edit_rig) add_menu_item('Build', _menu_build_rig) pm.menuItem(divider=True, parent=new_menu) add_menu_item('Website', _menu_goto_website) pm.menuItem(divider=True, parent=new_menu) add_menu_item('Reload', _menu_reload) # -- We specifically only want this menu to be visibile # -- in the rigging menu cached_menu_set = pm.menuSet(query=True, currentMenuSet=True) rigging_menu_set = pm.mel.findMenuSetFromLabel("Rigging") # -- Set our menu to the rigging menu and add it to # -- the menu set pm.menuSet(currentMenuSet=rigging_menu_set) pm.menuSet(addMenu=new_menu) # -- Restore the users cached menu set pm.menuSet(currentMenuSet=cached_menu_set)
def create_sgtk_disabled_menu(menu_name): """ Render a special "shotgun is disabled" menu """ if cmds.about(batch=True): # don't create menu in batch mode return # destroy any pre-existing shotgun menu - the one that holds the apps if pm.menu("ShotgunMenu", exists=True): pm.deleteUI("ShotgunMenu") # create a new shotgun disabled menu if one doesn't exist already. if not pm.menu("ShotgunMenuDisabled", exists=True): sg_menu = pm.menu("ShotgunMenuDisabled", label=menu_name, parent=pm.melGlobals["gMainWindow"]) pm.menuItem(label="Sgtk is disabled.", parent=sg_menu, command=lambda arg: sgtk_disabled_message())
def update_shelf_submenu(parent_menu): """ Populate a shelf submenu with the contents of a shelf. """ shelf.refresh() # Gather the menu items, including submenus. pm.setParent(parent_menu, menu=True) menu_cmds = {} for shelf_button in shelf.buttons: if shelf_button is separator: continue menu_cmds[shelf_button] = get_menu_item_params( shelf_button, pm.shelfButton) popup_menu_items = get_shelf_submenus(shelf_button) for popup_menu_item in popup_menu_items: if popup_menu_item is separator: continue menu_cmds[popup_menu_item] = get_menu_item_params( popup_menu_item, pm.menuItem) # Store the list of popup menu item names as a dummy entry in menu_cmds. This # won't be looked up by add_shelf_item. This just makes sure that if the list of # popups changes, menu_cmds will be different from latest_menu_cmds and we'll refresh # the menu. menu_cmds['__popups_%s' % shelf_button] = popup_menu_items # If the menu hasn't changed since the last time it was displayed, don't update it. # Updating menus is usually fast, but sometimes becomes very slow for no obvious reason. if latest_menu_cmds == menu_cmds: return # Update latest_menu_cmds so we remember the latest update. latest_menu_cmds.clear() latest_menu_cmds.update(menu_cmds) # Clear the menu. pm.setParent(parent_menu, menu=True) pm.menu(parent_menu, e=True, deleteAllItems=True) for shelf_button in shelf.buttons: if shelf_button is separator: pm.menuItem(divider=True) else: add_shelf_item(parent_menu, menu_cmds, shelf_button)
def create_material_submenu(self, parent, namespace): pm.setParent(parent, menu=True) pm.menu(parent, e=True, deleteAllItems=True) # Add namespaces at the top of the list. namespaces = self.namespaces_by_namespace.get(namespace, []) for child_namespace in namespaces: self.create_namespace_submenu(child_namespace) # Put a divider between namespaces and materials. materials = self.materials_by_namespace.get(namespace, []) if namespaces and materials: pm.menuItem(divider=True) # Add materials in this namespace. for material in materials: self.add_material_item(parent, material)
def destroy_engine(self): self.log_debug("%s: Destroying..." % self) # stop watching scene events: self.__watcher.stop_watching() # clean up UI: if self.has_ui and pm.menu(self._menu_handle, exists=True): pm.deleteUI(self._menu_handle)
def loadMenu(): # get user menu from menu.xml menuXmlPath = digital37.path.path(__file__).parent.joinpath('menu.xml') # get gMainWindow from mel command gMainWindow = pm.mel.eval('$tmpVar=$gMainWindow') print gMainWindow if gMainWindow: if menuXmlPath.exists() : menuLabel = '' menuName = 'digital37Menu' print ('Build Menu : ' + menuName) # open xml document menuXml = xml.dom.minidom.parse(menuXmlPath) # search menu node for item in menuXml.getElementsByTagName('menu'): val = item.attributes["name"].value menuLabel = val.encode('latin-1', 'replace') # search and delete old menuName menuList = pm.window(gMainWindow, query=True, menuArray=True) for menu in menuList: if pm.menu(menu, query=True, label=True) == menuLabel: pm.menu(menu, edit=True, deleteAllItems=True) pm.deleteUI(menu) break # Add userMenu to Maya Menu pm.menu(menuName, parent=gMainWindow, tearOff=True, label=menuLabel, allowOptionBoxes=True) # build each menu for child in item.childNodes: if child.nodeType == 1 : #loadMenu_recursive(child) nodename = child.nodeName nodetype = child.attributes["type"].value loadMenu_recursive(child, menuName)
def make_test_items(): menu = pmc.menu( 'DemoMenu', parent=mayautils.get_main_window_name()) def makeitem(ind): def callback(_): print 'Item', ind item = pmc.menuItem( parent=menu, label='Item %s' % ind, command=callback) register_menuitem(item.name()) for i in range(5): makeitem(i)
def __init__(self): # Name Autodesk gives to main Maya window mainMayaWindow = pm.ui.PyUI("MayaWindow") # Check that it is actually created (just incase this is run before it) if type(mainMayaWindow) == pm.uitypes.Window: # Our menu self.rootMenu = pm.menu("myMenu", parent=mainMayaWindow) self.rootMenu.setLabel("My Menu") else: pm.warning("WARNING! Maya main window is not initialized yet!") pm.warning(" Pipeline menu is not created")
def post_app_init(self): """ Called when all apps have initialized """ # detect if in batch mode if self.has_ui: self._menu_handle = pm.menu("ShotgunMenu", label=self._menu_name, parent=pm.melGlobals["gMainWindow"]) # create our menu handler tk_maya = self.import_module("tk_maya") self._menu_generator = tk_maya.MenuGenerator(self, self._menu_handle) # hook things up so that the menu is created every time it is clicked self._menu_handle.postMenuCommand(self._menu_generator.create_menu)
def create_shotgun_menu(self): """ Creates the main shotgun menu in maya. Note that this only creates the menu, not the child actions :return: bool """ # only create the shotgun menu if not in batch mode and menu doesn't already exist if self.has_ui and not pm.menu("ShotgunMenu", exists=True): self._menu_handle = pm.menu("ShotgunMenu", label=self._menu_name, parent=pm.melGlobals["gMainWindow"]) # create our menu handler tk_maya = self.import_module("tk_maya") self._menu_generator = tk_maya.MenuGenerator(self, self._menu_handle) # hook things up so that the menu is created every time it is clicked self._menu_handle.postMenuCommand(self._menu_generator.create_menu) # Restore the persisted Shotgun app panels. tk_maya.panel_generation.restore_panels(self) return True return False
def populateSelectCamera(): # clear camera menu pm.menu('ArnoldSelectCamera', edit=True, deleteAllItems=True) coll = pm.radioMenuItemCollection(parent='ArnoldSelectCamera') # populate camera menu cameras = cmds.ls(type='camera') if cameras != None: activeCamera = core.ACTIVE_CAMERA if not activeCamera in cameras: activeCamera = None if activeCamera == None: if 'perspShape' in cameras: activeCamera = 'perspShape' elif len(cameras): activeCamera = cameras[0] core.ACTIVE_CAMERA = activeCamera for cam in cameras: pm.menuItem('SelectCameraItem%s' % cam, label=cam, parent='ArnoldSelectCamera', radioButton=cam == activeCamera, cl=coll, c='from mtoa.ui.arnoldmenu import selectCamera; selectCamera("%s")' % cam)
def __init__(self, iconPath): self.name = "Control_Creation_UI" self.title = "Create Controls" if (pm.window(self.name, q=1, exists=1)): pm.deleteUI(self.name) self.window = pm.window(self.title, widthHeight=(300, 300), resizeToFitChildren=1, menuBar=True) self.iconPath = iconPath icons = [f for f in os.listdir(self.iconPath) if f.endswith('.png')] #menu pm.menu( label='UI', helpMenu=True ) pm.menuItem( label='Create Icons', command = pm.Callback(self.createIcons)) form = pm.formLayout() tabs = pm.tabLayout(innerMarginWidth=5, innerMarginHeight=5) pm.formLayout( form, edit=True, attachForm=((tabs, 'top', 0), (tabs, 'left', 0), (tabs, 'bottom', 0), (tabs, 'right', 0))) child1 = pm.rowColumnLayout(numberOfColumns=3) for style in SimpleCurves.STYLES: if icons and "%s.png"%(style) in icons: iPath = os.path.join(self.iconPath, "%s.png"%(style)) pm.iconTextButton(label=style, style='iconAndTextVertical', image1=iPath, command = pm.Callback(self.simpleCurve, style)) else: pm.button(label=style, command = pm.Callback(self.simpleCurve, style)) pm.setParent( '..' ) child2 = pm.rowColumnLayout(numberOfColumns=2) pm.button() pm.setParent( '..' ) child3 = pm.rowColumnLayout(numberOfColumns=2) pm.button() pm.button() pm.button() pm.setParent( '..' ) pm.tabLayout( tabs, edit=True, tabLabel=((child1, 'Simple Curves'), (child2, 'Combo Controls'), (child3, 'Facial Controls')) ) pm.showWindow(self.window)