def doEditPivotDriver(self, *args):

        newValue = mc.floatSliderButtonGrp(self.floatSlider, query=True, value=True)
        try:
            mc.deleteUI(self.pivotDriverWindow)
        except:
            pass

        currentValue = mc.getAttr(self.pivotDriver)
        if newValue == currentValue:
            return

        oldRP = mc.getAttr(self.node+'.rotatePivot')[0]
        mc.setAttr(self.pivotDriver, newValue)
        newRP = mc.getAttr(self.node+'.rotatePivot')[0]
        mc.setAttr(self.pivotDriver, currentValue)

        parentPosition = mc.group(em=True)
        offsetPosition = mc.group(em=True)
        offsetPosition = mc.parent(offsetPosition, parentPosition)[0]
        mc.setAttr(offsetPosition+'.translate', newRP[0]-oldRP[0], newRP[1]-oldRP[1], newRP[2]-oldRP[2])

        mc.delete(mc.parentConstraint(self.node, parentPosition))

        utl.matchBake(source=[self.node], destination=[parentPosition], bakeOnOnes=True, maintainOffset=False, preserveTangentWeight=False)

        mc.cutKey(self.pivotDriver)
        mc.setAttr(self.pivotDriver, newValue)
        mc.refresh()
        utl.matchBake(source=[offsetPosition], destination=[self.node], bakeOnOnes=True, maintainOffset=False, preserveTangentWeight=False, rotate=False)

        mc.delete(parentPosition)

def addCount():
    global progressCurrent
    global progressLength
    
    progressCurrent += 1
    
    row, left, right = uiInst._progressBarList[ progressIndex ]
    
    percent = progressCurrent/float(progressLength)
        
    leftWidth = percent*200
    rightWidth = 200-leftWidth
    
    if leftWidth < 1:
        leftWidth = 1
        rightWidth = 199
    if rightWidth < 1:
        leftWidth = 199
        rightWidth = 1
    
    cmds.rowColumnLayout( row, e=1, cw=[ (1,leftWidth),(2,rightWidth)] )
    if progressCurrent == 1: cmds.text( left, e=1, bgc=[1,1,0] )
    elif progressCurrent == progressLength: cmds.text( right, e=1, bgc=[1,1,0] )
    
    cmds.refresh()

def refresh():
    cmds.undoInfo(stateWithoutFlush=False)
    # cmds.refresh(force=True)
    # print "refresh"
    cmds.refresh(suspend=False)
    cmds.currentTime(cmds.currentTime(query=True), edit=True)
    cmds.undoInfo(stateWithoutFlush=True)

 def drag(self, *args):
     
     self.dragPoint = mc.draggerContext(self.draggerContext, query=True, dragPoint=True)
     
     #if this doesn't work, try getmodifier
     self.modifier = mc.draggerContext(self.draggerContext, query=True, modifier=True)
     
     self.x = ((self.dragPoint[0] - self.anchorPoint[0]) * self.multiplier) + self.defaultValue
     self.y = ((self.dragPoint[1] - self.anchorPoint[1]) * self.multiplier) + self.defaultValue
     
     if self.minValue is not None and self.x < self.minValue:
         self.x = self.minValue
     if self.maxValue is not None and self.x > self.maxValue:
         self.x = self.maxValue
     
     #dragString
     if self.modifier == 'control':
         if self.button == 1:
             self.dragControlLeft(*args)
         elif self.button == 2:
             self.dragControlMiddle(*args)
     elif self.modifier == 'shift':
         if self.button == 1:
             self.dragShiftLeft(*args)
         elif self.button == 2:
             self.dragShiftMiddle(*args)
     else:
         if self.button == 1:
             self.dragLeft()
         elif self.button == 2:
             self.dragMiddle()
     
     mc.refresh()

	def importAovs(self):
		"""import aovs into scene"""
		LayersInfo = pickle.load( open( self.aovsPath.path, "rb") )
		mc.refresh( su = 1 )
		for ao in LayersInfo.keys():
			aov.create( ao, LayersInfo[ao]['name'], LayersInfo[ao]['type'], LayersInfo[ao]['enabled'] )
		mc.refresh( su = 0 )

