Python utils.Utils类代码示例

    def open():
        '''
        just a shortcut method to construct and display main window
        '''

        window = MainWindow.getInstance()
        
        if cmds.control(MainWindow.DOCK_NAME,q=True,exists=True):
            cmds.control(MainWindow.DOCK_NAME,e=True,visible=True)
        else:
            cmds.dockControl(MainWindow.DOCK_NAME,l=window.createWindowTitle(),content=MainWindow.WINDOW_NAME,
                             area='right',allowedArea=['right', 'left'],
                             width=window.preferedWidth.get(),
                             floating=window.preferedFloating.get(),
                             visibleChangeCommand=window.visibilityChanged)
            
            if window.preferedFloating.get():
                cmds.window(MainWindow.DOCK_NAME,e=True,
                            topEdge=window.preferedTop.get(),leftEdge=window.preferedLeft.get(),
                            w=window.preferedWidth.get(),h=window.preferedHeight.get())
        
            Utils.silentCheckForUpdates()
        
        # bring tab to front; evaluate lazily as sometimes UI can show other errors and this command somehow fails
        cmds.evalDeferred(lambda *args: cmds.dockControl(MainWindow.DOCK_NAME,e=True,r=True));
        
        # a bit of a fake, but can't find a better place for an infrequent save
        LayerEvents.layerAvailabilityChanged.addHandler(window.savePrefs, MainWindow.DOCK_NAME)
        
        return window

 def parseSelectionList(self,selectionList):
     '''
     calculates compacted internal selection list from the MSelectionList
     '''
     selection = []
     if selectionList is None or selectionList.isEmpty():
         return selection
     
     #compact selection list first
     mergedList = om.MSelectionList()
     mergedList.merge(selectionList,om.MSelectionList.kMergeNormal)
                              
     for i in Utils.mIter(om.MItSelectionList(mergedList)):
         # read selection item
         path = om.MDagPath()
         compSelection = om.MObject()
         i.getDagPath(path,compSelection)
         if not i.hasComponents() or not compSelection.hasFn(self.componentType):
             continue
         
         # create selection entry and fill it with components
         selEntry = MeshSelectEntry(path)
         for c in Utils.mIter(om.MItMeshVertex(path,compSelection)):
             selEntry.components.append(c.index())
         selection.append(selEntry)
     return selection

