def create_fk_setup(self):
     """Creates the FK setup."""
     cmds.orientConstraint(self.controls['fan'], self.result_jnts[0], mo=True)
     mdl = cmds.shadingNode('multDoubleLinear', asUtility=True)
     mdl = cmds.rename(mdl, '%s_%s_MDL' % (self.side, self.modulename))
     if self.side == 'R':
         cmds.expression(s='%s.input1 = time * (-1);' % mdl, o=mdl, ae=1, uc='all')
     else:
         cmds.expression(s='%s.input1 = time;' % mdl, o=mdl, ae=1, uc='all')
     # END if
     cmds.connectAttr('%s.speed' % self.controls['fan'], '%s.input2' % mdl, f=True)
     cmds.setDrivenKeyframe('%s.rotate%s' % (self.controls['offset'], self._up_axis), cd='%s.output' % mdl, dv=0, v=0)
     cmds.setDrivenKeyframe('%s.rotate%s' % (self.controls['offset'], self._up_axis), cd='%s.output' % mdl, dv=1, v=1)
     cmds.keyTangent('%s_rotate%s' % (self.controls['offset'], self._up_axis), itt='linear', ott='linear', f=(0, 1))
     cmds.selectKey('%s_rotate%s' % (self.controls['offset'], self._up_axis), add=True, k=True, f=(0, 1))
     cmds.setInfinity(pri='cycleRelative', poi='cycleRelative')

def mirrorDrivenkeys(src, dst):
    for driver, driven in getDrivenKeys(src):
        newDriver = driver.replace(src, dst)
        newDriven = driven.replace("L_", "R_")
        if not mc.objExists(newDriven) or newDriven == driven:
            newDriven = driven.replace("left", "right")
        if not mc.objExists(newDriven) or newDriven == driven:
            newDriven = driven.replace("L", "R")

        if not mc.objExists(newDriver) or not mc.objExists(newDriven):
            continue
        if newDriven == driven:
            continue

        driverValues = mc.keyframe(driven, q=True, fc=True)
        drivenValues = mc.keyframe(driven, q=True, vc=True)
        for drv, dnv in zip(driverValues, drivenValues):
            if re.search(
                "(translateX|eyeRotInner_ctl_0.rotateZ|mouthCorner_ctl_0\.translateY|mouth_ctl_0\.translateY)$",
                newDriver,
            ):
                dnv = dnv * -1
            if re.search("(mainCheek_ctl_0\.translateX)$", newDriver):
                dnv = dnv * -1
            mc.setDrivenKeyframe(newDriven, cd=newDriver, dv=drv, v=dnv)

        print "Copy Driven keys: %s : %s -> %s : %s" % (driver, driven, newDriver, newDriven)

    def on_btn_setDrivenkey_clicked(self, args=None):
        if args==None:return
        rdnDict = {'rdn_A':'ypxn',  # -X+Y
                   'rdn_B':'y',     # +Y
                   'rdn_C':'ypxp',  # +X+Y

                   'rdn_D':'x',     # -X
                   'rdn_E':'x',     # +X

                   'rdn_F':'ynxn',  # -X-Y
                   'rdn_G':'y',     # -Y
                   'rdn_H':'ynxp'   # +X-Y
                   }
        selectRdn = ''
        for child in self.rdn_Box.findChildren(QtGui.QRadioButton):
            if child.isChecked():
                selectRdn = str(child.objectName())
                break
            else:
                continue
        #-----------------------------------------------------------
        driverAttr  = '%s.%s'%(self.__model.data(self.listView.selectedIndexes()[0], QtCore.Qt.DisplayRole), rdnDict.get(selectRdn))
        drivenAttr  = str(self.lineEdit.text())
        driverValue = mc.getAttr(driverAttr)
        drivenValue = mc.getAttr(drivenAttr)

        mc.setDrivenKeyframe(drivenAttr, cd=driverAttr, dv=driverValue, v=drivenValue)
        print driverAttr, drivenAttr, driverValue, drivenValue

    def resetFn(self, wid):
        print 'resetting', wid
        try:
            cmds.undoInfo(openChunk=True)
            #get original pose from driven dict
            initialPoseDict = json.loads(cmds.getAttr(self.currentFace.blendBoard + '.initialPoseDict'))
            initialPoseAttrs = initialPoseDict[wid.pose]

            #store current slider/attr val
            preVal = cmds.getAttr(wid.pose)

            #iterate over the attrs and set them bvack to original
            #TODO: rotate order?
            cmds.setAttr(wid.pose, 1.0)
            for att in wid.driven:
                #print att, initialPoseAttrs[att]
                cmds.setAttr(att, initialPoseAttrs[att])

            #set the old driven keyframe
            cmds.setDrivenKeyframe(wid.driven, cd=wid.pose)

            #reset the slider/attr val
            cmds.setAttr(wid.pose, preVal)
            self.checkForEditedPoses()

        except Exception, err:
            import traceback
            print(traceback.format_exc())