def bake(constraint,
         start=None,
         end=None,
         sampleBy=1,
         simulation=True):
    """
    Bake specified constraint
    @param constraint: Constraint to bake animation for.
    @type constraint: str
    @param start: Start frame of bake animation range
    @type start: float or None
    @param end: End frame of bake animation range
    @type end: float or None
    @param sampleBy: Sample every Nth frame
    @type sampleBy: int
    @param simulation: Simulation option for bakeResults
    @type simulation: bool
    """
    # ==========
    # - Checks -
    # ==========

    # Check Constraint
    if not glTools.utils.constraint.isConstraint(constraint):
        raise Exception('Object "' + constraint + '" is not a valid constraint node!')

    # Check Start/End Frames
    if start == None: start = cmds.playbackOptions(q=True, min=True)
    if end == None: end = cmds.playbackOptions(q=True, max=True)

    # ====================================
    # - Get Slave Transform and Channels -
    # ====================================

    # Get Slave Transform
    slave = glTools.utils.constraint.slave(constraint)

    # Get Slave Channels
    attrList = cmds.listConnections(constraint, s=False, d=True, p=True) or []
    slaveAttrs = [i.split('.')[-1] for i in attrList if i.startswith(slave + '.')] or []
    if not slaveAttrs: raise Exception('No slave channels to bake!')

    # ===================
    # - Bake Constraint -
    # ===================

    cmds.refresh(suspend=True)
    cmds.bakeResults(slave,
                   at=slaveAttrs,
                   time=(start, end),
                   disableImplicitControl=True,
                   simulation=simulation,
                   sampleBy=sampleBy)
    cmds.refresh(suspend=False)

    # =================
    # - Return Result -
    # =================

    return [slave + '.' + i for i in slaveAttrs]

    def onDrag(self):
        baseDraggerCtx.onDrag(self)

        cntrl, alt, shift = self.mods
        if self.btn ==1:
            if not cntrl and not alt and not shift:
                self.paintOnDrag()
            elif cntrl and not shift and not alt:
                self.paintOnPolyOnDrag()

            #curve(self.crv, append=1, p=[pnt])
        elif self.btn==2:
            if not cntrl and not shift and not alt:
                self.moveOpOnDrag()
            elif cntrl and not shift and not alt:
                self.moveOpOnDrag()
            elif cntrl and shift and not alt:
                self.moveOpOnDrag()
            elif not cntrl and shift and not alt:
                self.moveOpOnDrag()

            elif cntrl and shift and alt:
                self.moveEndsOpDrag()            


        mc.refresh(cv=True)

def fix(self):
    import os
    if os.name == 'posix':
        viewport.hide()
        cmds.refresh()
        viewport.show()
    pass