def closeNextDialogWithResult(result):
    '''
    close next modal dialog with given result
    '''
    if Utils.getMayaVersion()>=Utils.MAYA2011:
        mUtils.executeDeferred(lambda:BaseDialog.currentDialog.closeDialogWithResult(result))
    else:
        Utils.displayError("hurray for maya 2009, close dialog manually with result "+result)

    def selectPaintWeightsInfluence(self,infl):
        '''
        tries to select influence (provided as string) in current maya's paint weights context and UI
        if skin paint context is not available, nothing happens
        '''
        if not Utils.isCurrentlyPaintingWeights():
            return
        
        # influence name can come in any form ('joint3', 'joint2|joint3', 'joint1|joint2|joint3')
        # get the absolute shortest possible (but still unique) and longest
        try:
            longName = cmds.ls(infl,l=True)[0]
            shortName = cmds.ls(longName,l=False)[0]

            log.info("selecting in paint weights: influence %s" % str(infl))
        
            # try to work around with the mess in the earlier versions of 
            # maya's paint weights UI:
            if Utils.getMayaVersion()<Utils.MAYA2011:
                itemName = Utils.mel('artAttrSkinShortName("%s")'%shortName)
                Utils.mel('artSkinSelectInfluence("artAttrSkinPaintCtx","%s","%s");' % (shortName,itemName));
            else:
                Utils.mel('artSkinSelectInfluence("artAttrSkinPaintCtx","%s");' % shortName);
                
            # show paint weights interface
            cmds.toolPropertyWindow()
        except:
            # problems listing given influence.. just die here
            Utils.displayError('problem selecting influence %s' % infl)

    def initialize(self):
        log.debug("creating headless data host")
        
        LayerDataModel.reset()
        restartEvents()

        Utils.loadPlugin()

        MayaEvents.registerScriptJobs()
        
        LayerDataModel.getInstance()

 def closeDialogWithResult(self, buttonID):
     if buttonID==self.BUTTON_OK:
         self.controls.name.setValue(self.controls.name.getValue().strip())
         
         
         # check if valid layer name was entered
         # new layer mode should allow empty value
         if not self.newLayerMode and self.layerNameValue.get().strip()=='':
             Utils.confirmDialog( title='Validation Error', message="layer name cannot be blank", button=['Ok'], defaultButton='Ok')
             return
     
     
     BaseDialog.closeDialogWithResult(self, buttonID)

 def execCleanNodes(self,*args):
     if not LayerUtils.hasCustomNodes():
         Utils.confirmDialog(icon='information', title='Info', message='Scene does not contain any custom ngSkinTools nodes.', button=['Ok']);
         return
     
     message = 'This command deletes all custom nodes from ngSkinTools plugin. Skin weights will be preserved, but all layer data will be lost. Do you want to continue?'
     if Utils.confirmDialog(
             icon='warning',
             title='Warning', 
             message=message, 
             button=['Yes','No'], defaultButton='No')!='Yes':
         return
     
     LayerDataModel.getInstance().cleanCustomNodes()

 def execute(self):
     ldm = LayerDataModel.getInstance()
     for layerId in ldm.layerListsUI.getSelectedLayers():
         if ldm.mll.getLayerIndex(layerId)==0:
             Utils.displayError("Cannot merge lowest layer")
             return
         
         ldm.mll.layerMergeDown(layerId)
         
         
     
         
     LayerEvents.layerListModified.emit()
     self.onExecuted.emit()

    def initialize(self):
        log.debug("creating headless data host")
        self.scriptJobs = []

        LayerDataModel.reset()
        restartEvents()

        Utils.loadPlugin()

        self.registerScriptJob("SelectionChanged", MayaEvents.nodeSelectionChanged.emit)
        self.registerScriptJob("Undo", MayaEvents.undoRedoExecuted.emit)
        self.registerScriptJob("Redo", MayaEvents.undoRedoExecuted.emit)
        self.registerScriptJob("ToolChanged", MayaEvents.toolChanged.emit)

        LayerDataModel.getInstance()

 def update(self):
     if self.data.layerDataAvailable:
         return
     
     attachPoint = self.data.getLayersCandidateFromSelection()
     
     attachPossible = len(attachPoint)!=0
     selection = cmds.ls(sl=True,o=True)
     selectionAvailable = selection is not None and len(selection)>0
     
     if attachPossible:
         self.controls.label1.setLabel('Skin selected:')
         self.controls.label2.setLabel("%s (%s)" % tuple(map(Utils.shortName,tuple(attachPoint))))
     elif selectionAvailable:
         self.controls.label1.setLabel("Layer data cannot be attached to:")
         self.controls.label2.setLabel(Utils.shortName(selection[0]))
     else:
         self.controls.label1.setLabel("Nothing is selected")
         self.controls.label2.setLabel('')
     
     self.controls.label1.setEnabled(selectionAvailable)
     self.controls.label2.setEnabled(selectionAvailable)
     
     cmds.button(self.controls.addLayerDataButton,e=True,enable=attachPossible)
     

 def getLogicalInfluenceIndex(self,influenceName):
     try:
         path = Utils.getDagPathForNode(influenceName)
     except:
         raise MessageException("Could not find influence '%s' in %s" % (influenceName, self.skinCluster))
         
     return self.fn.indexForInfluenceObject(path)

    def open():
        '''
        just a shortcut method to construct and display main window
        '''

        window = MainWindow.getInstance()
        window.showWindow()
        
        # don't know where to fit this in, it's just an utility warning for those trying to run
        # this on a different maya version
        if Utils.getMayaVersion()==Utils.MAYAUNSUPPORTEDVERSION:
            Utils.displayError('unsupported Maya version detected.')
            
        Utils.silentCheckForUpdates()
        
        return window

 def useSkinClusterInputMesh(self,skinCluster):
     '''
     sets skincluster's input mesh as source mesh
     '''
     skinClusterObject = Utils.getMObjectForNode(skinCluster)
     geomFilter = oma.MFnGeometryFilter(skinClusterObject)
     self.meshMObject = geomFilter.inputShapeAtIndex(0)

    def getSelectionDagPaths(hilite):
        """
        similar functionality to cmds.ls, but returns transform nodes where shapes might be selected,
        and does not return components.
        """

        from maya import OpenMaya as om

        selection = om.MSelectionList()
        if hilite:
            om.MGlobal.getHiliteList(selection)
        else:
            om.MGlobal.getActiveSelectionList(selection)

        result = []
        for i in Utils.mIter(om.MItSelectionList(selection)):
            path = om.MDagPath()
            i.getDagPath(path)

            selectionPath = path.fullPathName()

            # if it's a shape node, extend upwards
            if path.node().hasFn(om.MFn.kShape):
                parentPath = om.MDagPath()
                om.MFnDagNode(om.MFnDagNode(path).parent(0)).getPath(parentPath)
                selectionPath = parentPath.fullPathName()

            if not selectionPath in result:
                result.append(selectionPath)

        return result

 def getFormats():
     '''
     returns iterator to available exporters
     '''
     yield Formats.getXmlFormat()
     if Utils.getMayaVersion() > Utils.MAYA2010:
         yield Formats.getJsonFormat()