def setDrivenKey(driverInfo, drivenInfo):
    """Automate the set driven key through the use of set driven key
    @param driverInfo list of values of the driver attribute. The key should be the target attribute
    @param drivenInfo list of values of the driven attribute. The key should be the target attribute

    @code
    import libUtilities
    #Set up the driver info
    driverInfo = {"ctrl.tx":[0,1]}
    drivenInfo = {"cube.rz":[0,360]}
    libUtilities.setDrivenKey(driverInfo, drivenInfo )
    @endcode

    @warning The number of values in both driver and driven attribute should be same
    """

    if type(driverInfo) != dict or type(drivenInfo) != dict:
        raise Exception("Not a dictInfo")

    driver = driverInfo.keys()[0]
    driven = drivenInfo.keys()[0]
    currentDriverValue = cmds.getAttr(driver)
    currentDrivenValue = cmds.getAttr(driven)

    cmds.setDrivenKeyframe(driven, itt="linear", ott="linear", cd=driver)
    for driveAttr, drivenAttr in zip(driverInfo[driver], drivenInfo[driven]):
        cmds.setAttr(driver, driveAttr)
        cmds.setAttr(driven, drivenAttr)
        cmds.setDrivenKeyframe(driven, itt="linear", ott="linear", cd=driver)

    cmds.setAttr(driver, currentDriverValue)
    cmds.setAttr(driven, currentDrivenValue)

def stampSDK( *args ):
    global drivenAttrs
    drivenAttrs = cmds.ls(sl=True)
    
    # Stamp SDK
    for sel in drivenAttrs:
        cmds.setDrivenKeyframe( "%s.%s" %(sel, cmds.channelBox( "mainChannelBox", q=True, sma=True )[0]), 
            cd=driverAttr)    

    def updateFn(self, wid):
        #check that the pose is fully on
        if wid.poseSlider.value() != 100:
            cmds.warning('Pose slider is not fully on, must be 1.0 in able to save edit.')
            return False

        cmds.setDrivenKeyframe(wid.driven, cd=wid.pose)
        self.checkForEditedPoses()

 def dpSetHandFollowSDK(self, *args):
     """ Create the setDrivenKey.
     """
     armWristIkCtrl = args[0]
     cmds.setDrivenKeyframe(armWristIkCtrl+"_Orient_Grp_ParentConstraint."+self.spineChestACtrl+"W0", currentDriver=armWristIkCtrl+"."+self.langDic[self.langName]['c_Follow'])
     cmds.setDrivenKeyframe(armWristIkCtrl+"_Orient_Grp_ParentConstraint."+self.globalCtrl+"W1", currentDriver=armWristIkCtrl+"."+self.langDic[self.langName]['c_Follow'])
     cmds.setDrivenKeyframe(armWristIkCtrl+"_Orient_Grp_ParentConstraint."+self.rootCtrl+"W2", currentDriver=armWristIkCtrl+"."+self.langDic[self.langName]['c_Follow'])
     cmds.setDrivenKeyframe(armWristIkCtrl+"_Orient_Grp_ParentConstraint."+self.spineHipsBCtrl+"W3", currentDriver=armWristIkCtrl+"."+self.langDic[self.langName]['c_Follow'])
     cmds.setDrivenKeyframe(armWristIkCtrl+"_Orient_Grp_ParentConstraint."+self.headCtrl+"W4", currentDriver=armWristIkCtrl+"."+self.langDic[self.langName]['c_Follow'])

    def on_actionQuickSDK_triggered(self, clicked=None):
        if clicked==None:return

        DriverAttribute = str(self.driverAttributelineEdit.text())


        for i in range(self.drivenAttributelineEdit.count()):
            Drivenattr = str(self.drivenAttributelineEdit.item(i).text())
            mc.setDrivenKeyframe(Drivenattr, cd=DriverAttribute)

