def load():
    '''loads animation environment'''
    print "loading animation environment presets..."
    #set autoKey
    cmds.autoKeyframe( state=True )
    #set 24fps and playback on all viewports
    cmds.playbackOptions(ps=1.0, v='all')
    #set unlimited undo's
    cmds.undoInfo( state=True, infinity=True )
    #set manipulator sizes
    if lib.checkAboveVersion(2014):
        cmds.manipOptions( r=False, hs=55, ls=4, sph=1 )
    else:
        cmds.manipOptions( r=False, hs=55, ls=4 )
    #set framerate visibility
    mel.eval("setFrameRateVisibility(1);")
    #gimbal rotation
    cmds.manipRotateContext('Rotate', e=True, mode=2)
    #world translation
    cmds.manipMoveContext('Move', e=True, mode=2)
    #time slider height
    aPlayBackSliderPython = mel.eval('$tmpVar=$gPlayBackSlider')
    cmds.timeControl(aPlayBackSliderPython, h=45, e=True);
    #special tick color
    cmds.displayRGBColor("timeSliderTickDrawSpecial", 1,0.5,0)

    #check if hotkeys have been set
    if (cmds.hotkey( 't', ctl=True, query=True, name = True)== 'CharacterAnimationEditorNameCommand'):
        print "Hotkeys have been previously loaded"
    else:
        setHotkeys('default')

    print "ENVIRONMENT SET\n", #the comma forces output on the status line

 def store(self):
     '''
     store animation
     '''
     # make sure o
     if self.poseOnly:
         self.mtrx.append(cmds.xform(self.obj, q=True, m=True, ws=True))
     else:
         if self.keys:
             current = cmds.currentTime(q=True)
             # ui off
             cn.uiEnable(controls='modelPanel')
             # autokey state
             autoK = cmds.autoKeyframe(q=True, state=True)
             cmds.autoKeyframe(state=False)
             for key in self.keys:
                 cmds.currentTime(key)
                 self.pos.append(cmds.xform(self.obj, q=True, rp=True, ws=True))
                 self.rot.append(cmds.xform(self.obj, q=True, ro=True, ws=True))
                 self.mtrx.append(cmds.xform(self.obj, q=True, m=True, ws=True))
             # restore everything
             cmds.currentTime(current)
             cmds.autoKeyframe(state=autoK)
             cn.uiEnable(controls='modelPanel')
         else:
             message('No keys, forcing timeline range.', maya=True)
             self.keys = range(int(self.rng.start), int(self.rng.end))
             self.rng.keyStart = self.rng.start
             self.rng.keyEnd = self.rng.end
             self.store()