def suspend_refresh():
    """A context mananger that stops the graph from running or the view
    updating.

    Can be nested, where only the outermost context manager will resume
    refresing.

    ::

        >>> with suspend_refresh():
        ...     do_something_with_high_drawing_cost()


    .. seealso::

        There are caveats with disabling the refresh cycle. Be sure to 
        read about :cmds:`refresh`.

    """

    global _suspend_depth
    try:
        if not _suspend_depth:
            cmds.refresh(suspend=True)
        _suspend_depth += 1
        yield
    finally:
        _suspend_depth -= 1
        if not _suspend_depth:
            cmds.refresh(suspend=False)

 def duplicateObj( self, targetObj, skinNode, addName='_add' ):
     
     if cmds.nodeType( targetObj ) != 'transform':
         targetObj = cmds.listRelatives( targetObj, p=1 )
         
         if targetObj: targetObj = targetObj [0]
         else: return None
     targetShape = cmds.listRelatives( targetObj, s=1 )[0]
     targetAttr = targetShape+'.outMesh'
     outputAttr = cmds.listConnections( skinNode+'.input[0].inputGeometry', s=1, d=0, p=1, c=1 )[1]
     
     secondMesh = cmds.createNode( 'mesh' )
     thirdMesh  = cmds.createNode( 'mesh' )
     
     secondObj = cmds.listRelatives( secondMesh, p=1 )[0]
     thirdObj  = cmds.listRelatives( thirdMesh, p=1 )[0]
     
     cmds.connectAttr( targetAttr, secondMesh+'.inMesh' )
     cmds.connectAttr( outputAttr, thirdMesh +'.inMesh' )
     
     cmds.refresh()
     
     cmds.disconnectAttr( targetAttr, secondMesh+'.inMesh' )
     cmds.disconnectAttr( outputAttr, thirdMesh +'.inMesh' )
     
     secondObj = cmds.rename( secondObj, targetObj+addName )
     thirdObj  = cmds.rename( thirdObj , targetObj+addName+'_inv' )
     
     return secondObj, thirdObj

    def copyWorld(self, *args):
        #print "copyworld"
        self.selection   = cmds.ls(selection=True)
        
        if len(self.selection) < 1: return
        
        if len(self.selection) > 20: 
            message         = "Too many objects selected, continue?"
            confirm         = cmds.confirmDialog( title='Confirm', message=message, button=['Yes','No'], defaultButton='Yes', cancelButton='No', dismissString='No' )
            if confirm != 'Yes': return  
        
        cmds.refresh(suspend=True)
        cmds.undoInfo(stateWithoutFlush=False)
        
        self.flushCopyCache(force=True)        
        self.scriptJob()       
        
        self.sourceObjs = self.selection
        self.targetObj  = "world"
        
        for loopObj in self.sourceObjs:        
            matrix     = cmds.xform(loopObj, query=True, ws=True, matrix=True)

            self.copyCache.append(matrix)

        
        cmds.iconTextButton("fakeConstrainBtn", edit=True, image= uiMod.getImagePath("specialTools_fake_constrain_active"),         highlightImage= uiMod.getImagePath("specialTools_fake_constrain_active copy"))
       
        cmds.refresh(suspend=False)
        cmds.undoInfo(stateWithoutFlush=True)

 def putObjects(self, atCurrentFrame=False):
     # print self.sel
     # print self.putObjectList
     autoKey = cmds.autoKeyframe(q=True, state=True)
     cmds.autoKeyframe(state=False)
     # current #NO LONGER USED, REMOVE ONCE MERGED WITH WORK COPY OF KET
     # CLASS
     if atCurrentFrame:
         current = cmds.currentTime(q=True)
         if self.start > current:
             self.offset = current - self.start
         else:
             self.offset = ((self.start - current) * -1.0) + 0.0
         # print self.offset
     # put
     num = len(self.objects)
     i = 1
     uiEnable()
     for obj in self.objects:
         if cmds.objExists(obj.name):
             message(str(i) + ' of ' + str(num) + ' --  ' + obj.name, maya=True)
             cmds.refresh(f=1)
             obj.offset = self.offset
             obj.putAttribute()
         else:
             cmds.warning(
                 'Object   ' + obj.name + '   does not exist, skipping.')
         i = i + 1
     uiEnable()
     cmds.autoKeyframe(state=autoKey)