def getDrivenKeyInfo(obj):
    DrivenInfo = []
    attributes = mc.setDrivenKeyframe(obj, q=True, dn=True)
    if re.match('^No driven attributes', attributes[0]):
        return DrivenInfo
    
    for attr in attributes:
        DrivenInfo.append((mc.setDrivenKeyframe(attr, q=True, dr=True), attr))
        
    return DrivenInfo

    def _setKeyFrame(self, DriverValueSpinbox, DrivenValueSpinbox):
        DriverAttibute = str(self.DriverAttributeLineEdit.text())
        DrivenAttibute = str(self.DrivenAttributeLineEdit.text())
        DriverValue = DriverValueSpinbox.value()
        DrivenValue = DrivenValueSpinbox.value()

        if len(DriverAttibute) == 0:return
        if len(DrivenAttibute) == 0:return

        mc.setDrivenKeyframe(DrivenAttibute, cd=DriverAttibute, dv=DriverValue, v=DrivenValue)

    def _dynamic_settings(self, dyCtrl, hairSys, fol):
        """
        Responsible for setting the dynamic control attributes.
        """
        # header
        cmds.addAttr(dyCtrl, ln="dynamic", at="enum",
                     en="settings:", k=True)
        cmds.setAttr("{0}.dynamic".format(dyCtrl), l=True)

        # EN
        cmds.addAttr(dyCtrl, ln="EN", at="enum", en="on:off", k=True)

        # off
        cmds.setAttr("{0}.EN".format(dyCtrl), 1)
        cmds.setAttr("{0}Shape.simulationMethod".format(hairSys), 0)
        cmds.setDrivenKeyframe("{0}Shape.simulationMethod".format(hairSys),
                          "{0}.EN".format(dyCtrl))

        # on
        cmds.setAttr("{0}.EN".format(dyCtrl), 0)
        cmds.setAttr("{0}Shape.simulationMethod".format(hairSys), 3)
        cmds.setDrivenKeyframe("{0}Shape.simulationMethod".format(hairSys),
                          "{0}.EN".format(dyCtrl))

        # motion drag
        cmds.addAttr(dyCtrl, ln="motionDrag", at="float", k=1, hnv=1, hxv=1)
        cmds.connectAttr("{0}.motionDrag".format(dyCtrl),
                         "{0}Shape.motionDrag".format(hairSys), f=1)

        # drag
        cmds.addAttr(dyCtrl, ln="drag", at="float",
                     k=1, hnv=1, hxv=1)
        cmds.connectAttr("{0}.drag".format(dyCtrl),
                         "{0}Shape.drag".format(hairSys), f=1)

        # damp
        cmds.addAttr(dyCtrl, ln="damp", at="float",
                     dv=0, k=1, hnv=1, hxv=1)
        cmds.connectAttr("{0}.damp".format(dyCtrl),
                         "{0}Shape.damp".format(hairSys), f=1)

        # iterations
        cmds.addAttr(dyCtrl, ln="iterations", at="float", k=1, hnv=1, hxv=1)
        cmds.connectAttr("{0}.iterations".format(dyCtrl),
                         "{0}Shape.iterations".format(hairSys), f=1)

        # stiffness
        cmds.addAttr(dyCtrl, ln="stiffness", at="float", k=0, hnv=1, hxv=1,
                     dv=1, min=0, max=1)
        cmds.connectAttr("{0}.stiffness".format(dyCtrl),
                         "{0}Shape.stiffness".format(hairSys), f=1)

 def create_ik_stretch(self):
     """Creates the IK stretch setup."""
     arm_dist, start_loc, end_loc = self.c.distance_node(self.guides['thigh'], self.guides['foot'])
     arm_dist = cmds.rename(arm_dist, '%s_%s_%s' % (self.side, 'leg', self.nc.distance))
     start_loc = cmds.rename(start_loc, '%s_%s_%s' % (self.side, 'legLengthStart', self.nc.locator))
     end_loc = cmds.rename(end_loc, '%s_%s_%s' % (self.side, 'legLengthEnd', self.nc.locator))
     cmds.parent(end_loc, self.controls['ik'])
     cmds.parent(arm_dist, self.top_grp)
     driver = '%sShape.distance' % arm_dist
     if self.side == 'R':
         mult = cmds.shadingNode('multiplyDivide', asUtility=True)
         mult = cmds.rename(mult, '%s_%s_stretch_negative_MDN' % (self.side, 'leg'))
         cmds.connectAttr('%sShape.distance' % arm_dist, '%s.input1X' % mult, f=True)
         cmds.setAttr('%s.input2X' % mult, -1)
         driver = '%s.outputX' % mult
     # END if
     thigh_len = cmds.getAttr('%s.tx' % self.ik_jnts[1])
     shin_len = cmds.getAttr('%s.tx' % self.ik_jnts[2])
     sum_len = thigh_len + shin_len
     cmds.setDrivenKeyframe('%s.translateX' % self.ik_jnts[1], cd=driver,
                            dv=sum_len, itt='linear', ott='linear')
     cmds.setDrivenKeyframe('%s.translateX' % self.ik_jnts[1], cd=driver,
                            dv=sum_len*2, v=thigh_len*2, itt='linear', ott='linear')
     cmds.setDrivenKeyframe('%s.translateX' % self.ik_jnts[2], cd=driver,
                            dv=sum_len, itt='linear', ott='linear')
     cmds.setDrivenKeyframe('%s.translateX' % self.ik_jnts[2], cd=driver,
                            dv=sum_len*2, v=shin_len*2, itt='linear', ott='linear')
     cmds.setAttr('%s_translateX.postInfinity' % self.ik_jnts[1], 1)
     cmds.setAttr('%s_translateX.postInfinity' % self.ik_jnts[2], 1)

 def create_ik_arm_stretch(self):
     """Creates the IK stretch setup."""
     arm_dist, start_loc, end_loc = self.c.distance_node(self.guides['upperArm'], self.guides['hand'])
     arm_dist = cmds.rename(arm_dist, '%s_%s_%s' % (self.side, 'arm', self.nc.distance))
     start_loc = cmds.rename(start_loc, '%s_%s_%s' % (self.side, 'armLengthStart', self.nc.locator))
     end_loc = cmds.rename(end_loc, '%s_%s_%s' % (self.side, 'armLengthEnd', self.nc.locator))
     cmds.parent(end_loc, self.controls['handik'])
     cmds.parent(arm_dist, self.top_grp)
     driver = '%sShape.distance' % arm_dist
     if self.side == 'R':
         mult = cmds.shadingNode('multiplyDivide', asUtility=True)
         mult = cmds.rename(mult, '%s_%s_stretch_negative_MDN' % (self.side, 'arm'))
         cmds.connectAttr('%sShape.distance' % arm_dist, '%s.input1X' % mult, f=True)
         cmds.setAttr('%s.input2X' % mult, -1)
         driver = '%s.outputX' % mult
     # END if
     upper_arm_len = cmds.getAttr('%s.tx' % self.ik_jnts[1])
     fore_arm_len = cmds.getAttr('%s.tx' % self.ik_jnts[2])
     sum_len = upper_arm_len + fore_arm_len
     cmds.setDrivenKeyframe('%s.translateX' % self.ik_jnts[1], cd=driver,
                            dv=sum_len, itt='linear', ott='linear')
     cmds.setDrivenKeyframe('%s.translateX' % self.ik_jnts[1], cd=driver,
                            dv=sum_len*2, v=upper_arm_len*2, itt='linear', ott='linear')
     cmds.setDrivenKeyframe('%s.translateX' % self.ik_jnts[2], cd=driver,
                            dv=sum_len, itt='linear', ott='linear')
     cmds.setDrivenKeyframe('%s.translateX' % self.ik_jnts[2], cd=driver,
                            dv=sum_len*2, v=fore_arm_len*2, itt='linear', ott='linear')
     cmds.setAttr('%s_translateX.postInfinity' % self.ik_jnts[1], 1)
     cmds.setAttr('%s_translateX.postInfinity' % self.ik_jnts[2], 1)
     # stretch the result joints
     curve = '%s_%s_%s' % (self.side, 'upperArm', self.nc.curve)
     self.stretch_result_joints(curve, 'upperArm', self.upper_arm_jnts)
     curve = '%s_%s_%s' % (self.side, 'foreArm', self.nc.curve)
     self.stretch_result_joints(curve, 'foreArm', self.fore_arm_jnts)

    def on_actionMirrorSDK_triggered(self, clicked=None):
        if clicked == None:return

        ReverDt = {'X':1, 'Y':1, 'Z':1}
        
        if self.REVERX.isChecked():ReverDt['X'] = -1
        if self.REVERY.isChecked():ReverDt['Y'] = -1
        if self.REVERZ.isChecked():ReverDt['Z'] = -1
        
        for i,DrivenInformations in enumerate(self.targentAtrLst):
            DrivenAttr = str(list(self.Model.stringList())[i])
            for driverValue, value in zip(DrivenInformations[2], DrivenInformations[3]):
                mc.setDrivenKeyframe(DrivenAttr, cd=DrivenInformations[0], dv=driverValue, v=value * ReverDt.get(DrivenInformations[0][-1], 1))
                print DrivenInformations[0], DrivenAttr

 def create_ik_stretch(self):
     """Creates the IK stretch setup."""
     shoulder_dist, start_loc, end_loc = self.c.distance_node(self.guides['shoulderBase'], self.guides['shoulderEnd'])
     shoulder_dist = cmds.rename(shoulder_dist, '%s_%s_%s' % (self.side, self.modulename, self.nc.distance))
     start_loc = cmds.rename(start_loc, '%s_%s_%s' % (self.side, 'shoulderLengthStart', self.nc.locator))
     end_loc = cmds.rename(end_loc, '%s_%s_%s' % (self.side, 'shoulderLengthEnd', self.nc.locator))
     cmds.parent(end_loc, self.controls['ik'])
     cmds.parent(shoulder_dist, start_loc, self.top_grp)
     driver = '%sShape.distance' % shoulder_dist
     shoulder_len = cmds.getAttr('%s.tx' % self.result_jnts[1])
     sum_len = shoulder_len
     cmds.setDrivenKeyframe('%s.translateX' % self.result_jnts[1], cd=driver, dv=sum_len, itt='linear', ott='linear')
     cmds.setDrivenKeyframe('%s.translateX' % self.result_jnts[1], cd=driver, dv=sum_len*2, v=shoulder_len*2, itt='linear', ott='linear')
     cmds.setAttr('%s_translateX.postInfinity' % self.result_jnts[1], 1)
     self.stretch_switch('%s_translateX' % self.result_jnts[1], self.result_jnts[1], self.switch_control, 'translateX')