def changeRO(obj, ro):
    '''
    '''
    roLst = ['xyz', 'yzx', 'zxy', 'xzy', 'yxz', 'zyx']
    if cmds.getAttr(obj + '.rotateOrder', settable=1):
        keyframes = getKeyedFrames(obj)
        origRO = cmds.getAttr(obj + '.rotateOrder')
        if ro != roLst[origRO]:
            if keyframes:
                cn.uiEnable(controls='modelPanel')
                r = getRange()
                autoK = cmds.autoKeyframe(q=True, state=True)
                cmds.autoKeyframe(state=False)
                i = r[0]
                current = r[2]
                cmds.currentTime(i)
                cmds.currentTime(cmds.findKeyframe(which='previous'))
                cmds.xform(obj, roo=ro)
                for key in keyframes:
                    cmds.currentTime(key)
                    cmds.setAttr(obj + '.rotateOrder', origRO)
                    cmds.xform(obj, roo=ro)
                    cmds.setKeyframe(obj + '.rotate')
                cmds.currentTime(current)
                cmds.autoKeyframe(state=autoK)
                cn.eulerFilter(obj, tangentFix=True)
                cn.uiEnable(controls='modelPanel')
            else:
                cmds.xform(obj, roo=ro)
            # done
            message('Rotate order changed: -- ' + roLst[origRO] + '   to   ' + ro, maya=True)
        else:
            message('Rotate order already set -- ' + ro)
    else:
        message('FAIL. Rotate order is LOCKED or CONNECTED to a custom attribute.', maya=True)

	def func( *args, **kwargs ):
		initialState = cmd.autoKeyframe( q=True, state=True )
		cmd.autoKeyframe( state=False )
		try:
			return f( *args, **kwargs )
		finally:
			cmd.autoKeyframe( state=initialState )

    def __exit__(self, *exc_info):

        cmds.autoKeyframe(state=self.autoKeyState)
        cmds.currentTime(self.time)

        if self.selection:
            cmds.select(self.selection)

 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 distributeKeys(step=3.0, destructive=True, forceWholeFrames=True):
    '''
    operates on selected curves
    '''
    s = GraphSelection()
    sel = cmds.ls(sl=1, fl=True)
    rng = fr.Get()
    if s.crvs:
        # gather info
        autoK = cmds.autoKeyframe(q=True, state=True)
        frames = getKeyedFrames(s.crvs)
        # process start/end of loop
        framesNew = []
        if rng.selection:
            for f in frames:
                if f >= rng.keyStart and f <= rng.keyEnd:
                    framesNew.append(f)
            frames = framesNew
        #
        cut = []
        # print frames
        if forceWholeFrames:
            framesOrig = frames
            frames = [round(frame) for frame in frames]
            framesPartial = list(set(framesOrig) - set(frames))
            cut = [frame for frame in framesPartial]
            # print cut, '______cut'
        lastFrame = frames[len(frames) - 1]
        count = frames[0]
        i = frames[0]
        # turn off autokey
        cmds.autoKeyframe(state=False)
        framesNew = []
        # process keys
        while i < lastFrame:
            if i == count:
                cmds.setKeyframe(s.crvs, i=True, t=count)
                framesNew.append(count)
                count = count + step
            else:
                if i in frames:
                    cut.append(i)
            i = i + 1
        # remove keys is destructive
        if destructive:
            framesDel = sorted(list(set(frames) - set(framesNew)))
            for frame in framesDel:
                cut.append(frame)
            # print framesOrig, '________orig'
            # print framesNew, '________new'
            # print cut, '_________cut'
            if cut:
                for frame in cut:
                    if frame >= rng.keyStart and frame <= rng.keyEnd:
                        cmds.cutKey(sel, clear=1, time=(frame, frame))
        # restore autokey
        cmds.autoKeyframe(state=autoK)
    else:
        message('Select one or more anima curves', maya=1)

    def restoreSettings(self):
        '''
        restore all UI settings
        '''
        cmds.autoKeyframe(state=self.dataStore['autoKey'])

        # timeline management
        cmds.currentTime(self.dataStore['currentTime'])
        cmds.playbackOptions(min=self.dataStore['minTime'])
        cmds.playbackOptions(max=self.dataStore['maxTime'])
        cmds.playbackOptions(ast=self.dataStore['startTime'])
        cmds.playbackOptions(aet=self.dataStore['endTime'])
        cmds.playbackOptions(ps=self.dataStore['playSpeed'])
        cmds.playbackOptions(loop=self.dataStore['playLoop'])

        # unit management
        cmds.currentUnit(time=self.dataStore['timeUnit'])
        cmds.currentUnit(linear=self.dataStore['sceneUnits'])
        if not cmds.upAxis(axis=True, q=True) == self.dataStore['upAxis']:
            cmds.upAxis(axis=self.dataStore['upAxis'])

        log.debug('Restored PlayBack / Timeline setup')

        # viewport colors
        cmds.displayPref(displayGradient=self.dataStore['displayGradient'])
        cmds.displayRGBColor(resetToSaved=True)

        # objects colors
        cmds.displayColor("curve", self.dataStore['curvecolor'], dormant=True)

        # panel management
        for panel, data in self.dataStore['panelStore'].items():
            try:
                cmdString = data['settings'].replace('$editorName', panel)
                mel.eval(cmdString)
                log.debug("Restored Panel Settings Data >> %s" % panel)
                mel.eval('lookThroughModelPanel("%s","%s")' % (data['activeCam'], panel))
                log.debug("Restored Panel Active Camera Data >> %s >> cam : %s" % (panel, data['activeCam']))
            except:
                log.debug("Failed to fully Restore ActiveCamera Data >> %s >> cam : %s" % (panel, data['activeCam']))

        # camera management
        for cam, settings in self.dataStore['cameraTransforms'].items():
            try:
                cmds.setAttr('%s.translate' % cam, settings[0][0][0], settings[0][0][1], settings[0][0][2])
                cmds.setAttr('%s.rotate' % cam, settings[1][0][0], settings[1][0][1], settings[1][0][2])
                cmds.setAttr('%s.scale' % cam, settings[2][0][0], settings[2][0][1], settings[2][0][2])
                log.debug('Restored Default Camera Transform Data : % s' % cam)
            except:
                log.debug("Failed to fully Restore Default Camera Transform Data : % s" % cam)

        # sound management
        if self.dataStore['displaySound']:
            cmds.timeControl(self.gPlayBackSlider, e=True, ds=1, sound=self.dataStore['activeSound'])
            log.debug('Restored Audio setup')
        else:
            cmds.timeControl(self.gPlayBackSlider, e=True, ds=0)
        log.debug('Scene Restored fully')
        return True

 def __exit__(self, *args):
         
     #reset settings
     mc.cycleCheck(evaluation=self.resetCycleCheck)
     mc.autoKeyframe(state=self.resetAutoKey)
     
     if self.sel:
         mc.select(self.sel)
         
     self.isolate(False)

	def func(*args, **kwargs):
		initialState = cmd.autoKeyframe(q=True, state=True)
		cmd.autoKeyframe(state=False)
		try:
			ret = f(*args, **kwargs)
		except:
			raise
		finally:
			cmd.autoKeyframe(state=initialState)

		return ret

 def __exit__(self, exc_type, exc_value, traceback):
     # Close the undo chunk, warn if any exceptions were caught:
     cmds.autoKeyframe(state=self.autoKeyState)
     cmds.currentTime(self.timeStore)
     log.info('autoKeyState restored: %s' % self.autoKeyState)
     log.info('currentTime restored: %f' % self.timeStore)
     cmds.undoInfo(closeChunk=True)
     if exc_type:
         log.exception('%s : %s'%(exc_type, exc_value))
     # If this was false, it would re-raise the exception when complete
     return True

	def actualFunc(*args):
		start = time.clock()
		initialAutoKeyState = cmd.autoKeyframe(q=True,state=True)
		cmd.autoKeyframe(state=False)
		api.mel.zooAllViews(0)

		retVal = f(*args)

		api.mel.zooAllViews(1)
		cmd.autoKeyframe(state=initialAutoKeyState)
		print 'time taken',time.clock()-start,'secs'
		return retVal

 def __enter__(self):
 
     self.sel = mc.ls(sl=True)
     self.modelPanels = mc.getPanel(type='modelPanel')
     self.isolate(True)
     
     mc.select(clear=True)
     
     #save and turn off settings that might print to the script editor
     self.resetCycleCheck = mc.cycleCheck(query=True, evaluation=True)
     mc.cycleCheck(evaluation=False)
     
     self.resetAutoKey = mc.autoKeyframe(query=True, state=True)
     mc.autoKeyframe(state=False)