def duplicateOnlyCurve( curves ):
    
    import sgBFunction_dag
    curves = sgBFunction_dag.getChildrenCurveExists( curves )
    
    newCurves = []
    for curve in curves:
        curveP = sgBFunction_dag.getParent( curve )
        if curveP:
            newCurveParent = sgBFunction_dag.makeCloneObject( curveP )
        else:
            newCurveParent = None
        
        newCurveShape = cmds.createNode( 'nurbsCurve' )
        curveShape = sgBFunction_dag.getShape( curve )
        cmds.connectAttr( curveShape+'.local', newCurveShape+'.create' )
        
        newCurve = sgBFunction_dag.getTransform( newCurveShape )
        newCurve = cmds.rename( newCurve, 'du_' + curve.split( '|' )[-1] )
        if newCurveParent:
            newCurve = cmds.parent( newCurve, newCurveParent )[0]
        newCurves.append( newCurve )
    
    cmds.refresh()
    
    for i in range( len( newCurves ) ):
        curveShape = sgBFunction_dag.getShape( curves[i] )
        newCurveShape = sgBFunction_dag.getShape( newCurves[i] )
        if cmds.isConnected( curveShape+'.local', newCurveShape+'.create' ):
            cmds.disconnectAttr( curveShape+'.local', newCurveShape+'.create' )
    
    return newCurves

 def drag(self, *args):
     '''Called continuously when holding the mouse button down, updates self.x and self.y with the mouse position,
     and runs the corresponding method for whichever button is being pressed.'''
     self.dragPoint = mc.draggerContext(self.draggerContext, query=True, dragPoint=True)
     
     self.x = ((self.dragPoint[0] - self.anchorPoint[0]) * self.multiplier) + self.defaultValue
     self.y = ((self.dragPoint[1] - self.anchorPoint[1]) * self.multiplier) + self.defaultValue
     
     if self.minValue is not None and self.x < self.minValue:
         self.x = self.minValue
     if self.maxValue is not None and self.x > self.maxValue:
         self.x = self.maxValue
     
     #dragString
     if self.modifier == 'control':
         if self.button == 1:
             self.dragControlLeft()
         elif self.button == 2:
             self.dragControlMiddle()
     elif self.modifier == 'shift':
         if self.button == 1:
             self.dragShiftLeft()
         elif self.button == 2:
             self.dragShiftMiddle()
     else:
         if self.button == 1:
             self.dragLeft()
         elif self.button == 2:
             self.dragMiddle()
     
     mc.refresh()

def createInCurveFromCurve( numCurve ):
    
    import sgBFunction_surface
    import sgBFunction_dag
    
    def optimizeConnection( targetObject ):
        targetShape = sgBFunction_dag.getShape( targetObject )
        src = cmds.listConnections( targetShape + '.create', p=1 )[0]
        dst = cmds.listConnections( targetShape, d=1, s=0, p=1,type="volumeCurvesOnSurface" )[0]
        cmds.connectAttr( src, dst, f=1 )
        cmds.delete( targetObject )
    
    curves = sgBFunction_dag.getChildrenShapeExists( cmds.ls( sl=1 ) )

    surface = sgBFunction_surface.getLoftSurfaceFromSelCurves( curves, True )
    curves = sgBFunction_surface.createInCurve( surface, numCurve )
    
    surfShape = cmds.listRelatives( surface, s=1, f=1 )[0]
    reverseNode = cmds.listConnections( surfShape, s=1, type='reverseSurface' )[0]
    cmds.setAttr( reverseNode+'.direction', 0  )
    cmds.refresh()
    cmds.setAttr( reverseNode+'.direction', 3  )
    cmds.refresh()
    cmds.select( curves )
    #cmds.setAttr( surfShape+'.io', 1 )
    optimizeConnection( surfShape )
    
    return curves