def copySetDrivenKey(sourceDriver,targetDriver,drivenObject,targetObject):
    """ 
    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
    ACKNOWLEDGEMENT:
    Jason Schleifer's AFR Materials.

    DESCRIPTION:
    Copies an SDK

    ARGUMENTS:
    sourceDriver(string)
    targetDriver(string)
    drivenObject(string)
    targetObject(string)

    RETURNS:
    driverCurves(list)
    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    """
    # Get driven attributes
    drivenAttributes = mc.setDrivenKeyframe(drivenObject,q=True, dn=True)
    if not drivenAttributes:
        guiFactory.warning('No driven attributes found on %s' %drivenObject)
    else:
        # Get drivers
        for attr in drivenAttributes:
            print attr
            drivers = mc.setDrivenKeyframe(attr,q=True, dr=True)
            if not sourceDriver in drivers:
                guiFactory.warning('%s not found in the sdk drivers' %sourceDriver)
            else:
                # Get curve info
                curveInfo = returnSetDrivenCurveInfo(sourceDriver,attr)
                
                for key in curveInfo.keys():
                    attrBuffer = attr.split('.')
                    # set the SDK's
                    mc.setDrivenKeyframe(targetObject+'.'+attrBuffer[-1], currentDriver = targetDriver, driverValue = key,value = curveInfo[key])
                
                #Copy Curve tangents and stuff
                oldCurve = returnDriverCurve(sourceDriver,attr)
                newCurve = returnDriverCurve(targetDriver,attr)
                
                weight = mc.keyTangent(oldCurve[0],q=True, wt=True)
                mc.keyTangent(newCurve[0],edit=True,wt=weight[0])
                
                #copy the bits
                copyAnimCurveSettingsToCurve(oldCurve[0],newCurve[0])