def distributeKeys(count=3.0, destructive=True):
    sel = cmds.ls(sl=1, fl=True)
    rng = fr.Get()
    if sel:
        # gather info
        autoK = cmds.autoKeyframe(q=True, state=True)
        frames = getKeyedFrames(sel)
        if not frames:
            # add a bake if no keys exist, then get keys again
            message('No keys found, setting a key start/end of range.', maya=1)
            cmds.setKeyframe(sel, t=(rng.start, rng.start))
            cmds.setKeyframe(sel, t=(rng.end, rng.end))
            frames = getKeyedFrames(sel)
            # return None
        # process start/end of loop
        framesNew = []
        if rng.selection:
            for f in frames:
                if f >= rng.keyStart and f <= rng.keyEnd:
                    framesNew.append(f)
            frames = framesNew
        #
        print frames
        lastFrame = frames[len(frames) - 1]
        step = frames[0]
        i = frames[0]
        cut = []
        # turn off autokey
        cmds.autoKeyframe(state=False)
        # process keys
        while i < lastFrame:
            if i == step:
                cmds.setKeyframe(sel, i=True, t=step)
                step = step + count
            else:
                if i in frames:
                    cut.append(i)
            i = i + 1
        # remove keys is destructive
        if destructive:
            # print cut, '_________'
            if cut:
                for frame in cut:
                    cmds.cutKey(sel, clear=1, time=(frame, frame))
        # restore autokey
        cmds.autoKeyframe(state=autoK)
    else:
        message('Select one or more objects', maya=1)

    def restoreSettings(self):
        '''
        restore all UI settings
        '''
        cmds.autoKeyframe(state=self.dataStore['autoKey'])
        
        #timeline management
        cmds.currentTime(self.dataStore['currentTime'])
        cmds.playbackOptions(min=self.dataStore['minTime'])
        cmds.playbackOptions(max=self.dataStore['maxTime'])
        cmds.playbackOptions(ast=self.dataStore['startTime'])
        cmds.playbackOptions(aet=self.dataStore['endTime'])
        cmds.playbackOptions(ps=self.dataStore['playSpeed'])
        
        #unit management
        cmds.currentUnit(time=self.dataStore['timeUnit'])
        cmds.currentUnit(linear=self.dataStore['sceneUnits'])
        cmds.upAxis(axis=self.dataStore['upAxis'])
        
        log.info('Restored PlayBack / Timeline setup')
        
        #panel management
        for panel, data in self.dataStore['panelStore'].items():
            cmdString = data['settings'].replace('$editorName', panel)
            mel.eval(cmdString)
            log.info("Restored Panel Settings Data >> %s" % panel)
            mel.eval('lookThroughModelPanel("%s","%s")' % (data['activeCam'], panel))
            log.info("Restored Panel Active Camera Data >> %s >> cam : %s" % (panel, data['activeCam']))
            
        # camera management
        for cam, settings in self.dataStore['cameraTransforms'].items():
            cmds.setAttr('%s.translate' % cam, settings[0][0][0], settings[0][0][1], settings[0][0][2])
            cmds.setAttr('%s.rotate' % cam, settings[1][0][0], settings[1][0][1], settings[1][0][2])
            cmds.setAttr('%s.scale' % cam, settings[2][0][0], settings[2][0][1], settings[2][0][2])
            log.info('Restored Default Camera Transform Data : % s' % cam)

        #sound management
        if self.dataStore['displaySound']:
            cmds.timeControl(self.gPlayBackSlider, e=True, ds=1, sound=self.dataStore['activeSound'])
            log.info('Restored Audio setup')
        else:
            cmds.timeControl(self.gPlayBackSlider, e=True, ds=0)
        return True

    def replay(s, data):
        """
        Places the data back onto the objects in the scene at the current time.
        Accepts = { object : { attribute : [val1, val2, val3, ... ] } }
        """
        frame = cmds.currentTime(q=True) # Current time to start at
        index = 0 # Current index
        # Validate objects and build a working set of data
        validData = {}
        for o, attrs in data.items():
            if cmds.objExists(o): # Check for object existance
                for at in attrs:
                    if cmds.attributeQuery(at, n=o, ex=True):
                        validData["%s.%s" % (o, at)] = data[o][at]
                    else:
                        print "%s.%s could not be found. Skipping!" % (o, at)
            else:
                print "%s could not be found. Skipping!" % o
        # Ok our data is now valid. Lets get a posin! Phew. The final step...
        if not validData: raise RuntimeError, "Nothing in the Clip to pose."

        cmds.undoInfo(openChunk=True)
        autokeyState = cmds.autoKeyframe(q=True, state=True)
        cmds.autoKeyframe(state=False) # Turn off autokey
        try: # Open undo block!
            for attr, vals in validData.iteritems():
                frames = len(vals) # Get length to iterate!
                break

            for i in range(frames):
                cmds.currentTime(frame + i) # Jump to frame
                for attr, vals in validData.iteritems(): # Lots of looping. :(
                    try:
                        cmds.setAttr(attr, vals[i])
                        cmds.setKeyframe(attr)
                    except RuntimeError as e:
                        print "Warning \"%s\" :: %s" % (attr, e)
            print "Clip posed!"
        finally:
            cmds.autoKeyframe(state=autokeyState)
            cmds.undoInfo(closeChunk=True)

    def __enter__(self):
        self.autoKeyState = cmds.autoKeyframe(query=True, state=True)
        self.timeStore['currentTime'] = cmds.currentTime(q=True)
        self.timeStore['minTime'] = cmds.playbackOptions(q=True, min=True)
        self.timeStore['maxTime'] = cmds.playbackOptions(q=True, max=True)
        self.timeStore['startTime'] = cmds.playbackOptions(q=True, ast=True)
        self.timeStore['endTime'] = cmds.playbackOptions(q=True, aet=True)
        self.timeStore['playSpeed'] = cmds.playbackOptions(query=True, playbackSpeed=True)

        # force AutoKey OFF
        cmds.autoKeyframe(state=self.autokey)

        if self.mangage_undo:
            cmds.undoInfo(openChunk=True)
        else:
            cmds.undoInfo(swf=False)
        if self.manage_em:
            if r9Setup.mayaVersion() >= 2016:
                self.evalmode = cmds.evaluationManager(mode=True, q=True)[0]
                if self.evalmode == 'parallel':
                    evalManagerState(mode='off')

    def storeSettings(self):
        '''
        main work function, store all UI settings
        '''
        self.dataStore['autoKey'] = cmds.autoKeyframe(query=True, state=True)

        # timeline management
        self.dataStore['currentTime'] = cmds.currentTime(q=True)
        self.dataStore['minTime'] = cmds.playbackOptions(q=True, min=True)
        self.dataStore['maxTime'] = cmds.playbackOptions(q=True, max=True)
        self.dataStore['startTime'] = cmds.playbackOptions(q=True, ast=True)
        self.dataStore['endTime'] = cmds.playbackOptions(q=True, aet=True)
        self.dataStore['playSpeed'] = cmds.playbackOptions(query=True, playbackSpeed=True)
        self.dataStore['playLoop'] = cmds.playbackOptions(query=True, loop=True)

        # unit management
        self.dataStore['timeUnit'] = cmds.currentUnit(q=True, fullName=True, time=True)
        self.dataStore['sceneUnits'] = cmds.currentUnit(q=True, fullName=True, linear=True)
        self.dataStore['upAxis'] = cmds.upAxis(q=True, axis=True)

        # viewport colors
        self.dataStore['displayGradient'] = cmds.displayPref(q=True, displayGradient=True)

        # objects colors
        self.dataStore['curvecolor'] = cmds.displayColor("curve", q=True, dormant=True)

        # panel management
        self.dataStore['panelStore'] = {}
        for panel in ['modelPanel1', 'modelPanel2', 'modelPanel3', 'modelPanel4']:
            if not cmds.modelPanel(panel, q=True, exists=True):
                continue
            self.dataStore['panelStore'][panel] = {}
            self.dataStore['panelStore'][panel]['settings'] = cmds.modelEditor(panel, q=True, sts=True)
            activeCam = cmds.modelPanel(panel, q=True, camera=True)
            if not cmds.nodeType(activeCam) == 'camera':
                activeCam = cmds.listRelatives(activeCam, f=True)[0]
            self.dataStore['panelStore'][panel]['activeCam'] = activeCam

        # camera management
        # TODO : store the camera field of view etc also
        self.dataStore['cameraTransforms'] = {}
        for cam in ['persp', 'top', 'side', 'front']:
            try:
                self.dataStore['cameraTransforms'][cam] = [cmds.getAttr('%s.translate' % cam),
                                                     cmds.getAttr('%s.rotate' % cam),
                                                     cmds.getAttr('%s.scale' % cam)]
            except:
                log.debug("Camera doesn't exists : %s" % cam)

        # sound management
        self.dataStore['activeSound'] = cmds.timeControl(self.gPlayBackSlider, q=True, s=1)
        self.dataStore['displaySound'] = cmds.timeControl(self.gPlayBackSlider, q=True, ds=1)

 def __exit__(self, exc_type, exc_value, traceback):
     # Close the undo chunk, warn if any exceptions were caught:
     cmds.autoKeyframe(state=self.autoKeyState)
     log.info('autoKeyState restored: %s' % self.autoKeyState)
     
     if self.manage_em and self.evalmode:
         evalManagerState(mode=self.evalmode)
         log.info('evalManager restored: %s' % self.evalmode)
     if self.manage_time:
         cmds.currentTime(self.timeStore['currentTime'])
         cmds.playbackOptions(min=self.timeStore['minTime'])
         cmds.playbackOptions(max=self.timeStore['maxTime'])
         cmds.playbackOptions(ast=self.timeStore['startTime'])
         cmds.playbackOptions(aet=self.timeStore['endTime'])
         cmds.playbackOptions(ps=self.timeStore['playSpeed'])
         log.info('currentTime restored: %f' % self.timeStore['currentTime'])
     if self.mangage_undo:
         cmds.undoInfo(closeChunk=True)
     else:
         cmds.undoInfo(swf=True)
     if exc_type:
         log.exception('%s : %s'%(exc_type, exc_value))
     # If this was false, it would re-raise the exception when complete
     return True

    def addCharacter(self, close, *args):
        project = cmds.optionMenu(self.widgets["project"], q = True, value = True)
        selectedCharacter = cmds.textScrollList(self.widgets["characterList"], q = True, si = True)[0]
        rigPath = self.mayaToolsDir + "/General/ART/Projects/" + project + "/AnimRigs/" + selectedCharacter + ".mb"


        #find existing namespaces in scene
        namespaces = cmds.namespaceInfo(listOnlyNamespaces = True)

        #reference the rig file
        cmds.file(rigPath, r = True, type = "mayaBinary", loadReferenceDepth = "all", namespace = selectedCharacter, options = "v=0")

        #clear selection and fit view
        cmds.select(clear = True)
        
        #query autoKeyFrame state
        if not cmds.autoKeyframe(q = True, state = True):
            cmds.viewFit()
        #cmds.viewFit()
        panels = cmds.getPanel(type = 'modelPanel')


        #turn on smooth shading
        for panel in panels:
            editor = cmds.modelPanel(panel, q = True, modelEditor = True)
            cmds.modelEditor(editor, edit = True, displayAppearance = "smoothShaded", displayTextures = True, textures = True )



        #find new namespaces in scene (this is here in case I need to do something later and I need the new name that was created)
        newCharacterName = selectedCharacter
        newNamespaces = cmds.namespaceInfo(listOnlyNamespaces = True)

        for name in newNamespaces:
            if name not in namespaces:
                newCharacterName = name

        #launch UI
        import ART_animationUI
        reload(ART_animationUI)
        ART_animationUI.AnimationUI()

        if close:
            cmds.deleteUI(self.widgets["window"])