def updateOutMesh(srcMesh=None, outMesh=None, force=True):
    """
    Update given outMesh, then remove connection

    :param srcMesh: Source mesh
    :type srcMesh: str
    :param outMesh: Out mesh
    :type outMesh: str
    :param force: Force connection
    :type force: True
    """
    # --- Check Object List ---#
    if srcMesh is None and outMesh is None:
        selObjects = mc.ls(sl=True)
        print selObjects
        if not selObjects:
            print "!!! Error: Select srcMesh, then outMesh !!!"
        else:
            srcMesh = selObjects[0]
            outMesh = selObjects[1]
    # --- Update Mesh ---#
    connectOutMesh(srcMesh, outMesh, force=force)
    mc.refresh()
    mc.disconnectAttr("%s.worldMesh" % srcMesh, "%s.inMesh" % outMesh)
    print "// Update %s.worldMesh ---> %s.inMesh" % (srcMesh, outMesh)

 def loadData(self, onlySelectedNodes=False, crashFolder=None, *args):  
     
     cmds.waitCursor(state=True)
     cmds.refresh(suspend=True)
     cmds.undoInfo(openChunk=True)
     utilMod.startProgressBar("aTools Animation Crash Recovery - Loading data...")                
     
     self.pause      = True
     savedData       = self.getSavedData(crashFolder, onlySelectedNodes)
             
     if savedData:
     
         animData    = savedData["animData"]["data"]
         attrData    = savedData["attrData"]["data"] 
     
         self.applyAttrData(attrData)
         self.applyAnimData(animData)
         if not crashFolder: self.loadInfoData()
     
     utilMod.setProgressBar(endProgress=True)
     
     self.pause = False
     
     cmds.undoInfo(closeChunk=True)
     cmds.refresh(suspend=False)    
     cmds.waitCursor(state=False)

 def rigUpdate(self):
     #disable refresh until the rig update is complete
     cmds.refresh(su=True)
     rigNodeFound = False
     try:
         rigGuiNode = self.scene.sceneNodes["Rig"]
         rigNodeFound = True
     except KeyError:
         rigNodeFound = False
     if rigNodeFound:
         #kill all script jobs created by controllers to avoid
         #an update loop which the rig is updated
         for jobNum in self.scriptJobNumbers:
             if jobNum != globals.currentScriptJobNum:
                 cmds.scriptJob(k=jobNum)
         self.scriptJobNumbers = []
         rigGuiNode.updateVersion += 0.1
         rootElem = self.recursiveGetXML(rigGuiNode)
         self.indent(rootElem)
         tree = xml.ElementTree(rootElem)
         file = open(self.updateXmlPath, 'w')
         tree.write(file)
         file.close()
         self.recursiveZeroOutControllers(rigGuiNode)
         if rigGuiNode.metaNodeName is not None and rigGuiNode.metaNodeName != "":
             self.rootNodeName = mel.eval("updateMetaDataManager -n \""+rigGuiNode.metaNodeName+"\";")
         else:
             self.rootNodeName = mel.eval("loadRig -p \""+self.updateXmlPath+"\";")
         cmds.select(cl=True)
         self.recursiveUpdateMetaNodes(rigGuiNode,self.rootNodeName)
         self.recursiveSetupScriptJobs(rigGuiNode)
     cmds.refresh(su=False)

    def doPress( self, event ):
        
        if event.mouseButton() == OpenMayaUI.MEvent.kMiddleMouse: 
            cmds.select( d=1 )
            self.beforeJoint = None
            return None
        
        self.transform = None
        mouseX, mouseY = self.getMouseXY( event )

        intersectPoint = Functions.getIntersectPoint( self.dagPath, mouseX, mouseY )
        if not intersectPoint: 
            return None
        
        if not self.beforeJoint:
            cmds.select( d=1 )
        self.transform = cmds.joint()    
        cmds.select( self.transform )
        self.beforePosition = cmds.xform( self.transform, q=1, ws=1, t=1 )[:3]
        cmds.undoInfo( swf=0 )
        cmds.move( intersectPoint.x, intersectPoint.y, intersectPoint.z, self.transform, ws=1 )
        self.currentPosition = [intersectPoint.x, intersectPoint.y, intersectPoint.z]
        
        if self.beforeJoint:
            Functions.setOrientByChild( self.beforeJoint )
            cmds.setAttr( self.transform + '.r', 0,0,0 )
        
        cmds.refresh()

def GenTerrain(DATA_SIZE, SEED, h, j):
	
	createTerrainData(DATA_SIZE, SEED, h, j)
	
	name = 'Terrain'
	totalPoints=(DATA_SIZE)*(DATA_SIZE)
	
	if (cmds.objExists(name) == True):
		cmds.delete(name)
    
	cmds.polyPlane( n=name, sx=(DATA_SIZE-1), sy=(DATA_SIZE-1), h=20, w=20)
	count = 0
	
	cmds.progressWindow(title='Setting Points', progress=count, max = totalPoints, status='Setting: 0/'+str(totalPoints))            
                         
	for i in xrange(DATA_SIZE):
		if True: cmds.refresh()
		cmds.delete(name, ch = True)
		for j in xrange(DATA_SIZE):
					offset = dataArray[i][j]
					cmds.polyMoveVertex( name+'.vtx['+str(count)+']', ws = True, ty = offset, cch=True)
					cmds.progressWindow(edit=True, progress=count, status='Setting: '+str(count))
					count+=1
                                    
	cmds.progressWindow(endProgress=1)

	#cmds.polySmooth(n=name, cch = True)
	cmds.delete(name, ch = True)