def refreshSettingsFromSelection(self):
     layersAvailable = LayerDataModel.getInstance().getLayersAvailable()
     currentLimit = 0 if not layersAvailable else LayerDataModel.getInstance().mll.getInfluenceLimitPerVertex()
     
     self.controls.numMaxInfluences.setValue(max(1,currentLimit))
     self.controls.useInfluenceLimit.setValue(currentLimit!=0)
     self.updateUIEnabled()

    def applyCurrentSkinSettings(self):
        limit = 0 if not self.controls.useInfluenceLimit.isChecked() else self.controls.numMaxInfluences.getModelValue()
        LayerDataModel.getInstance().mll.setInfluenceLimitPerVertex(limit)

        pruneFilter = 0.00 if not self.controls.usePruneFilter.isChecked() else self.controls.pruneFilterValue.getModelValue()
        LayerDataModel.getInstance().mll.setPruneWeightsFilter(threshold=pruneFilter)
        
        self.updateUIEnabled()

 def execute(self):
     influencesMapping = MllInterface.influencesMapToList(self.mapper.mapping)
     mirrorAxis = TransferWeightsTab.axisValues[self.mapper.distanceMatchRule.mirrorAxis]
     
     cmds.ngSkinLayer(initMirrorData=True, influencesMapping=influencesMapping, mirrorAxis=mirrorAxis)
     
     LayerDataModel.getInstance().mll.setManualMirrorInfluences(self.mapper.manualOverrides)
     
     LayerDataModel.getInstance().updateMirrorCacheStatus()

 def updatePreferedValues(self):
     if self.mirrorMode:
         preferedMirrorAxis = LayerDataModel.getInstance().mirrorCache.mirrorAxis
         if preferedMirrorAxis is None:
             preferedMirrorAxis = 'X'
         self.controls.mirrorAxis.setValue(TransferWeightsTab.axisValues.index(preferedMirrorAxis.upper()))
     
     if self.mirrorMode and LayerDataModel.getInstance().layerDataAvailable:
         self.manualOverrides = LayerDataModel.getInstance().mll.getManualMirrorInfluences()
     else:
         self.manualOverrides = {}

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

        Utils.loadPlugin()

        MayaEvents.registerScriptJobs()
        
        LayerDataModel.getInstance()

 def internalEditLabelCommand(self, item, newName):
     '''
     implements layer in-place rename
     '''
     # do not allow empty layer names
     if newName.strip()=='':
         return ''
     
     LayerDataModel.getInstance().setLayerName(int(item),newName)
     cmds.treeView(self.control,e=True,displayLabel=(item,newName))
     return item

    def refreshSettingsFromSelection(self):
        layersAvailable = LayerDataModel.getInstance().getLayersAvailable()

        currentLimit = 0 if not layersAvailable else LayerDataModel.getInstance().mll.getInfluenceLimitPerVertex()
        self.controls.numMaxInfluences.setValue(max(3,currentLimit))
        self.controls.useInfluenceLimit.setValue(currentLimit!=0)
        
        pruneFilterValue = 0 if not layersAvailable else LayerDataModel.getInstance().mll.getPruneWeightsFilter()
        self.controls.pruneFilterValue.setValue(max(0.01,min(1,pruneFilterValue)))
        self.controls.usePruneFilter.setValue(pruneFilterValue!=0)
        
        self.updateUIEnabled()

 def buildInfluenceMappingEngine(self,controls):
     '''
     builds influence transfer mapping, using parameters from UI
     '''
     mapping = TransferDataModel.buildInfluenceMappingEngine(self,controls)
     mapping.sourceInfluences = LayerDataModel.getInstance().mll.listInfluenceInfo();
         
     mapping.mirrorMode = True
     
     mapping.manualOverrides = LayerDataModel.getInstance().mll.getManualMirrorInfluences()
     
     return mapping

 def execute(self):
     defaultLayerName = "New Layer"
     dlg = LayerPropertiesDialog(newLayerMode=True)
     dlg.layerNameValue.set("")
     if dlg.execute()!=dlg.BUTTON_OK:
         return
     
     newLayerName = dlg.layerNameValue.get()
     if newLayerName.strip()=="":
         newLayerName = defaultLayerName
     LayerDataModel.getInstance().addLayer(newLayerName)
     self.onExecuted.emit()

 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 execInfluenceSelected(self,*args):
        '''
        selection change handler for .influenceDisplay
        '''
        targetId = self.controls.influenceDisplay.getSelectedID();
        
        if targetId is None:
            return
        
        LayerDataModel.getInstance().mll.setCurrentPaintTarget(targetId)

        LayerEvents.currentInfluenceChanged.emit()
        
        log.info("selected logical influence {0}".format(targetId))

    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 updateLayoutEnabled(self):
     '''
     updates UI enabled/disabled flag based on layer data availability
     '''
     enabled = LayerDataModel.getInstance().layerDataAvailable==True
     cmds.layout(self.cmdLayout.innerLayout,e=True,enable=enabled)
     cmds.layout(self.cmdLayout.buttonForm,e=True,enable=enabled)

 def onOpacitySliderChange(self):
     '''
     emits when opacity slider in the dialog changes value
     '''
     currLayer = LayerDataModel.getInstance().getCurrentLayer()
     if currLayer is not None:
         cmds.ngSkinLayer(e=True,id=currLayer,opacity=self.dlg.layerOpacityValue.get())

 def execPruneWeights(self):
     ldm = LayerDataModel.getInstance()
     for layerId in ldm.layerListsUI.getSelectedLayers():
         if self.controls.pruneWeights.getValue():
             ldm.mll.pruneWeights(layerId=layerId,threshold=self.controls.pruneWeightsThreshold.getValue())
         if self.controls.pruneMask.getValue():
             ldm.mll.pruneMask(layerId=layerId,threshold=self.controls.pruneMaskThreshold.getValue())

 def layerDropped(self,layers,newParent,itemBefore,itemAfter):
     '''
     final handler of drag-drop action in layers list
     '''
     
     mll = LayerDataModel.getInstance().mll
     
     with mll.batchUpdateContext():
         # first, order layers by index, and start the "drop" with lowest index
         layers = sorted(layers,key=lambda layer:mll.getLayerIndex(layer),reverse=True)
         
         if newParent:
             itemAfter = None
             itemBefore = newParent
 
         for layer in layers:
             # as layers are shifted, indexes change for target layers
             currentIndex = mll.getLayerIndex(layer)
             
             targetIndex = 0
             if itemAfter:
                 targetIndex = mll.getLayerIndex(itemAfter)+1
             elif itemBefore:
                 targetIndex = mll.getLayerIndex(itemBefore)
 
             # fix index when moving up            
             if targetIndex>currentIndex:
                 targetIndex -= 1
                 
             mll.setLayerIndex(layer,targetIndex)
             
             # for subsequent layers, drop after this layer
             itemBefore = layer
             itemAfter = None

 def isEnabled(self):
     model = LayerDataModel.getInstance()
     if model is None:
         return False
     if not model.mirrorCache.isValid:
         return False
     return BaseLayerAction.isEnabled(self)

 def updateCacheInfo(self):
     '''
     updates UI according to new mirror cache status
     '''
     
     self.controls.labelCacheInfo.setLabel(LayerDataModel.getInstance().mirrorCache.message)
     self.updateInfluenceList()

    def execInitMirrorData(self):
        kargs = {};
        kargs["initMirrorData"] = True;
        kargs["influenceAssociationDistance"] = self.controls.influenceDistanceError.getValue()
        kargs["mirrorAxis"] = self.controls.mirrorAxis.getSelectedText()


        # create a comma-delimited prefix string, stripping away any spaces 
        # that might be specified in the user input        
        prefixes = self.controls.influencePrefixes.getValue()
        kargs["influenceAssociationPrefix"] = ",".join([prefix.strip() for prefix in prefixes.split(",")])
        
        cmds.ngSkinLayer(**kargs)
        
        LayerDataModel.getInstance().updateMirrorCacheStatus()

        self.updateInfluenceList()

 def updateUIEnabled(self):
     layersAvailable = LayerDataModel.getInstance().getLayersAvailable()
     
     Layout.setEnabled(self.controls.selectedSkinSettingsGroup,layersAvailable)
     if not layersAvailable:
         return
     
     self.controls.influenceLimitRow.setEnabled(self.controls.useInfluenceLimit.getModelValue())