def copyDrivenKeys(src, dsr, dsn, mirror=1):
    for arg in (src, dsr, dsn):
        obj, attribute = arg.split('.', 1)
        if not mc.objExists(obj):
            print 'Error -> obj  %s  was not Exists...'%obj
            return
        if not mc.attributeQuery(attribute, n=obj, ex=True):
            print 'Error -> attributes  %s  was not Exists...'%arg
            return
    
    mc.delete(mc.keyframe(dsn, q=True, n=True))
    
    driverValues = mc.keyframe(src, q=True, fc=True)
    drivenValues = mc.keyframe(src, q=True, vc=True)
    for drv, dnv in zip(driverValues, drivenValues):
        mc.setDrivenKeyframe(dsn, cd=dsr, dv=drv, v=dnv * mirror)

 def create_fk_setup(self):
     """Creates the FK setup."""
     cmds.setDrivenKeyframe('%s.translateX' % self.fk_jnts[1], cd='%s.length' % self.fk_jnts[0], dv=1, itt='linear', ott='linear')
     cmds.setDrivenKeyframe('%s.translateX' % self.fk_jnts[1], cd='%s.length' % self.fk_jnts[0], dv=0, v=0, itt='linear', ott='linear')
     cmds.setDrivenKeyframe('%s.translateX' % self.fk_jnts[2], cd='%s.length' % self.fk_jnts[1], dv=1, itt='linear', ott='linear')
     cmds.setDrivenKeyframe('%s.translateX' % self.fk_jnts[2], cd='%s.length' % self.fk_jnts[1], dv=0, v=0, itt='linear', ott='linear')
     cmds.selectKey('%s_translateX' % self.fk_jnts[1], k=True, f=(1,))
     cmds.setInfinity(poi='cycleRelative')
     cmds.selectKey('%s_translateX' % self.fk_jnts[2], k=True, f=(1,))
     cmds.setInfinity(poi='cycleRelative')

 def createSDK(self,*args):
     """
      Create the SDK with given values
     """
     #Store user values in variables
     driver = mc.textFieldGrp(self.driverField,q=True,text=True)
     driverVal = mc.floatField(self.driverValueField,q=True,v=True)
     driverAttr = mc.optionMenu(self.driverAttField,q=True,v=True)
     drivenValue = mc.floatField(self.drivenValueField,q=True,v=True)
     drivenAttr = mc.optionMenu(self.drivenAttField,q=True,v=True)
     drivenObj = mc.textFieldGrp(self.drivenField,q=True,text=True)
     inTangent = mc.optionMenu(self.inTangentField,q=True,v=True)
     outTangent = mc.optionMenu(self.outTangentField,q=True,v=True)
     blend = mc.optionMenu(self.insertBlendField,q=True,sl=True)
     
     currentDriver = '%s.%s' % (driver,driverAttr) 
     
     mc.setDrivenKeyframe(drivenObj,cd=currentDriver,dv=driverVal,v=drivenValue,at=drivenAttr,itt=inTangent,ott=outTangent,ib=blend)