
'''
Stub class file for:
OpenMayaAnim

Maya2011 Python API stub file
Generated from original Maya documentation.
Autodesk Maya 2010  c1997-2010 Autodesk, Inc. All rights reserved. 
'''




class MAnimControl:
    '''Control over animation playback and values.'''
    def __init__(self):
        pass


    def setCurrentTime(self, newTime): 
        '''setCurrentTime(self, newTime)
Arguments:
	[in]	newTime = MTime

Set the current animation frame.'''
        pass

    def setMinMaxTime(self, min, max): 
        '''setMinMaxTime(self, min, max)
Arguments:
	[in]	min = MTime
	[in]	max = MTime

Set the values of the first and last frames of the playback time
range.'''
        pass

    def setViewMode(self, newMode): 
        '''setViewMode(self, newMode)
Arguments:
	[in]	newMode = MAnimControl.PlaybackViewMode

Set the current viewing mode. Controls whether the animation is
run in only the active view, or simultaneously in all views.'''
        pass

    def kPlaybackViewAll(self):
        '''This is an enum of PlaybackViewMode.
Description: Playback in all views.
Value: 0'''
        pass

    def kPlaybackViewActive(self):
        '''This is an enum of PlaybackViewMode.
Description: Playback in only the active view.
Value: 1'''
        pass

    class PlaybackViewMode:
        '''Non-functional class.  Values for this enum:
        kPlaybackViewAll
        kPlaybackViewActive
'''
        def __init__(self):
            pass

    def playbackSpeed(self): 
        '''playbackSpeed(self) -> double

Return the speed with with to play the animation.'''
        pass

    def weightedTangents(self): 
        '''weightedTangents(self) -> bool
Returns: Returns:


true the tangents on the Anim Curve are weighted
false the tangents on the Anim Curve are not
weighted

Determine whether or not the tangents on the Anim Curve are
weighted.'''
        pass

    def setPlaybackSpeed(self, newSpeed): 
        '''setPlaybackSpeed(self, newSpeed)
Arguments:
	[in]	newSpeed = double

Set the desired speed factor at which the animation will play
back.'''
        pass

    def minTime(self): 
        '''minTime(self) -> MTime

Return an  MTime 
specifying the first frame of the current playback time range. This
corresponds to the minTime which can also be set and queried using
the playbackOptions mel command. It does not represent the first
frame of the total animation time unless the two coincide.'''
        pass

    def playbackBy(self): 
        '''playbackBy(self) -> double

Return a double specifying the increment between times viewed
during the playing of the animation.'''
        pass

    def setAnimationStartEndTime(self, newStartTime, newEndTime): 
        '''setAnimationStartEndTime(self, newStartTime, newEndTime)
Arguments:
	[in]	newStartTime = MTime
	[in]	newEndTime = MTime

Set the values of the first and last frames in the
animation.'''
        pass

    def animationEndTime(self): 
        '''animationEndTime(self) -> MTime

Return an  MTime 
specifying the last frame of the animation, as specified by the
Maya user in the Range Slider UI. This corresponds to the
animationEndTime which can also be set and queried using the
playbackOptions mel command.'''
        pass

    def setAutoKeyMode(self, mode): 
        '''setAutoKeyMode(self, mode)
Arguments:
	[in]	mode = bool

Set the autoKeyMode.'''
        pass

    def maxTime(self): 
        '''maxTime(self) -> MTime

Return an  MTime 
specifying the last frame of the current playback time range. This
corresponds to the maxTime which can also be set and queried using
the playbackOptions mel command. It does not represent the final
frame of the total animation time unless the two coincide.'''
        pass

    def setGlobalOutTangentType(self, tangentType): 
        '''setGlobalOutTangentType(self, tangentType)
Arguments:
	[in]	tangentType = MFnAnimCurve.TangentType

Set the current global out tangent type.'''
        pass

    def globalInTangentType(self): 
        '''globalInTangentType(self) -> MFnAnimCurve.TangentType
Returns: Returns:


MFnAnimCurve::TangentType
the current global in tangent type

Return the current global in tangent type.'''
        pass

    def setMinTime(self, newMinTime): 
        '''setMinTime(self, newMinTime)
Arguments:
	[in]	newMinTime = MTime

Set the first frame of the current playback time range.'''
        pass

    def playBackward(self): 
        '''playBackward(self)
Start playing the current animation backwards.'''
        pass

    def stop(self): 
        '''stop(self)
Stop playing the current animation.'''
        pass

    def setPlaybackBy(self, newTime): 
        '''setPlaybackBy(self, newTime)
Arguments:
	[in]	newTime = double

Specify the increment between times viewed during the playing of
the animation.'''
        pass

    def animationStartTime(self): 
        '''animationStartTime(self) -> MTime

Return an  MTime 
specifying the first frame of the animation, as specified by the
Maya user in the Range Slider UI. This corresponds to the
animationStartTime which can also be set and queried using the
playbackOptions mel command.'''
        pass

    def globalOutTangentType(self): 
        '''globalOutTangentType(self) -> MFnAnimCurve.TangentType
Returns: Returns:
The current global out tangent type

Return the current global out tangent type.'''
        pass

    def setPlaybackMode(self, newMode): 
        '''setPlaybackMode(self, newMode)
Arguments:
	[in]	newMode = MAnimControl.PlaybackMode

Set the current playback mode.'''
        pass

    def kPlaybackOscillate(self):
        '''This is an enum of PlaybackMode.
Description: Play forwards, then backwards continuously.
Value: 2'''
        pass

    def kPlaybackOnce(self):
        '''This is an enum of PlaybackMode.
Description: Play once then stop.
Value: 0'''
        pass

    def kPlaybackLoop(self):
        '''This is an enum of PlaybackMode.
Description: Play continuously.
Value: 1'''
        pass

    class PlaybackMode:
        '''Non-functional class.  Values for this enum:
        kPlaybackOscillate
        kPlaybackOnce
        kPlaybackLoop
'''
        def __init__(self):
            pass

    def setMaxTime(self, newMaxTime): 
        '''setMaxTime(self, newMaxTime)
Arguments:
	[in]	newMaxTime = MTime

Set the value of the last frame of the current playback time
range.'''
        pass

    def isPlaying(self): 
        '''isPlaying(self) -> bool

Return a value indicating whether Maya is currently playing the
animation.'''
        pass

    def setGlobalInTangentType(self, tangentType): 
        '''setGlobalInTangentType(self, tangentType)
Arguments:
	[in]	tangentType = MFnAnimCurve.TangentType

Set the current global in tangent type.'''
        pass

    def setWeightedTangents(self, weightState): 
        '''setWeightedTangents(self, weightState)
Arguments:
	[in]	weightState = bool

Sets whether or not the tangents on the Anim Curve are weighted.
Note: switching a curve from weightedTangents true to false and
back to true again will not preserve fixed tangents properly. Use
undo instead.'''
        pass

    def currentTime(self): 
        '''currentTime(self) -> MTime

Return an  MTime 
instance containing the current animation frame.'''
        pass

    def autoKeyMode(self): 
        '''autoKeyMode(self) -> bool

Return the autoKeyMode.'''
        pass

    def setAnimationStartTime(self, newStartTime): 
        '''setAnimationStartTime(self, newStartTime)
Arguments:
	[in]	newStartTime = MTime

Set the value of the first frame in the animation.'''
        pass

    def viewMode(self): 
        '''viewMode(self) -> MAnimControl.PlaybackViewMode

Return the viewing mode currently in effect.'''
        pass

    def playbackMode(self): 
        '''playbackMode(self) -> MAnimControl.PlaybackMode

Return the playback mode currently in effect.'''
        pass

    def playForward(self): 
        '''playForward(self)
Start playing the current animation forwards.'''
        pass

    def setAnimationEndTime(self, newEndTime): 
        '''setAnimationEndTime(self, newEndTime)
Arguments:
	[in]	newEndTime = MTime

Set the value of the last frame in the animation.'''
        pass

class MAnimCurveChange:
    '''Anim Curve Change Cache.'''
    def __init__(self):
        pass


    def redoIt(self): 
        '''redoIt(self)
Redoes all of the Anim Curve edits that this cache previously
undid. It is only valid to invoke this method after an undo on this
cache.'''
        pass

    def undoIt(self): 
        '''undoIt(self)
Undoes all of the Anim Curve edits that have been given to this
cache.'''
        pass

class MAnimCurveClipboard:
    '''Control over the animation clipboard.'''
    def __init__(self):
        pass


    def clipboardItems(self): 
        '''clipboardItems(self) -> const MAnimCurveClipboardItemArray
Returns: Returns:
The item array currently on this clipboard.

Returns the contents of the clipboard.'''
        pass

    def set(self, clipboardItemArray, startTime, endTime, startUnitlessInput, endUnitlessInput): 
        '''set(self, clipboardItemArray, startTime, endTime, startUnitlessInput, endUnitlessInput)
Arguments:
	[in]	clipboardItemArray = MAnimCurveClipboardItemArray
	[in]	startTime = MTime
	[in]	endTime = MTime
	[out]	startUnitlessInput = float
	[out]	endUnitlessInput = float

Sets the contents of the clipboard.'''
        pass

    def clear(self): 
        '''clear(self)
This method empties the clipboard.'''
        pass

    def startUnitlessInput(self): 
        '''startUnitlessInput(self) -> float
Returns: Returns:
The start unitless input of the clipboard.

Returns the start unitless input of the clipboard.'''
        pass

    def isEmpty(self): 
        '''isEmpty(self) -> bool
Returns: Returns:


true the current clipboard is empty
false the current clipboard is not empty

Status Code

Determines if the clipboard is empty.'''
        pass

    def startTime(self): 
        '''startTime(self) -> MTime
Returns: Returns:
The start time of the clipboard.

Returns the start time of the clipboard.'''
        pass

    def theAPIClipboard(self): 
        '''theAPIClipboard(self) -> MAnimCurveClipboard

Returns the static API clipboard. 
  Reprocessed example '''
        pass

    def endUnitlessInput(self): 
        '''endUnitlessInput(self) -> float
Returns: Returns:
The end unitless input of the clipboard.

Returns the end unitless input of the clipboard.'''
        pass

    def endTime(self): 
        '''endTime(self) -> MTime
Returns: Returns:
The end time of the clipboard.

Returns the end time of the clipboard.'''
        pass

class MAnimCurveClipboardItem:
    '''Wrapper for a clipboard item.'''
    def __init__(self):
        pass


    def setAnimCurve(self, curve): 
        '''setAnimCurve(self, curve)
Arguments:
	[in]	curve = MObject

Sets the clipboard item's animCurve'''
        pass

    def nodeName(self): 
        '''nodeName(self) -> const MString
Returns: Returns:
The node name.

Returns the node name'''
        pass

    def setNameInfo(self, nodeName, fullName, leafName): 
        '''setNameInfo(self, nodeName, fullName, leafName)
Arguments:
	[in]	nodeName = MString
	[in]	fullName = MString
	[in]	leafName = MString

Sets the clipboard item's name info'''
        pass

    def setAddressingInfo(self, rowCount, childCount, attributeCount): 
        '''setAddressingInfo(self, rowCount, childCount, attributeCount)
Arguments:
	[in]	rowCount = int
	[in]	childCount = int
	[in]	attributeCount = int

Sets the clipboard item's addressing info'''
        pass

    def leafAttributeName(self): 
        '''leafAttributeName(self) -> const MString
Returns: Returns:
The attribute's leaf name.

Returns the attribute's leaf name'''
        pass

    def getAddressingInfo(self, rowCount, childCount, attributeCount): 
        '''getAddressingInfo(self, rowCount, childCount, attributeCount)
Arguments:
	[out]	rowCount = int
	[out]	childCount = int
	[out]	attributeCount = int

Returns the addressing information for this clipboard item,'''
        pass

    def animCurve(self): 
        '''animCurve(self) -> const MObject
Returns: Returns:
An MObject for the
animCurve. On failure, the MObject will be NULL. Be aware that the
clipboard may be holding onto NULL animCurves (which are
placeholder objects).

Returns the animCurve held by this clipboard item as an
 MObject . Note that the
returned  MObject  is
const because you must not modify the animCurve referenced by this
 MObject .'''
        pass

    def animCurveType(self): 
        '''animCurveType(self) -> MFnAnimCurve.AnimCurveType
Returns: Returns:
The animCurve type.

Returns the animCurve type'''
        pass

    def __eq__(self, rhs): 
        '''__eq__(self, rhs) -> bool
Returns: Returns:


true the MAnimCurveClipboard
items are equal
false the MAnimCurveClipboard
items are not equal

Arguments:
	[in]	rhs = MAnimCurveClipboardItem

Compare the individual members for equality.'''
        pass

    def fullAttributeName(self): 
        '''fullAttributeName(self) -> const MString
Returns: Returns:
The attribute's full name

Returns the attribute's full name'''
        pass

class MAnimCurveClipboardItemArray:
    '''Array of MAnimCurveClipboardItem data
type.'''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MAnimCurveClipboardItem
	[in]	index = int

Inserts a new value into the array at the given index. The
initial element at that index, and all following elements, are
shifted towards the last. If the array cannot be expanded in size
by 1 element, then the insert will fail and the existing array will
remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = MAnimCurveClipboardItem
	[in]	index = int

Sets the value of the indicated element to the indicated
 MAnimCurveClipboardItem 
value.'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> const MAnimCurveClipboardItem
Returns: Returns:
A reference to the indicated element

Arguments:
	[in]	index = int

Index operator. Returns the value of the element at the given
index. No range checking is done - valid indices are 0 to  
length() -1.'''
        pass

    def isValid(self, failedIndex): 
        '''isValid(self, failedIndex) -> bool
Returns: Returns:
true if the clipboard item array is valid, and false
otherwise

Arguments:
	[out]	failedIndex = int

Ensures that the  MAnimCurveClipboard 
items in the array make sense.'''
        pass

    def clear(self): 
        '''clear(self)
Clear the contents of the array. After this operation the length
method will return 0. This does not change the amount of memory
allocated to the array, only the number of valid elements in
it.'''
        pass

    def sizeIncrement(self): 
        '''sizeIncrement(self) -> int

Return the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int

Remove the array element at the given index. All array elements
following the removed element are shifted toward the first
element.'''
        pass

    def length(self): 
        '''length(self) -> int

Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int

Set the size by which the array will be expanded whenever
expansion is necessary.'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = MAnimCurveClipboardItem

Adds a new element to the end of the array. If the array cannot
be expanded in size by 1 element, then the append will fail and the
existing array will remain unchanged.'''
        pass

class MAnimMessage:
    '''Animation messages.'''
    def __init__(self):
        pass


    def addNodeAnimKeyframeEditedCallback(self, animNode, func, clientData): 
        '''addNodeAnimKeyframeEditedCallback(self, animNode, func, clientData) -> MCallbackId

Arguments:
	[in]	animNode = MObject
	[in]	func = MMessage.MNodeObjArray
	[in]	clientData = void

AnimCurve keyframe edited callback.'''
        pass

    def addAnimCurveEditedCallback(self, func, clientData): 
        '''addAnimCurveEditedCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MObjArray
	[in]	clientData = void

AnimCurve edited callback.'''
        pass

    def addAnimKeyframeEditCheckCallback(self, func, clientData): 
        '''addAnimKeyframeEditCheckCallback(self, func, clientData) -> MCallbackId
Returns: Returns:
Identifier used for removing the callback.

Arguments:
	[in]	func = MMessage.MCheckPlugFunction
	[in]	clientData = void

AnimCurve keyframe edit check callback.'''
        pass

    def addAnimKeyframeEditedCallback(self, func, clientData): 
        '''addAnimKeyframeEditedCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MObjArray
	[in]	clientData = void

AnimCurve keyframe edited callback.'''
        pass

    def flushAnimKeyframeEditedCallbacks(self): 
        '''flushAnimKeyframeEditedCallbacks(self)
'''
        pass

class MAnimUtil:
    '''Static class providing common animation helper methods.'''
    def __init__(self):
        pass


    def isAnimated(self, selectionList, checkParent): 
        '''isAnimated(self, selectionList, checkParent) -> bool
Returns: Returns:


true The MSelectionList has atleast one animated
member.
false No member of the MSelectionList is animated.

Arguments:
	[in]	selectionList = MSelectionList
	[in]	checkParent = bool

Determine whether or not any member of an  MSelectionList  is animated. This is
intended to work with an  MSelectionList  with a single entry since
that provides the most useful information.'''
        pass

    def findAnimatedPlugs(self, selectionList, animatedPlugs, checkParent): 
        '''findAnimatedPlugs(self, selectionList, animatedPlugs, checkParent) -> bool
Returns: Returns:


true The MSelectionList has atleast one animated
member.
false No member of the MSelectionList is animated.

Arguments:
	[in]	selectionList = MSelectionList
	[in]	animatedPlugs = MPlugArray
	[in]	checkParent = bool

Find the list of attributes (MPlugs) on any member of an
 MSelectionList  that is animated. This is
intended to work with an  MSelectionList  with a single entry since
that provides the most useful information.'''
        pass

    def findAnimation(self, plug, animation): 
        '''findAnimation(self, plug, animation) -> bool
Returns: Returns:


true The MPlug is
animated.
false The MPlug is not
animated.

Arguments:
	[in]	plug = MPlug
	[in]	animation = MObjectArray

Find the animCurve(s) that are animating a given attribute
( MPlug ). In most
cases an attribute is animated by a single animCurve and so just
that animCurve will be returned. It is possible to setup a series
of connections where an attribute is animated by more than one
animCurve, although Maya does not currently offer a UI to do so.
Compound attributes are not expanded to include any child
attributes.'''
        pass

class MFnAnimCurve:
    '''Anim Curve Function Set.Specifying the correct AnimCurveType during creation will avoid
implicit unit conversion nodes.'''
    def __init__(self):
        pass


    def isWeighted(self): 
        '''isWeighted(self) -> bool
Returns: Returns:
Boolean value: true if the curve has weighted tangents,
false otherwise.

Determines whether or not the curve has weighted tangents.'''
        pass

    def getTangent(self, index, inTangent, angle, weight): 
        '''getTangent(self, index, inTangent, angle, weight)
Arguments:
	[in]	index = int
	[out]	angle = MAngle
	[out]	weight = double
	[in]	inTangent = bool

Determines the angle and weight of the in- or out-tangent to the
curve for the key at the specified index.'''
        pass

    def setTangentsLocked(self, index, locked, change): 
        '''setTangentsLocked(self, index, locked, change)
Arguments:
	[in]	index = int
	[in]	locked = bool
	[out]	change = MAnimCurveChange

Lock or unlock the tangents at the given key.'''
        pass

    def timedAnimCurveTypeForPlug(self, plug): 
        '''timedAnimCurveTypeForPlug(self, plug) -> MFnAnimCurve.AnimCurveType
Returns: Returns:
The animCurve type.

Arguments:
	[in]	plug = MPlug

Returns the timed animCurve type appropriate for the specified
plug.'''
        pass

    def kTangentGlobal(self):
        '''This is an enum of TangentType.
Description: Global.
Value: 0'''
        pass

    def kTangentFast(self):
        '''This is an enum of TangentType.
Description: OBSOLETE kTangentFast should not be used. Using this tangent
type may produce unwanted and unexpected results.
Value: 7'''
        pass

    def kTangentPlateau(self):
        '''This is an enum of TangentType.
Description: Plateau.
Value: 9'''
        pass

    def kTangentFixed(self):
        '''This is an enum of TangentType.
Description: Fixed.
Value: 1'''
        pass

    def kTangentSmooth(self):
        '''This is an enum of TangentType.
Description: Smooth.
Value: 4'''
        pass

    def kTangentStepNext(self):
        '''This is an enum of TangentType.
Description: StepNext.
Value: 10'''
        pass

    def kTangentStep(self):
        '''This is an enum of TangentType.
Description: Step.
Value: 5'''
        pass

    def kTangentClamped(self):
        '''This is an enum of TangentType.
Description: Clamped.
Value: 8'''
        pass

    def kTangentFlat(self):
        '''This is an enum of TangentType.
Description: Flag.
Value: 3'''
        pass

    def kTangentSlow(self):
        '''This is an enum of TangentType.
Description: OBSOLETE kTangentSlow should not be used. Using this tangent
type may produce unwanted and unexpected results.
Value: 6'''
        pass

    def kTangentLinear(self):
        '''This is an enum of TangentType.
Description: Linear.
Value: 2'''
        pass

    class TangentType:
        '''Non-functional class.  Values for this enum:
        kTangentGlobal
        kTangentFast
        kTangentPlateau
        kTangentFixed
        kTangentSmooth
        kTangentStepNext
        kTangentStep
        kTangentClamped
        kTangentFlat
        kTangentSlow
        kTangentLinear
'''
        def __init__(self):
            pass

    def addKeyframe(self, time, value, tangentInType, tangentOutType, change): 
        '''addKeyframe(self, time, value, tangentInType, tangentOutType, change)
Arguments:
	[in]	time = MTime
	[in]	value = double
	[in]	tangentInType = MFnAnimCurve.TangentType
	[in]	tangentOutType = MFnAnimCurve.TangentType
	[out]	change = MAnimCurveChange

Adds a new key with the given value and tangent types at the
specified time.'''
        pass

    def remove(self, index, change): 
        '''remove(self, index, change)
Arguments:
	[in]	index = int
	[out]	change = MAnimCurveChange

Removes the key at the specified index.'''
        pass

    def animCurveType(self): 
        '''animCurveType(self) -> MFnAnimCurve.AnimCurveType
Returns: Returns:
The animCurve type.

Returns the animCurve type'''
        pass

    def findClosest(self, unitlessInput): 
        '''findClosest(self, unitlessInput) -> int
Returns: Returns:
Key index closest to the specified time

Arguments:
	[in]	unitlessInput = double

Determines the index of the key which is set at the time closest
to the specified unitless input value.'''
        pass

    def find(self, unitlessInput, index): 
        '''find(self, unitlessInput, index) -> bool
Returns: Returns:
Boolean value: true if the index is found false
otherwise

Arguments:
	[in]	unitlessInput = double
	[out]	index = int

Determines the index of the key which is set at the specified
unitless input value.'''
        pass

    def setIsWeighted(self, isWeighted, change): 
        '''setIsWeighted(self, isWeighted, change)
Arguments:
	[in]	isWeighted = bool
	[out]	change = MAnimCurveChange

Sets whether or not the curve has weighted tangents.'''
        pass

    def kCycle(self):
        '''This is an enum of InfinityType.
Description: Cycle.
Value: 3'''
        pass

    def kConstant(self):
        '''This is an enum of InfinityType.
Description: Constant.
Value: 0'''
        pass

    def kLinear(self):
        '''This is an enum of InfinityType.
Description: Linear.
Value: 1'''
        pass

    def kOscillate(self):
        '''This is an enum of InfinityType.
Description: Oscillate.
Value: 5'''
        pass

    def kCycleRelative(self):
        '''This is an enum of InfinityType.
Description: Cycle relative.
Value: 4'''
        pass

    class InfinityType:
        '''Non-functional class.  Values for this enum:
        kCycle
        kConstant
        kLinear
        kOscillate
        kCycleRelative
'''
        def __init__(self):
            pass

    def create(self, animCurveType, modifier): 
        '''create(self, animCurveType, modifier) -> MObject
Returns: Returns:
The new Anim Curve Node

Arguments:
	[in]	animCurveType = MFnAnimCurve.AnimCurveType
	[in]	modifier = MDGModifier

Creates a new Anim Curve Node, attaches the Function Set to the
new Node (detaching from the current Node) but does not attempt to
connect the new Anim Curve Node.'''
        pass

    def unitlessAnimCurveTypeForPlug(self, plug): 
        '''unitlessAnimCurveTypeForPlug(self, plug) -> MFnAnimCurve.AnimCurveType
Returns: Returns:
The animCurve type.

Arguments:
	[in]	plug = MPlug

Returns the unitless animCurve type appropriate for the
specified plug.'''
        pass

    def setPostInfinityType(self, infinityType, change): 
        '''setPostInfinityType(self, infinityType, change)
Arguments:
	[in]	infinityType = MFnAnimCurve.InfinityType
	[out]	change = MAnimCurveChange

Set the behaviour of the curve for the range occurring after the
last key.'''
        pass

    def setInTangentType(self, index, tangentType, change): 
        '''setInTangentType(self, index, tangentType, change)
Arguments:
	[in]	index = int
	[in]	tangentType = MFnAnimCurve.TangentType
	[out]	change = MAnimCurveChange

Sets the type of the tangent to the curve entering the key at
the specified index.'''
        pass

    def setPreInfinityType(self, infinityType, change): 
        '''setPreInfinityType(self, infinityType, change)
Arguments:
	[in]	infinityType = MFnAnimCurve.InfinityType
	[out]	change = MAnimCurveChange

Set the behaviour of the curve for the range occurring before
the first key.'''
        pass

    def inTangentType(self, index): 
        '''inTangentType(self, index) -> MFnAnimCurve.TangentType
Returns: Returns:
Type of the tangent

Arguments:
	[in]	index = int

Determines the type of the tangent to the curve entering the
current key.'''
        pass

    def addKey(self, unitlessInput, timeValue, tangentInType, tangentOutType, change): 
        '''addKey(self, unitlessInput, timeValue, tangentInType, tangentOutType, change) -> int
Returns: Returns:
Index of added key

Arguments:
	[in]	unitlessInput = double
	[in]	timeValue = MTime
	[in]	tangentInType = MFnAnimCurve.TangentType
	[in]	tangentOutType = MFnAnimCurve.TangentType
	[out]	change = MAnimCurveChange

Adds a new key with the given output time value and tangent
types at the specified unitless input for curves of type
kAnimCurveUT.'''
        pass

    def setTangent(self, index, angle, weight, inTangent, convertUnits, change): 
        '''setTangent(self, index, angle, weight, inTangent, convertUnits, change)
Arguments:
	[in]	index = int
	[in]	angle = MAngle
	[in]	weight = double
	[in]	inTangent = bool
	[out]	change = MAnimCurveChange
	[in]	convertUnits = bool

Sets the tangent for the key at the specified index. If
convertUnits is true (the default) the x value will be scaled by
the current UI time units and the y value will be scaled by the
relevant UI units for the output type of the animation curve (i.e.
linear units for a curve that outputs linear data, and so on).'''
        pass

    def numKeys(self): 
        '''numKeys(self) -> int
Returns: Returns:
Number of keys on the Anim Curve Node

Determines the number of keys on the Anim Curve Node.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def setOutTangentType(self, index, tangentType, change): 
        '''setOutTangentType(self, index, tangentType, change)
Arguments:
	[in]	index = int
	[in]	tangentType = MFnAnimCurve.TangentType
	[out]	change = MAnimCurveChange

Sets the type of the tangent to the curve leaving the key at the
specified index.'''
        pass

    def isUnitlessInput(self): 
        '''isUnitlessInput(self) -> bool
Returns: Returns:
Boolean value: true if the curve takes a unitless value
as input, false otherwise.

Determines the input type of the animCurve.'''
        pass

    def outTangentType(self, index): 
        '''outTangentType(self, index) -> MFnAnimCurve.TangentType
Returns: Returns:
Type of the tangent

Arguments:
	[in]	index = int

Determines the type of the tangent to the curve leaving the
current key.'''
        pass

    def isStatic(self): 
        '''isStatic(self) -> bool
Returns: Returns:
Boolean value: true if the curve is static, false
otherwise

Determines whether or not the animCurve is static. The animCurve
is considered to be static if it would return the same value
regardless of the evaluation time. This basically means that the
values of all the keys are the same and the y component of all the
tangents is 0.'''
        pass

    def setValue(self, index, value, change): 
        '''setValue(self, index, value, change)
Arguments:
	[in]	index = int
	[in]	value = double
	[out]	change = MAnimCurveChange

Sets the value of the key at the specified index. This method
should only be used on Anim Curves of type kAnimCurve*A,
kAnimCurve*L or kAnimCurve*U.'''
        pass

    def isTimeInput(self): 
        '''isTimeInput(self) -> bool
Returns: Returns:
Boolean value: true if the curve takes time as input
false otherwise.

Determines the input type of the animCurve.'''
        pass

    def preInfinityType(self): 
        '''preInfinityType(self) -> MFnAnimCurve.InfinityType
Returns: Returns:
The current preInfinityType for the curve

Determines the behaviour of the curve for the range occurring
before the first key.'''
        pass

    def evaluate(self, atUnitlessInput, timeValue): 
        '''evaluate(self, atUnitlessInput, timeValue)
Arguments:
	[out]	atUnitlessInput = double
	[out]	timeValue = MTime

Determines the interpolated output value of Anim Curves of type
kAnimCurveUT at the specified unitless input.'''
        pass

    def addKeys(self, timeArray, valueArray, tangentInType, tangentOutType, keepExistingKeys, change): 
        '''addKeys(self, timeArray, valueArray, tangentInType, tangentOutType, keepExistingKeys, change)
Arguments:
	[in]	timeArray = MTimeArray
	[in]	valueArray = MDoubleArray
	[in]	tangentInType = MFnAnimCurve.TangentType
	[in]	tangentOutType = MFnAnimCurve.TangentType
	[in]	keepExistingKeys = bool
	[out]	change = MAnimCurveChange

Add a set of new keys with the given corresponding values and
tangent types at the specified times. This method only works for
Anim Curves of type kAnimCurveTA, kAnimCurveTL and
kAnimCurveTU.'''
        pass

    def setAngle(self, index, angle, inTangent, change): 
        '''setAngle(self, index, angle, inTangent, change)
Arguments:
	[in]	index = int
	[in]	angle = MAngle
	[in]	inTangent = bool
	[out]	change = MAnimCurveChange

Set the in- or out-angle of the tangent for the key at the given
index'''
        pass

    def setTime(self, index, time, change): 
        '''setTime(self, index, time, change)
Arguments:
	[in]	index = int
	[in]	time = MTime
	[out]	change = MAnimCurveChange

Sets the time of the key at the specified index. This will fail
if setting the time would require re-ordering of the keys. This
method should only be used on Anim Curves of type kAnimCurveT*.'''
        pass

    def setUnitlessInput(self, index, unitlessInput, change): 
        '''setUnitlessInput(self, index, unitlessInput, change)
Arguments:
	[in]	index = int
	[in]	unitlessInput = double
	[out]	change = MAnimCurveChange

Sets the value of the unitless input of the key at the specified
index. This will fail if setting the value would require
re-ordering of the keys. This methid should only be used on Anim
Curves of type kAnimCurveU*.'''
        pass

    def isBreakdown(self, index): 
        '''isBreakdown(self, index) -> bool
Returns: Returns:
Boolean value: true if the key is a breakdown,
false otherwise.

Arguments:
	[in]	index = int

Determines whether or not a key is a breakdown.'''
        pass

    def weightsLocked(self, index): 
        '''weightsLocked(self, index) -> bool
Returns: Returns:
Boolean value: true if the weights are locked,
false otherwise.

Arguments:
	[in]	index = int

Determines whether the weights are locked at the given key.'''
        pass

    def setWeight(self, index, weight, inTangent, change): 
        '''setWeight(self, index, weight, inTangent, change)
Arguments:
	[in]	index = int
	[in]	weight = double
	[in]	inTangent = bool
	[out]	change = MAnimCurveChange

Set the in- or out-weight of the tangent for the key at the
given index'''
        pass

    def setWeightsLocked(self, index, locked, change): 
        '''setWeightsLocked(self, index, locked, change)
Arguments:
	[in]	index = int
	[in]	locked = bool
	[out]	change = MAnimCurveChange

Lock or unlock the weights at the given key.'''
        pass

    def value(self, index): 
        '''value(self, index) -> double
Returns: Returns:
Value of the key

Arguments:
	[in]	index = int

Determines the value of the key at the specified index. This
method should only be used on Anim Curves of type kAnimCurve*A,
kAnimCurve*L or kAnimCurve*U.'''
        pass

    def postInfinityType(self): 
        '''postInfinityType(self) -> MFnAnimCurve.InfinityType
Returns: Returns:
The current postInfinityType for the curve

Determines the behaviour of the curve for the range occurring
after the last key.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def tangentsLocked(self, index): 
        '''tangentsLocked(self, index) -> bool
Returns: Returns:
Boolean value: true if the tangents are locked,
false otherwise.

Arguments:
	[in]	index = int

Determines whether the tangents are locked at the given key.'''
        pass

    def time(self, index): 
        '''time(self, index) -> MTime
Returns: Returns:
Time (in seconds) of the key

Arguments:
	[in]	index = int

Determines the time of the key at the specified index.'''
        pass

    def kAnimCurveTU(self):
        '''This is an enum of AnimCurveType.
Description: Time to Unitless.
Value: 3'''
        pass

    def kAnimCurveTT(self):
        '''This is an enum of AnimCurveType.
Description: Time to Time.
Value: 2'''
        pass

    def kAnimCurveUnknown(self):
        '''This is an enum of AnimCurveType.
Description: Unknown type.
Value: 8'''
        pass

    def kAnimCurveUT(self):
        '''This is an enum of AnimCurveType.
Description: Unitless to Time.
Value: 6'''
        pass

    def kAnimCurveUU(self):
        '''This is an enum of AnimCurveType.
Description: Unitless to Unitless.
Value: 7'''
        pass

    def kAnimCurveTA(self):
        '''This is an enum of AnimCurveType.
Description: Time to Angular.
Value: 0'''
        pass

    def kAnimCurveUL(self):
        '''This is an enum of AnimCurveType.
Description: Unitless to Linear.
Value: 5'''
        pass

    def kAnimCurveTL(self):
        '''This is an enum of AnimCurveType.
Description: Time to Linear.
Value: 1'''
        pass

    def kAnimCurveUA(self):
        '''This is an enum of AnimCurveType.
Description: Unitless to Angular.
Value: 4'''
        pass

    class AnimCurveType:
        '''Non-functional class.  Values for this enum:
        kAnimCurveTU
        kAnimCurveTT
        kAnimCurveUnknown
        kAnimCurveUT
        kAnimCurveUU
        kAnimCurveTA
        kAnimCurveUL
        kAnimCurveTL
        kAnimCurveUA
'''
        def __init__(self):
            pass

    def unitlessInput(self, index): 
        '''unitlessInput(self, index) -> double
Returns: Returns:
Input value at which the key is set

Arguments:
	[in]	index = int

Determines the unitless input value of the key at the specified
index. This method should only be used on Anim Curves of type
kAnimCurveU*.'''
        pass

    def setIsBreakdown(self, index, isBreakdown, change): 
        '''setIsBreakdown(self, index, isBreakdown, change)
Arguments:
	[in]	index = int
	[in]	isBreakdown = bool
	[out]	change = MAnimCurveChange

Sets the breakdown state of a key at a given index.'''
        pass

class MFnBlendShapeDeformer:
    '''blend shape deformer function set'''
    def __init__(self):
        pass


    def kLocalOrigin(self):
        '''This is an enum of Origin.
Description: 
Value: 0'''
        pass

    def kWorldOrigin(self):
        '''This is an enum of Origin.
Description: 
Value: 1'''
        pass

    class Origin:
        '''Non-functional class.  Values for this enum:
        kLocalOrigin
        kWorldOrigin
'''
        def __init__(self):
            pass

    def origin(self): 
        '''origin(self) -> MFnBlendShapeDeformer.Origin
Returns: Returns:
The origin space

Gets the origin space. It defines the point around which the
differences in the geometry are calculated.'''
        pass

    def addBaseObject(self, object): 
        '''addBaseObject(self, object)
Arguments:
	[in]	object = MObject

Adds a new base object to the deformer. This object will be
deformed as targets are added for it and the deformation parameters
change.'''
        pass

    def addTarget(self, baseObject, weightIndex, newTarget, fullWeight): 
        '''addTarget(self, baseObject, weightIndex, newTarget, fullWeight)
Arguments:
	[in]	baseObject = MObject
	[in]	weightIndex = int
	[in]	newTarget = MObject
	[in]	fullWeight = double

Adds a new target object for the given base object. The weight
index says which of the deformer's weight values will control this
target's affects on the base object. The full weight argument
determines at what weight the target is in full effect. If a base
object has no other targets and the weight is set to the 'full
weight', then the base object will look just like the target
object.'''
        pass

    def weight(self, index): 
        '''weight(self, index) -> float
Returns: Returns:
The weight value

Arguments:
	[in]	index = int

Get the weight value at the given index. To be valid, a weight
value should only be requested at index values returned by
 
MFnBlendShapeDeformer::weightIndexList .'''
        pass

    def removeTarget(self, baseObject, weightIndex, target, fullWeight): 
        '''removeTarget(self, baseObject, weightIndex, target, fullWeight)
Arguments:
	[in]	baseObject = MObject
	[in]	weightIndex = int
	[in]	target = MObject
	[in]	fullWeight = double

Remove a target object for the given base object. The weight
index specifies the index at which target is connected. The full
weight argument specifies at what weight the target is in full
effect.'''
        pass

    def numWeights(self): 
        '''numWeights(self) -> int
Returns: Returns:
The number of weight indices

Return the number of weight values that this blend shape
deformer has. The number of weight values is equal to the number of
targets. Targets are either shapes in the dag or baked data on the
blendShape node (when a target shape is deleted).'''
        pass

    def kNormal(self):
        '''This is an enum of HistoryLocation.
Description: 
Value: 1'''
        pass

    def kFrontOfChain(self):
        '''This is an enum of HistoryLocation.
Description: 
Value: 0'''
        pass

    class HistoryLocation:
        '''Non-functional class.  Values for this enum:
        kNormal
        kFrontOfChain
'''
        def __init__(self):
            pass

    def getTargets(self, baseObject, weightIndex, targetObjects): 
        '''getTargets(self, baseObject, weightIndex, targetObjects)
Arguments:
	[in]	baseObject = MObject
	[in]	weightIndex = int
	[out]	targetObjects = MObjectArray

Get a list of all of the target objects for the given base
object that affect it based on the given weight index.'''
        pass

    def setEnvelope(self, envelope): 
        '''setEnvelope(self, envelope)
Arguments:
	[in]	envelope = float

Sets the envelope value of the deformer.'''
        pass

    def setOrigin(self, space): 
        '''setOrigin(self, space)
Arguments:
	[in]	space = MFnBlendShapeDeformer.Origin

Sets the origin space. It defines the point around which the
differences in the geometry are calculated.'''
        pass

    def weightIndexList(self, indexList): 
        '''weightIndexList(self, indexList)
Arguments:
	[out]	indexList = MIntArray

Return the array index numbers corresponding to the targets. The
resulting index list will be the length of
MFnBlendShape::numWeights. This method exists because the indices
of the targets can be sparse. For example, if a target has been
removed using Deform -> Edit BlendShape -> Remove.'''
        pass

    def targetItemIndexList(self, targetIndex, baseObject, inbetweens): 
        '''targetItemIndexList(self, targetIndex, baseObject, inbetweens)
Arguments:
	[in]	targetIndex = int
	[in]	baseObject = MObject
	[in]	inbetweens = MIntArray

Return the "inputTargetItem" array indices for the specified
target. The "inputTargetItem" array indices correspond to the
weight where the targets take affect according to the formula:
index = wt * 1000 + 5000. For example, if you have only a single
target, and no in-betweens, the index will typically be 6000 since
the default weight for the initial target is 1.0.'''
        pass

    def setWeight(self, index, weight): 
        '''setWeight(self, index, weight)
Arguments:
	[in]	index = int
	[in]	weight = float

Set the weight value at the given index.'''
        pass

    def envelope(self): 
        '''envelope(self) -> float
Returns: Returns:
Envelope value

Gets the envelope value of the deformer.'''
        pass

    def getBaseObjects(self, objects): 
        '''getBaseObjects(self, objects)
Arguments:
	[out]	objects = MObjectArray

Get a list of all of the base objects for this deformer. The
objects returned will be the deformed versions of the base
objects.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def create(self, baseObjects, originSpace, historyLoc): 
        '''create(self, baseObjects, originSpace, historyLoc) -> MObject
Returns: Returns:
A handle to the new deformer

Arguments:
	[in]	baseObjects = MObjectArray
	[in]	originSpace = MFnBlendShapeDeformer.Origin
	[in]	historyLoc = MFnBlendShapeDeformer.HistoryLocation

Creates a new blend shape deformer in the dependency graph. This
method differs from the other  
MFnBlendShapeDeformer::create  in that it allows multiple base
shapes to be supplied at create time and it allows the use of the
front-of-chain history location, which puts the blendShape ahead of
other deformers such as skinning deformers.'''
        pass

class MFnCharacter:
    '''Function Set for Characters.'''
    def __init__(self):
        pass


    def getBlend(self, index): 
        '''getBlend(self, index) -> MObject
Returns: Returns:
MObject containing
an animBlendInOut node

Arguments:
	[in]	index = int

Return the animBlendInOut node corresponding to the specified
index.'''
        pass

    def getSourceClip(self, index): 
        '''getSourceClip(self, index) -> MObject
Returns: Returns:
MObject containing
an animClip node

Arguments:
	[in]	index = int

Return the animClip node corresponding to the specified index.
The animClip node will be a source clip node. The specified index
should range from 0 to clipCount-1 where clipCount is the value
returned by  MFnCharacter::getSourceClipCount .'''
        pass

    def blendExists(self, instancedClip1, instancedClip2, blendResult): 
        '''blendExists(self, instancedClip1, instancedClip2, blendResult) -> bool
Returns: Returns:
true, if a blend was found between the two clips

Arguments:
	[in]	instancedClip1 = MObject
	[in]	instancedClip2 = MObject
	[in]	blendResult = MObject

Return true if a blend exists between the two instanced clips on
the character. If a blend exists, the animBlend node related to the
blend is also returned.'''
        pass

    def attachInstanceToCharacter(self, instanceClip, dgMod): 
        '''attachInstanceToCharacter(self, instanceClip, dgMod)
Arguments:
	[in]	instanceClip = MObject
	[in]	dgMod = MDGModifier

Attaches an instance of a clip to the character. If the source
clip related to the clip instance is not already attached to the
character, it will be attached as well.'''
        pass

    def getScheduledClipCount(self): 
        '''getScheduledClipCount(self) -> int
Returns: Returns:
Number of clips scheduled on this character

Return the number of clips that have been scheduled on this
character.'''
        pass

    def getSubCharacters(self, result): 
        '''getSubCharacters(self, result)
Arguments:
	[out]	result = MSelectionList

Get a list of the subcharacters that are members of the
character set.'''
        pass

    def attachSourceToCharacter(self, sourceClip, dgMod): 
        '''attachSourceToCharacter(self, sourceClip, dgMod)
Arguments:
	[in]	sourceClip = MObject
	[in]	dgMod = MDGModifier

Attaches a given source clip node (created using  MFnClip::createSourceClip )
to the character's clipLibrary. Attaches a clipLibrary and
clipScheduler to the character if they are not attached
already.'''
        pass

    def getClipScheduler(self): 
        '''getClipScheduler(self) -> MObject
Returns: Returns:
MObject containing
a clipScheduler node

Get the clipScheduler node that manages the playback of clips on
this character. If no clips have been created for this character,
this method will return an empty  MObject .'''
        pass

    def getBlendCount(self): 
        '''getBlendCount(self) -> int
Returns: Returns:
Number of blends on clips in this character

Return the number of blends that have been added to clips on
this character.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def getScheduledClip(self, index): 
        '''getScheduledClip(self, index) -> MObject
Returns: Returns:
MObject containing
an animClip node

Arguments:
	[in]	index = int

Return the scheduled animClip node corresponding to the
specified index. The specified index should range from 0 to
clipCount-1 where clipCount is the value returned by  MFnCharacter::getScheduledClipCount .'''
        pass

    def addCurveToClip(self, curve, sourceClip, plug, dgMod): 
        '''addCurveToClip(self, curve, sourceClip, plug, dgMod)
Arguments:
	[in]	curve = MObject
	[in]	sourceClip = MObject
	[in]	plug = MPlug
	[in]	dgMod = MDGModifier

Adds an animation curve to a clip. The user must provide the
animation curve, and the related source clip node (typically
created using MFnCharacter::createSourceClip). The user must also
specify the plug that the clip will drive. The plug must be a
member of the character managed by this  MFnCharacter .'''
        pass

    def createBlend(self, instancedClip1, instancedClip2, blendAnimCurve, dgMod): 
        '''createBlend(self, instancedClip1, instancedClip2, blendAnimCurve, dgMod) -> MObject
Returns: Returns:
The resulting animBlend node

Arguments:
	[in]	instancedClip1 = MObject
	[in]	instancedClip2 = MObject
	[in]	blendAnimCurve = MObject
	[in]	dgMod = MDGModifier

Creates a blend between two instanced clips on the character.
The blend is defined by a specified paramCurve, which should be
keyed between times of 0 and 1. Time 0 corresponds to the start
time of the blend. Time 1 corresponds to the end time of the blend.
The blend will be performed on the clips according to the keyed
value of the blend curve, using the equation: (value)*clip1 +
(1-value)*clip2. For example, let's say the blend curve goes from a
value of (0,0) to (1,1). At the start of the blend you will have
100% of clip1, and 0% of clip2. At the end of the blend you will
have 0% of clip1, and 100% of clip2.'''
        pass

    def getBlendClips(self, index, clip1, clip2): 
        '''getBlendClips(self, index, clip1, clip2)
Arguments:
	[in]	index = int
	[out]	clip1 = MObject
	[out]	clip2 = MObject

Returns the clip nodes that are blended by the blend node
corresponding to the specified index.'''
        pass

    def getSourceClipCount(self): 
        '''getSourceClipCount(self) -> int
Returns: Returns:
Number of source clips owned by the library on this
character

Return the number of source clips managed by the clipLibrary
node of this character. For more information on source clips, refer
to the description of the  MFnCharacter  node.'''
        pass

    def getCharacterThatOwnsPlug(self, plug, result): 
        '''getCharacterThatOwnsPlug(self, plug, result) -> bool
Returns: Returns:
true, if the plug is in a character

Arguments:
	[in]	plug = MPlug
	[in]	result = MObject

Given a plug, test the plug to see if it is owned by a
character. If a character controls this plug, the character will be
returned'''
        pass

    def removeBlend(self, instancedClip1, instancedClip2, dgMod): 
        '''removeBlend(self, instancedClip1, instancedClip2, dgMod) -> bool
Returns: Returns:
true, if a blend was found and deleted

Arguments:
	[in]	instancedClip1 = MObject
	[in]	instancedClip2 = MObject
	[in]	dgMod = MDGModifier

Remove the blend between the two instanced clips on the
character. If a blend exists and was deleted, returns true. If a
blend did not exist, returns false.'''
        pass

    def getMemberPlugs(self, result): 
        '''getMemberPlugs(self, result)
Arguments:
	[out]	result = MPlugArray

Get the members of the character set that are attributes. Return
them as a plug array. A character set can contain only attributes
and subcharacters. To get all of the members of the character, use
 MFnSet::getMembers .
To get the subcharacters, use MFnCharacter::getSubcharacters.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnClip:
    '''clip function set'''
    def __init__(self):
        pass


    def setPreCycle(self, cycle, mod): 
        '''setPreCycle(self, cycle, mod)
Arguments:
	[in]	cycle = double
	[in]	mod = MDGModifier

Specify the pre cycle value for the clip.'''
        pass

    def createInstancedClip(self, sourceClip, start, dgMod, absolute, postCycle, weight, scale, preCycle): 
        '''createInstancedClip(self, sourceClip, start, dgMod, absolute, postCycle, weight, scale, preCycle) -> MObject
Returns: Returns:
The newly created clip.

Arguments:
	[in]	sourceClip = MObject
	[in]	start = MTime
	[in]	dgMod = MDGModifier
	[in]	absolute = bool
	[in]	postCycle = double
	[in]	weight = double
	[in]	scale = double
	[in]	preCycle = double

Creates an instance of a clip that will be viewable in the Trax
editor.'''
        pass

    def getTrack(self): 
        '''getTrack(self) -> int
Returns: Returns:
The index of this clip's track

Return the track number for the clip. Track indices are
one-based. If a track index of zero is returned, it indicates that
a track has not yet been assigned to the clip.'''
        pass

    def setPoseClip(self, state, mod): 
        '''setPoseClip(self, state, mod)
Arguments:
	[in]	state = bool
	[in]	mod = MDGModifier

Specify whether or not this clip node should be tagged as a pose
rather than a clip. By default, clip nodes are not poses.'''
        pass

    def setScale(self, scale, mod): 
        '''setScale(self, scale, mod)
Arguments:
	[in]	scale = double
	[in]	mod = MDGModifier

Specify a scale value for the clip.'''
        pass

    def setPostCycle(self, cycle, mod): 
        '''setPostCycle(self, cycle, mod)
Arguments:
	[in]	cycle = double
	[in]	mod = MDGModifier

Specify the post cycle value for the clip.'''
        pass

    def getAbsoluteChannelSettings(self, absoluteChannels): 
        '''getAbsoluteChannelSettings(self, absoluteChannels)
Arguments:
	[out]	absoluteChannels = MIntArray

Return an array indicating which channels of the clip are
absolute and which are relative. The length of the array is equal
to the members in the character. A value of one in the array
indicates absolute and a value of 0 indicates relative.'''
        pass

    def setSourceData(self, start, duration, mod): 
        '''setSourceData(self, start, duration, mod)
Arguments:
	[in]	start = MTime
	[in]	duration = MTime
	[in]	mod = MDGModifier

Specify the start frame and duration for the source clip
associated with this clip.'''
        pass

    def isPose(self): 
        '''isPose(self) -> bool
Returns: Returns:
True or false as to whether the clip is a pose.

Return true or false as to whether the clip node represents a
pose.'''
        pass

    def getStartFrame(self): 
        '''getStartFrame(self) -> MTime
Returns: Returns:
The value of this clip's start frame.

Return the value of this clip's start frame'''
        pass

    def sourceClip(self): 
        '''sourceClip(self) -> MObject
Returns: Returns:
MObject containing
the associated source clip.

Return the source clip associated with the MFnClip's clip'''
        pass

    def createSourceClip(self, sourceStart, sourceDuration, dgMod): 
        '''createSourceClip(self, sourceStart, sourceDuration, dgMod) -> MObject
Returns: Returns:
The newly created clip.

Arguments:
	[in]	sourceStart = MTime
	[in]	sourceDuration = MTime
	[in]	dgMod = MDGModifier

Creates a source clip node and associates it with this function
set. Each animation clip has a single source clip, which defines
the startFrame and duration of the clip's animation curves. The
startFrame and duration act as a window onto the animation curves,
defining the range of animation that is considered part of the
clip. After a source clip node is created, it can be passed to a
 MFnCharacter  along with the clip
animCurves in order to associate the clip with the character.'''
        pass

    def getSourceDuration(self): 
        '''getSourceDuration(self) -> MTime
Returns: Returns:
The value of this clip's source duration.

Return the value of the start frame of this clip's source
duration. The sourceStart and sourceDuration define the region of
the animCurve that is treated as the clip.'''
        pass

    def setAbsoluteChannelSettings(self, absoluteChannels, mod): 
        '''setAbsoluteChannelSettings(self, absoluteChannels, mod)
Arguments:
	[in]	absoluteChannels = MIntArray
	[in]	mod = MDGModifier

Set which channels of the clip are absolute and which are
relative. The length of the specified array should be equal to the
number of members in the character. A value of one in the array
indicates absolute and a value of 0 indicates relative.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def getWeight(self): 
        '''getWeight(self) -> double
Returns: Returns:
The value of this clip's weight attribute.

Return the value of this clip's weight attribute'''
        pass

    def setEnabled(self, val, mod): 
        '''setEnabled(self, val, mod)
Arguments:
	[in]	val = bool
	[in]	mod = MDGModifier

Specify whether or not the clip is enabled. Note: should not be
called for source clips since the enabled attribute is ignored on
source clips.'''
        pass

    def getPostCycle(self): 
        '''getPostCycle(self) -> double
Returns: Returns:
The value of this clip's post cycle attribute.

Return the value of this clip's post cycle attribute'''
        pass

    def getMemberAnimCurves(self, curves, associatedAttrs): 
        '''getMemberAnimCurves(self, curves, associatedAttrs)
Arguments:
	[out]	curves = MObjectArray
	[out]	associatedAttrs = MPlugArray

Return two arrays: the first contains the animCurves associated
with this clip. The second contains the character member that is
driven by this animCurve.'''
        pass

    def getScale(self): 
        '''getScale(self) -> double
Returns: Returns:
The value of this clip's scale attribute.

Return the value of this clip's scale attribute'''
        pass

    def setTrack(self, trackIndex, mod): 
        '''setTrack(self, trackIndex, mod)
Arguments:
	[in]	trackIndex = int
	[in]	mod = MDGModifier

Specify the one-based track number for the clip.'''
        pass

    def getPreCycle(self): 
        '''getPreCycle(self) -> double
Returns: Returns:
The value of this clip's pre cycle attribute.

Return the value of this clip's pre cycle attribute'''
        pass

    def isInstancedClip(self): 
        '''isInstancedClip(self) -> bool
Returns: Returns:
True or false as to whether the clip is an instanced clip.

Return true or false as to whether the clip node represents the
source clip or an instanced clip. All clips maintained by the
clipScheduler node and visible in the TraX editor are instanced
clips. All clips maintained by the clipLibrary node and visible in
the Visor are non-instanced clips, also called "Source Clips". Each
instanced clip has a corresponding source clip.'''
        pass

    def setWeight(self, wt, mod): 
        '''setWeight(self, wt, mod)
Arguments:
	[in]	wt = double
	[in]	mod = MDGModifier

Specify a weight value for the clip.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def getEnabled(self): 
        '''getEnabled(self) -> bool
Returns: Returns:
The value of this clip's enable attribute.

Return the value of this clip's enable attribute'''
        pass

    def getSourceStart(self): 
        '''getSourceStart(self) -> MTime
Returns: Returns:
The value of this clip's source start frame.

Return the value of the start frame of this clip's source clip.
The sourceStart and sourceDuration define the region of the
animCurve that is treated as the clip.'''
        pass

    def setStartFrame(self, start, mod): 
        '''setStartFrame(self, start, mod)
Arguments:
	[in]	start = MTime
	[in]	mod = MDGModifier

Specify the start frame for the instanced clip. Note: should not
be called for source clips since the start frame attribute is
ignored on source clips.'''
        pass

class MFnGeometryFilter:
    '''geometry filter function set'''
    def __init__(self):
        pass


    def getInputGeometry(self, geomList): 
        '''getInputGeometry(self, geomList)
Arguments:
	[out]	geomList = MObjectArray

This method returns the input geometry for the deformer by
traversing the graph to find upstream shape nodes. It is possible
for there to be nodes in between the shape and the deformer so that
the returned shape may have a different topology or tweaks then the
input data to the deformer. If the actual input geometry data for
the deformer is required, this information can be accessed by using
 MPlug::getValue()  to query the
inputGeometry attribute on the deformer.'''
        pass

    def indexForGroupId(self, groupId): 
        '''indexForGroupId(self, groupId) -> int
Returns: Returns:
The plug index corresponding to the groupId

Arguments:
	[in]	groupId = int

Returns the plug index corresponding to the groupId.'''
        pass

    def groupIdAtIndex(self, index): 
        '''groupIdAtIndex(self, index) -> int
Returns: Returns:
The groupId at the specified index

Arguments:
	[in]	index = int

Returns the groupId at the specified plug index.'''
        pass

    def indexForOutputConnection(self, connectionIndex): 
        '''indexForOutputConnection(self, connectionIndex) -> int
Returns: Returns:
The plug index corresponding to the connection index

Arguments:
	[in]	connectionIndex = int

Returns the plug index corresponding to the connection index.
The connection index is the index specifying the nth output
connection. The plug index (logical index) is the sparse array
index used by many of MFnGeometryFilter's methods and in MEL
scripts. The connection index is 0-based, hence, the maximum value
of the connection index is numOutputs - 1.'''
        pass

    def outputShapeAtIndex(self, index): 
        '''outputShapeAtIndex(self, index) -> MObject
Returns: Returns:
The output shape corresponding to the plug index

Arguments:
	[in]	index = int

Returns the output shape corresponding to the plug index'''
        pass

    def envelope(self): 
        '''envelope(self) -> float
Returns: Returns:
The envelope value

Returns the envelope value.'''
        pass

    def getOutputGeometry(self, geomList): 
        '''getOutputGeometry(self, geomList)
Arguments:
	[out]	geomList = MObjectArray

The output geometry is packed into the provided list of
MObjects. Each of the MObjects will be a DAG node.'''
        pass

    def setEnvelope(self, envelope): 
        '''setEnvelope(self, envelope)
Arguments:
	[in]	envelope = float

Sets the envelope value.'''
        pass

    def inputShapeAtIndex(self, index): 
        '''inputShapeAtIndex(self, index) -> MObject
Returns: Returns:
The input shape corresponding to the plug index

Arguments:
	[in]	index = int

Returns the input shape corresponding to the plug index.'''
        pass

    def numOutputConnections(self): 
        '''numOutputConnections(self) -> int
Returns: Returns:
The number of outputs

Returns the number of output geometries connected to this node.
This is typically equal to the number of input geometries unless an
input or output geometry has been deleted, or a connection to an
input or output geometry has been broken.'''
        pass

    def getPathAtIndex(self, index, dagPath): 
        '''getPathAtIndex(self, index, dagPath)
Arguments:
	[in]	index = int
	[out]	dagPath = MDagPath

The DAG path of the output geometry at the specified plug index
is put in the dagPath argument.'''
        pass

    def indexForOutputShape(self, shape): 
        '''indexForOutputShape(self, shape) -> int
Returns: Returns:
The plug index leading to the specified shape

Arguments:
	[in]	shape = MObject

Returns the plug index for the specified output shape.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def deformerSet(self): 
        '''deformerSet(self) -> MObject
Returns: Returns:
The set containing the objects that are deformed

Returns the set containing the objects that are deformed. Adding
new components to the deformer set will cause them to be deformed.
Removing components from the deformer set will prevent them from
being influenced by the deformer.'''
        pass

class MFnHikEffector:
    '''Full Body IK end effector function set.'''
    def __init__(self):
        pass


    def getAuxiliaryEffectors(self, effs): 
        '''getAuxiliaryEffectors(self, effs)
Arguments:
	[out]	effs = MObjectArray

Returns an array of the auxiliary effectors associated with this
effector. Auxiliary effectors are used by humanIK to act as
additional pivots.'''
        pass

    def setEffColor(self, color): 
        '''setEffColor(self, color)
Arguments:
	[in]	color = MColor

Set the humanIK color for this effector.'''
        pass

    def create(self, parent): 
        '''create(self, parent) -> MObject
Returns: Returns:
A handle to the new object

Arguments:
	[in]	parent = MObject

Creates a new fbik effector.'''
        pass

    def getEffColor(self): 
        '''getEffColor(self) -> MColor
Returns: Returns:
Pivot offset vector.

Retrieve the cached humanIK color of this effector.'''
        pass

    def getPivotOffset(self): 
        '''getPivotOffset(self) -> MVector
Returns: Returns:
Pivot offset vector.

Retrieve the pivot offset of this effector.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def setPivotOffset(self, vector): 
        '''setPivotOffset(self, vector)
Arguments:
	[in]	vector = MVector

Set the pivot offset for this effector.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnIkEffector:
    '''Inverse kinematics end effector function set.'''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def create(self, parent): 
        '''create(self, parent) -> MObject
Returns: Returns:
A handle to the new object

Arguments:
	[in]	parent = MObject

Creates a new end effector. For the effector to work properly,
it should be given a joint as the parent. It should be given the
joint before the last bone.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnIkHandle:
    '''Function set for inverse kinematics (IK) handles.'''
    def __init__(self):
        pass


    def priority(self): 
        '''priority(self) -> int
Returns: Returns:
The priority of this handle

Get the priority of this handle in case a solution is affected
by more than one handle.'''
        pass

    def stickiness(self): 
        '''stickiness(self) -> MFnIkHandle.Stickiness
Returns: Returns:
The stickiness value for this handle.

Get the stickiness of this handle.'''
        pass

    def weight(self): 
        '''weight(self) -> double
Returns: Returns:
The weight value for this handle

Get the handles weight in error calculations. The weight only
applies when handle goals are in conflict and cannot be solved
simultaneously. When this happens, a solution is computed that
weights the "distance" from each goal to the solution by the
handle's weight and attempts to minimize this value. The weight
must be >= 0.'''
        pass

    def getEffector(self, effectorPath): 
        '''getEffector(self, effectorPath)
Arguments:
	[out]	effectorPath = MDagPath

Get a dag path to the end-effector of the handle's joint
chain.'''
        pass

    def setPriority(self, priority): 
        '''setPriority(self, priority)
Arguments:
	[in]	priority = int

Set the priority of this handle in case a solution is affected
by more than one handle'''
        pass

    def setWeight(self, weight): 
        '''setWeight(self, weight)
Arguments:
	[in]	weight = double

Specifies the handles weight in error calculations. The weight
only applies when handle goals are in conflict and cannot be solved
simultaneously. When this happens, a solution is computed that
weights the "distance" from each goal to the solution by the
handle's weight and attempts to minimize this value. The weight
must be >= 0.'''
        pass

    def create(self, startJoint, effector): 
        '''create(self, startJoint, effector) -> MObject

Arguments:
	[in]	startJoint = MDagPath
	[in]	effector = MDagPath

Creates a new ik handle. The effector and startJoint specify the
joint chain controlled by this handle. The effector is the joint
that is moved by the handle forcing the solver to recalculate the
joint chain.'''
        pass

    def solver(self): 
        '''solver(self) -> MObject
Returns: Returns:
The solver associated with this handle

Returns the solver attached to this handle.'''
        pass

    def setStartJointAndEffector(self, jointPath, effectorPath): 
        '''setStartJointAndEffector(self, jointPath, effectorPath)
Arguments:
	[in]	jointPath = MDagPath
	[in]	effectorPath = MDagPath

This method will set the dag path for the starting joint and the
end-effector of the handle's joint chain. This method must be used
when setting the joints for a handle that are in a different
skeletal chain then the current one.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def setSolver(self, solverName): 
        '''setSolver(self, solverName)
Arguments:
	[in]	solverName = MString

Set the solver associated with this handle by name.'''
        pass

    def setEffector(self, effectorPath): 
        '''setEffector(self, effectorPath)
Arguments:
	[in]	effectorPath = MDagPath

Set the dag path to the end-effector of the handle's joint
chain. The end-effector/joint must be on the same skeletal chain as
the start joint or this method will fail.'''
        pass

    def setStartJoint(self, jointPath): 
        '''setStartJoint(self, jointPath)
Arguments:
	[in]	jointPath = MDagPath

This method will set the dag path for the starting joint of the
handle's joint chain. The start joint must be on the same skeletal
chain as the end effector or this method will fail.'''
        pass

    def poWeight(self): 
        '''poWeight(self) -> double
Returns: Returns:
The position/orientation weight

Gets the position/orientation weight of a handle. This is used
to compute the "distance" between the goal position and the
end-effector position.'''
        pass

    def setStickiness(self, stickiness): 
        '''setStickiness(self, stickiness)
Arguments:
	[in]	stickiness = MFnIkHandle.Stickiness

Set the stickiness of this handle. Sticky handles are solved
when the skeleton is being manipulated interactively. If a
character has sticky feet, the solver will attempt to keep them in
the same position as the user moves the character's root. If they
were not sticky, they would move along with the root.'''
        pass

    def getStartJoint(self, jointPath): 
        '''getStartJoint(self, jointPath)
Arguments:
	[out]	jointPath = MDagPath

This method will get a dag path to the starting joint of the
handle's joint chain.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def kStickyOff(self):
        '''This is an enum of Stickiness.
Description: Handle will move with skeleton's root.
Value: 0'''
        pass

    def kStickyOn(self):
        '''This is an enum of Stickiness.
Description: Handle will try to stay where it is.
Value: 1'''
        pass

    def kSuperSticky(self):
        '''This is an enum of Stickiness.
Description: Not used.
Value: 2'''
        pass

    class Stickiness:
        '''Non-functional class.  Values for this enum:
        kStickyOff
        kStickyOn
        kSuperSticky
'''
        def __init__(self):
            pass

    def setPOWeight(self, poWeight): 
        '''setPOWeight(self, poWeight)
Arguments:
	[in]	poWeight = double

Sets the position/orientation weight of a handle. This is used
to compute the "distance" between the goal position and the
end-effector position.'''
        pass

class MFnIkJoint:
    '''Function set for joints.(where '*' denotes matrix multiplication).The methods to get the value of these matrices are:'''
    def __init__(self):
        pass


    def maxRotateDampXStrength(self): 
        '''maxRotateDampXStrength(self) -> double
Returns: Returns:
Status code (see below)

Get the minimum of the damping strength in X.'''
        pass

    def maxRotateDampYStrength(self): 
        '''maxRotateDampYStrength(self) -> double
Returns: Returns:
Status code (see below)

Get the minimum of the damping strength in X.'''
        pass

    def setMaxRotateDampYRange(self, angle): 
        '''setMaxRotateDampYRange(self, angle)
Arguments:
	[in]	angle = double

Set the maximum of the damping range in Y'''
        pass

    def maxRotateDampZRange(self): 
        '''maxRotateDampZRange(self) -> double
Returns: Returns:
The maximum of the damping range in Z

Get the maximum of the damping range in Z. This corresponds to
the maxRotateDampZRange attribute on the joint.'''
        pass

    def getOrientation(self, rotation, order): 
        '''getOrientation(self, rotation, order)
Arguments:
	[out]	rotation = double3
	[out]	order = MTransformationMatrix.RotationOrder

Get the orientation of the coordinate axes.'''
        pass

    def setMinRotateDampXStrength(self, angle): 
        '''setMinRotateDampXStrength(self, angle)
Arguments:
	[in]	angle = double

Set the maximum of the damping strength in Z.'''
        pass

    def setMinRotateDampYRange(self, angle): 
        '''setMinRotateDampYRange(self, angle)
Arguments:
	[in]	angle = double

Set the minimum of the damping range in Y'''
        pass

    def setMinRotateDampZRange(self, angle): 
        '''setMinRotateDampZRange(self, angle)
Arguments:
	[in]	angle = double

Set the minimum of the damping range in Z'''
        pass

    def setPreferedAngle(self, rotation): 
        '''setPreferedAngle(self, rotation)
Arguments:
	[in]	rotation = double3

Set the preferred orientation for this joint (in XYZ order)'''
        pass

    def maxRotateDampZStrength(self): 
        '''maxRotateDampZStrength(self) -> double
Returns: Returns:
Status code (see below)

Get the minimum of the damping strength in X.'''
        pass

    def setMinRotateDampZStrength(self, angle): 
        '''setMinRotateDampZStrength(self, angle)
Arguments:
	[in]	angle = double

Set the minimum of the damping strength in Z.'''
        pass

    def create(self, parent): 
        '''create(self, parent) -> MObject
Returns: Returns:
The parent transform of the new joint

Arguments:
	[in]	parent = MObject

Create a new joint in a skeleton. In maya, skeletons are defined
entirely by DAG hierarchy. So, giving the joint you want to attach
to as a parent will add this joint to that skeleton.'''
        pass

    def minRotateDampXStrength(self): 
        '''minRotateDampXStrength(self) -> double
Returns: Returns:
Status code (see below)

Get the minimum of the damping strength in X.'''
        pass

    def getSegmentScale(self, scale): 
        '''getSegmentScale(self, scale)
Arguments:
	[out]	scale = double3

Get the local space scale values for the joint segment (bone).
This is equivalent to calling  MFnTransform::getScale .'''
        pass

    def getPreferedAngle(self, rotation): 
        '''getPreferedAngle(self, rotation)
Arguments:
	[out]	rotation = double3

Get the preferred orientation for this joint (in XYZ order)'''
        pass

    def minRotateDampZRange(self): 
        '''minRotateDampZRange(self) -> double
Returns: Returns:
The minimum damping range in Z

Get the minimum of the damping range in Z. This corresponds to
the minRotateDampZRange attribute on the joint.'''
        pass

    def setMinRotateDampYStrength(self, angle): 
        '''setMinRotateDampYStrength(self, angle)
Arguments:
	[in]	angle = double

Set the maximum of the damping strength in Y.'''
        pass

    def minRotateDampYRange(self): 
        '''minRotateDampYRange(self) -> double
Returns: Returns:
The minimum damping range in Y

Get the minimum of the damping range in Y. This corresponds to
the minRotateDampYRange attribute on the joint.'''
        pass

    def setMaxRotateDampZStrength(self, angle): 
        '''setMaxRotateDampZStrength(self, angle)
Arguments:
	[in]	angle = double

Set the maximum of the damping strength in Z.'''
        pass

    def setMinRotateDampXRange(self, angle): 
        '''setMinRotateDampXRange(self, angle)
Arguments:
	[in]	angle = double

Set the minimum of the damping range in X'''
        pass

    def minRotateDampZStrength(self): 
        '''minRotateDampZStrength(self) -> double
Returns: Returns:
Status code (see below)

Get the minimum of the damping strength in X.'''
        pass

    def maxRotateDampYRange(self): 
        '''maxRotateDampYRange(self) -> double
Returns: Returns:
The maximum of the damping range in Y

Get the maximum of the damping range in Y. This corresponds to
the maxRotateDampYRange attribute on the joint.'''
        pass

    def getStiffness(self, stiffness): 
        '''getStiffness(self, stiffness)
Arguments:
	[out]	stiffness = double3

Get the stiffness (from 0 to 100.0) for the joint. The stiffness
attribute is used by ik solvers to generate a resistance to a joint
motion. The higher the stiffness the less it will rotate. Stiffness
works in relative sense: it determines the willingness of this
joint to rotate with respect to the other joint in the ik
chain.'''
        pass

    def setStiffness(self, stiffness): 
        '''setStiffness(self, stiffness)
Arguments:
	[in]	stiffness = double3

Set the stiffness (from 0 to 100.0) for the joint. The stiffness
attribute is used by ik solvers to generate a resistance to a joint
motion. The higher the stiffness the less it will rotate. Stiffness
works in relative sense: it determines the willingness of this
joint to rotate with respect to the other joint in the ik
chain.'''
        pass

    def setMaxRotateDampXRange(self, angle): 
        '''setMaxRotateDampXRange(self, angle)
Arguments:
	[in]	angle = double

Set the maximum of the damping range in X'''
        pass

    def minRotateDampYStrength(self): 
        '''minRotateDampYStrength(self) -> double
Returns: Returns:
Status code (see below)

Get the minimum of the damping strength in X.'''
        pass

    def setSegmentScale(self, scale): 
        '''setSegmentScale(self, scale)
Arguments:
	[in]	scale = double3

Set the local space scale values for the joint segment (bone).
This is equivalent to calling Ttransform::setScale.'''
        pass

    def setDegreesOfFreedom(self, freeInX, freeInY, freeInZ): 
        '''setDegreesOfFreedom(self, freeInX, freeInY, freeInZ)
Arguments:
	[in]	freeInX = bool
	[in]	freeInY = bool
	[in]	freeInZ = bool

Set the degrees of freedom of this joint by specifying which
axes are allowed to rotate.'''
        pass

    def setOrientation(self, rotation, order): 
        '''setOrientation(self, rotation, order)
Arguments:
	[in]	rotation = double3
	[in]	order = MTransformationMatrix.RotationOrder

Set the orientation of the coordinate axes.'''
        pass

    def getDegreesOfFreedom(self, freeInX, freeInY, freeInZ): 
        '''getDegreesOfFreedom(self, freeInX, freeInY, freeInZ)
Arguments:
	[out]	freeInX = bool
	[out]	freeInY = bool
	[out]	freeInZ = bool

Get degrees of freedom of this joint'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def getScaleOrientation(self, rotation, order): 
        '''getScaleOrientation(self, rotation, order)
Arguments:
	[out]	rotation = double3
	[out]	order = MTransformationMatrix.RotationOrder

Get the orientation of the coordinate axes for rotation. This is
equivalent to calling the  MFnTransform::rotateOrientation 
method but returns the Euler rotation rather than the quaternion
rotation. The matrix equations used to combine the rotateAxis with
the other transformation attributes of the joint are described in
the description for the  MFnIkJoint  class.'''
        pass

    def setMaxRotateDampYStrength(self, angle): 
        '''setMaxRotateDampYStrength(self, angle)
Arguments:
	[in]	angle = double

Set the maximum of the damping strength in Y.'''
        pass

    def setMaxRotateDampXStrength(self, angle): 
        '''setMaxRotateDampXStrength(self, angle)
Arguments:
	[in]	angle = double

Set the maximum of the damping strength in X.'''
        pass

    def setMaxRotateDampZRange(self, angle): 
        '''setMaxRotateDampZRange(self, angle)
Arguments:
	[in]	angle = double

Set the maximum of the damping range in Z'''
        pass

    def setScaleOrientation(self, rotation, order): 
        '''setScaleOrientation(self, rotation, order)
Arguments:
	[in]	rotation = double3
	[in]	order = MTransformationMatrix.RotationOrder

Set the orientation of the coordinate axes for rotation. This is
equivalent to calling the  MFnTransform::setRotateOrientation 
method, and corresponds to the rotateAxis attribute on the joint
node. The matrix equations used to combine the rotateAxis with the
other transformation attributes of the joint are described in the
description for the  MFnIkJoint  class.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def maxRotateDampXRange(self): 
        '''maxRotateDampXRange(self) -> double
Returns: Returns:
The maximum of the damping range in X

Get the maximum of the damping range in X. This corresponds to
the maxRotateDampXRange attribute on the joint.'''
        pass

    def minRotateDampXRange(self): 
        '''minRotateDampXRange(self) -> double
Returns: Returns:
The minimum damping range in X

Get the minimum of the damping range in X. This corresponds to
the minRotateDampXRange attribute on the joint.'''
        pass

    def hikJointName(self): 
        '''hikJointName(self) -> MString
Returns: Returns:
The name used to identify this joint for HumanIK

Get the name that the HumanIK solver uses to identify this
joint.'''
        pass

class MFnIkSolver:
    '''Function set for inverse kinematics (IK) solvers.'''
    def __init__(self):
        pass


    def maxIterations(self): 
        '''maxIterations(self) -> int
Returns: Returns:
The maximum number of iterations used by this solver when
solving

Returns the maximum number of iterations used when solving.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def setTolerance(self, tolerance): 
        '''setTolerance(self, tolerance)
Arguments:
	[in]	tolerance = double

Sets the tolerance used when solving.'''
        pass

    def tolerance(self): 
        '''tolerance(self) -> double
Returns: Returns:
The tolerance value for this solver

Returns the tolerance used when solving.'''
        pass

    def setMaxIterations(self, maxIters): 
        '''setMaxIterations(self, maxIters)
Arguments:
	[in]	maxIters = int

Sets the maximum number of iterations used when solving.'''
        pass

class MFnKeyframeDelta:
    '''Base function set for keyframe deltas.'''
    def __init__(self):
        pass


    def paramCurve(self): 
        '''paramCurve(self) -> MObject
Returns: Returns:
A MObject,
readable by MFnAnimCurve.

Return the Animation Curve  MObject  that this key belongs to.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def keyIndex(self): 
        '''keyIndex(self) -> int
Returns: Returns:
An unsigned int representing the position of the key on the
curve.

The index of this key on the animation curve.'''
        pass

class MFnKeyframeDeltaAddRemove:
    '''Function set for the addition or removal keys on a curve.'''
    def __init__(self):
        pass


    def kReplaced(self):
        '''This is an enum of DeltaType.
Description: Key replaced.
Value: 2'''
        pass

    def kAdded(self):
        '''This is an enum of DeltaType.
Description: Key added.
Value: 0'''
        pass

    def kRemoved(self):
        '''This is an enum of DeltaType.
Description: Key removed.
Value: 1'''
        pass

    class DeltaType:
        '''Non-functional class.  Values for this enum:
        kReplaced
        kAdded
        kRemoved
'''
        def __init__(self):
            pass

    def deltaType(self): 
        '''deltaType(self) -> MFnKeyframeDeltaAddRemove.DeltaType

Indicates the type of change that this class instance
represents.'''
        pass

    def value(self): 
        '''value(self) -> double
Returns: Returns:
A double value

The value of the key that was added or removed.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def replacedValue(self): 
        '''replacedValue(self) -> double
Returns: Returns:
A double value

The value of the key that was replaced. This method is only
applicable to the kReplaced operation. Otherwise it will return
0.'''
        pass

    def time(self): 
        '''time(self) -> MTime
Returns: Returns:
A MTime
value of the added/removed key.

The time value of the key that was added or removed.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def keyIndex(self): 
        '''keyIndex(self) -> int
Returns: Returns:
An unsigned int representing the position of the key on the
curve.

The index of this key on the animation curve.'''
        pass

class MFnKeyframeDeltaBlockAddRemove:
    '''Function set for block add or removal of keys.'''
    def __init__(self):
        pass


    def numKeys(self): 
        '''numKeys(self) -> int
Returns: Returns:

Total number of keys involved in this add or remove
operation.'''
        pass

    def kAdded(self):
        '''This is an enum of DeltaType.
Description: Keys were added.
Value: 0'''
        pass

    def kRemoved(self):
        '''This is an enum of DeltaType.
Description: Keys were removed.
Value: 1'''
        pass

    class DeltaType:
        '''Non-functional class.  Values for this enum:
        kAdded
        kRemoved
'''
        def __init__(self):
            pass

    def getTimes(self, times): 
        '''getTimes(self, times)
Arguments:
	[out]	times = MTimeArray

Returns the times of all keys involved in the group add or
remove.'''
        pass

    def deltaType(self): 
        '''deltaType(self) -> MFnKeyframeDeltaBlockAddRemove.DeltaType
Returns: Returns:


kAdded - a block of keys were added.
kRemoved - a block of keys were removed.

Indicates the type of change, i.e. keys added or removed, that
this class instance represents.'''
        pass

    def getValues(self, values): 
        '''getValues(self, values)
Arguments:
	[out]	values = MDoubleArray

Returns the values of all keys involved in the group add or
remove.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def startTime(self): 
        '''startTime(self) -> MTime
Returns: Returns:
An MTime
value.

An  MTime 
value indicating the start time of the add/remove.'''
        pass

    def endTime(self): 
        '''endTime(self) -> MTime
Returns: Returns:
An MTime
value indicating the end of the add/remove.

Returns an  MTime 
value indicating the endTime of the add/remove.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnKeyframeDeltaBreakdown:
    '''Function set for changes in a key's breakdown state.'''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def wasBreakdown(self): 
        '''wasBreakdown(self) -> bool
Returns: Returns:
true or false depending on the key's breakdown state.

Returns the previous breakdown state of the key. It will return
false if the key was converted to a breakdown key.'''
        pass

    def isBreakdown(self): 
        '''isBreakdown(self) -> bool
Returns: Returns:
true or false depending on the key's breakdown state.

Returns the current breakdown state of the key. It will return
true if the key was converted to a breakdown key.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnKeyframeDeltaInfType:
    '''Function set for changes in pre or post infinity type.'''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def currentInfinityType(self): 
        '''currentInfinityType(self) -> MFnAnimCurve.InfinityType
Returns: Returns:
The current InfinityType for the curve

The current infinity type.'''
        pass

    def isPreInfinity(self): 
        '''isPreInfinity(self) -> bool
Returns: Returns:
true if this class encapsulates changes to the
pre-infinity type.

This class can describe changes to both the pre-infinity and
post-infinity this method allows the API user to figure out which
type this class represents.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def previousInfinityType(self): 
        '''previousInfinityType(self) -> MFnAnimCurve.InfinityType
Returns: Returns:
The previous infinityType for the curve.

The previous infinity type.'''
        pass

class MFnKeyframeDeltaMove:
    '''Function set for change in keyframe value or time.'''
    def __init__(self):
        pass


    def previousTime(self): 
        '''previousTime(self) -> MTime
Returns: Returns:
A MTime
containing the previous time of this key.

The previous time value of this key.'''
        pass

    def currentValue(self): 
        '''currentValue(self) -> double
Returns: Returns:
A double representing the current value of the key.

The current value of the key. The value corresponds to the units
of the animation curve.'''
        pass

    def previousValue(self): 
        '''previousValue(self) -> double
Returns: Returns:
A double representing the previous value of the key.

The previous value of the key prior to the change. The value
corresponds to the units of the animation curve.'''
        pass

    def currentTime(self): 
        '''currentTime(self) -> MTime
Returns: Returns:
A MTime
containing the current time of this key.

The current/current time value.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def previousIndex(self): 
        '''previousIndex(self) -> int
Returns: Returns:
An unsigned value representing the previous index of this key
on the curve.

The previous index value of this key. If a key has been moved
over another key then you can use this previous index to figure out
where the key was moved from.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def keyIndex(self): 
        '''keyIndex(self) -> int
Returns: Returns:
An unsigned value representing the current index of this key on
the curve.

The current index value of this key.'''
        pass

class MFnKeyframeDeltaScale:
    '''Function set for scaling in time.'''
    def __init__(self):
        pass


    def pivotTime(self): 
        '''pivotTime(self) -> MTime
Returns: Returns:
An MTime
value

The pivot point of the scale (in time).'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def startTime(self): 
        '''startTime(self) -> MTime
Returns: Returns:
An MTime
value

The start time of the scaling block.'''
        pass

    def currentEndTime(self): 
        '''currentEndTime(self) -> MTime
Returns: Returns:
An MTime
value

The current end time.'''
        pass

    def currentStartTime(self): 
        '''currentStartTime(self) -> MTime
Returns: Returns:
An MTime
value

The current scale time (after scaling has been performed).'''
        pass

    def endTime(self): 
        '''endTime(self) -> MTime
Returns: Returns:
An MTime
value

The end time of the scaling block.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnKeyframeDeltaTangent:
    '''Function set for changes to a key's tangent.'''
    def __init__(self):
        pass


    def getPreviousPosition(self, x, y): 
        '''getPreviousPosition(self, x, y)
Arguments:
	[out]	x = float
	[out]	y = float

Get the values of the previous time/value position of the
tangent for this key.'''
        pass

    def getCurrentPosition(self, x, y): 
        '''getCurrentPosition(self, x, y)
Arguments:
	[out]	x = float
	[out]	y = float

Get the values of the current time/value position of the tangent
for this key.'''
        pass

    def isInTangent(self): 
        '''isInTangent(self) -> bool
Returns: Returns:


true if the incoming tangent was modified.
false if the outgoing tangent was modified.

Key's have two tangents, in-bound and out-bound. A
MFnKeyframeTangent object can created once for each tangent. Use
this method to determine which tangent was modified.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def currentTangentType(self): 
        '''currentTangentType(self) -> MFnAnimCurve.TangentType
Returns: Returns:
The current tangent type.

Returns the current tangent type that the key represents.'''
        pass

    def previousTangentType(self): 
        '''previousTangentType(self) -> MFnAnimCurve.TangentType
Returns: Returns:
The previous tangent type.

Returns the previous tangent type.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnKeyframeDeltaWeighted:
    '''Function set for changes in a key's weighted state.'''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def wasWeighted(self): 
        '''wasWeighted(self) -> bool
Returns: Returns:
true or false depending on the key's weight status.

Returns true if the key had weighted tangent, but it is not
currently.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnLattice:
    '''Lattice function set.'''
    def __init__(self):
        pass


    def reset(self, sSize, tSize, uSize): 
        '''reset(self, sSize, tSize, uSize)
Arguments:
	[in]	sSize = double
	[in]	tSize = double
	[in]	uSize = double

Reset the lattice points to a uniform parallelipiped shape with
the specified dimensions: sSize x tSize x uSize'''
        pass

    def setDivisions(self, s, t, u): 
        '''setDivisions(self, s, t, u)
Arguments:
	[in]	s = int
	[in]	t = int
	[in]	u = int

Set the number of divisions in the lattice'''
        pass

    def point(self, s, t, u): 
        '''point(self, s, t, u) -> MPoint
Returns: Returns:
The point

Arguments:
	[in]	s = int
	[in]	t = int
	[in]	u = int

Returns the point in the lattice that is at the given
indices'''
        pass

    def getDivisions(self, s, t, u): 
        '''getDivisions(self, s, t, u)
Arguments:
	[out]	s = int
	[out]	t = int
	[out]	u = int

Get the number of divisions in the lattice'''
        pass

    def create(self, xDiv, yDiv, zDiv, parentOrOwner): 
        '''create(self, xDiv, yDiv, zDiv, parentOrOwner) -> MObject
Returns: Returns:
A handle to the new lattice data, lattice node or transform
node. See the discussion of the parentOrOwner parameter
above for more details.

Arguments:
	[in]	xDiv = int
	[in]	yDiv = int
	[in]	zDiv = int
	[in]	parentOrOwner = MObject

Create a new lattice. This can be used to create either a new
lattice shape in the DAG, or to place new lattice geometry into a
dependency graph lattice data object. Lattice data objects can be
created with  MFnLatticeData  or
can be obtained from an  MDataHandle 
in the compute method of a dependency node.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnLatticeDeformer:
    '''FFD lattice deformer function set.'''
    def __init__(self):
        pass


    def setDivisions(self, x, y, z): 
        '''setDivisions(self, x, y, z)
Arguments:
	[in]	x = int
	[in]	y = int
	[in]	z = int

Set the number of divisions in each of the X, Y, and Z
directions. The number of divisions specifies the resolution of the
lattice.'''
        pass

    def deformLattice(self): 
        '''deformLattice(self) -> MObject
Returns: Returns:
Handle for the deformed lattice shape

This returns the deformed version of the lattice. The deformed
lattice is a shape in the DAG and should be modified using the
 MFnLattice  function set.'''
        pass

    def getDivisions(self, x, y, z): 
        '''getDivisions(self, x, y, z)
Arguments:
	[out]	x = int
	[out]	y = int
	[out]	z = int

Retrieve the number of divisions in each of the X, Y, and Z
directions. The number of divisions specifies the resolution of the
lattice.'''
        pass

    def create(self, xDiv, yDiv, zDiv): 
        '''create(self, xDiv, yDiv, zDiv) -> MObject
Returns: Returns:
Returns a handle to the new deformer

Arguments:
	[in]	xDiv = int
	[in]	yDiv = int
	[in]	zDiv = int

Creates a new lattice deformer with the given number of
divisions. This function set's object is set to be the new lattice
node.'''
        pass

    def baseLattice(self): 
        '''baseLattice(self) -> MObject
Returns: Returns:
Handle for the base lattice shape

This returns the base version of the lattice that describes the
region of space deformed by the lattice. The returned base lattice
is a shape in the DAG and can be accessed using the  MFnDagNode  function set.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def resetLattice(self, centerLattice): 
        '''resetLattice(self, centerLattice)
Arguments:
	[in]	centerLattice = bool

This method resets the deformed lattice to match the base
lattice.'''
        pass

    def addGeometry(self, object): 
        '''addGeometry(self, object)
Arguments:
	[in]	object = MObject

Adds a piece of geometry to the deformation.'''
        pass

    def getAffectedGeometry(self, objects): 
        '''getAffectedGeometry(self, objects)
Arguments:
	[out]	objects = MObjectArray

The geometry affected by this deformer is packed into the
provided list of MObjects. Each of the MObjects will be a DAG node
that has geometry.'''
        pass

    def removeGeometry(self, object): 
        '''removeGeometry(self, object)
Arguments:
	[in]	object = MObject

Removes a piece of geometry from the deformation.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnMotionPath:
    '''Motion path animation function set.'''
    def __init__(self):
        pass


    def numPositionMarkers(self): 
        '''numPositionMarkers(self) -> int
Returns: Returns:
The number of markers

Returns the number of position markers on this motion path.'''
        pass

    def upAxis(self): 
        '''upAxis(self) -> MFnMotionPath.Axis
Returns: Returns:
The up-axis for this motion path

Return the up-axis for this motion path.'''
        pass

    def pathObject(self): 
        '''pathObject(self) -> MDagPath
Returns: Returns:
The dag path of the motion path object

Return a dag path to the motion path object. The motion path
object is the curve/surface that animated objects of this node will
move along.'''
        pass

    def setUTimeStart(self, start): 
        '''setUTimeStart(self, start)
Arguments:
	[in]	start = MTime

Sets the starting time of the animation for the u parameter.'''
        pass

    def inverseNormal(self): 
        '''inverseNormal(self) -> bool
Returns: Returns:


true Inverse normal vector is used for object
alignment.
false Inverse normal vector is not used for object
alignment.

Determines whether the up-axis of the animated object for this
motion path is aligned to the opposite direction of the normal
vector of the path geometry.'''
        pass

    def getOrientationMarker(self, markerNum): 
        '''getOrientationMarker(self, markerNum) -> MObject
Returns: Returns:
The orientation marker

Arguments:
	[in]	markerNum = int

Gets the orientation marker where markerNum is the order in
which the marker was created.'''
        pass

    def follow(self): 
        '''follow(self) -> bool
Returns: Returns:


true Follow is turned on
false Follow is turned off

Determines whether follow is set for this motion path node.'''
        pass

    def setUStart(self, start): 
        '''setUStart(self, start)
Arguments:
	[in]	start = double

Sets the starting value of the u parameterization for the
animation.'''
        pass

    def uTimeStart(self): 
        '''uTimeStart(self) -> MTime
Returns: Returns:
The starting time

Returns the start time of the animation for the u parameter.'''
        pass

    def setPathObject(self, pathObject, modifier): 
        '''setPathObject(self, pathObject, modifier)
Arguments:
	[in]	pathObject = MDagPath
	[in]	modifier = MDGModifier

Set the curve or surface for this motion path. All animated
objects for this motion path will follow the new path that is
specified.'''
        pass

    def create(self, pathObject, objectToAnimate, timeStart, timeEnd, modifier): 
        '''create(self, pathObject, objectToAnimate, timeStart, timeEnd, modifier) -> MObject
Returns: Returns:
The new motion path node

Arguments:
	[in]	pathObject = MDagPath
	[in]	objectToAnimate = MDagPath
	[in]	timeStart = MTime
	[in]	timeEnd = MTime
	[in]	modifier = MDGModifier

Create a new motion path dependency node. When a motion path
node is created, the following defaults are set:'''
        pass

    def setUpAxis(self, axis): 
        '''setUpAxis(self, axis)
Arguments:
	[in]	axis = MFnMotionPath.Axis

Set the up-axis for this motion path.'''
        pass

    def getPositionMarker(self, markerNum): 
        '''getPositionMarker(self, markerNum) -> MObject
Returns: Returns:
The position marker

Arguments:
	[in]	markerNum = int

Gets the position marker where markerNum is the order in which
the marker was created.'''
        pass

    def bankThreshold(self): 
        '''bankThreshold(self) -> double
Returns: Returns:
The bank threshold.

Return the bank threshold for this motion path. The bank
threshold is used to specify the maximum bank angle. The default
value is 90 degrees.'''
        pass

    def numOrientationMarkers(self): 
        '''numOrientationMarkers(self) -> int
Returns: Returns:
The number of markers

Returns the number of orientation markers on this motion
path.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def bankScale(self): 
        '''bankScale(self) -> double
Returns: Returns:
The bank scale.

Return the bank scale for this motion path.'''
        pass

    def followAxis(self): 
        '''followAxis(self) -> MFnMotionPath.Axis
Returns: Returns:
The follow axis.

Return the follow axis for this motion path.'''
        pass

    def setInverseNormal(self, invert): 
        '''setInverseNormal(self, invert)
Arguments:
	[in]	invert = bool

If  true , enable alignment of the up axis of the moving
object(s) to the opposite direction of the normal vector of the
path geometry.'''
        pass

    def uEnd(self): 
        '''uEnd(self) -> double
Returns: Returns:
The end value

Returns the end value of the u parameterization for the
animation.'''
        pass

    def setUTimeEnd(self, end): 
        '''setUTimeEnd(self, end)
Arguments:
	[in]	end = MTime

Sets the end time of the animation for the u parameter.'''
        pass

    def getAnimatedObjects(self, array): 
        '''getAnimatedObjects(self, array)
Arguments:
	[out]	array = MDagPathArray

Returns an array of dag paths to the animated objects for this
motion path.'''
        pass

    def useNormal(self): 
        '''useNormal(self) -> bool
Returns: Returns:


true Normal vector is used for object alignment.
false Normal vector is not used for object
alignment.

Determines whether the up-axis of the animated object for this
motion path is aligned with the normal vector of the path
geometry.'''
        pass

    def setUEnd(self, end): 
        '''setUEnd(self, end)
Arguments:
	[in]	end = double

Sets the end value of the u parameterization for the
animation.'''
        pass

    def setBankScale(self, bankScale): 
        '''setBankScale(self, bankScale)
Arguments:
	[in]	bankScale = double

Set the bank scale for this motion path. If the computed bank
angles are not large enough, the user can specify the bankScale to
amplify them. The default value is 1.'''
        pass

    def setFollowAxis(self, axis): 
        '''setFollowAxis(self, axis)
Arguments:
	[in]	axis = MFnMotionPath.Axis

Sets the axis of the animated object that will follow the motion
path. Possible alignment parameters are  kXaxis ,
 kYaxiz , or  kZaxis .'''
        pass

    def bank(self): 
        '''bank(self) -> bool
Returns: Returns:


true Bank is enabled
false Bank is disabled

Determines whether bank has been enabled for this motion
path.'''
        pass

    def uTimeEnd(self): 
        '''uTimeEnd(self) -> MTime
Returns: Returns:
The end time

Returns the end time of the animation for the u parameter.'''
        pass

    def setBankThreshold(self, bankThreshold): 
        '''setBankThreshold(self, bankThreshold)
Arguments:
	[in]	bankThreshold = double

Set the bank threshold for this motion path. The bank threshold
is used to specify the maximum bank angle. The default value is 90
degrees.'''
        pass

    def setUseNormal(self, use): 
        '''setUseNormal(self, use)
Arguments:
	[in]	use = bool

If  true , enables alignment of the up axis of the animated
object to the normal vector of the path geometry.'''
        pass

    def setBank(self, bank): 
        '''setBank(self, bank)
Arguments:
	[in]	bank = bool

'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def uStart(self): 
        '''uStart(self) -> double
Returns: Returns:
The starting value

Returns the starting value of the u parameterization for the
animation.'''
        pass

    def addAnimatedObject(self, objectToAnimate, modifier): 
        '''addAnimatedObject(self, objectToAnimate, modifier)
Arguments:
	[in]	objectToAnimate = MDagPath
	[in]	modifier = MDGModifier

Add an object to be animated along this motion path.'''
        pass

    def setFollow(self, on, modifier): 
        '''setFollow(self, on, modifier)
Arguments:
	[in]	on = bool
	[in]	modifier = MDGModifier

Setting follow on will cause the animated object(s) local axis
to be aligned with the tangent of the motion path. The default
alignment axis is Y.'''
        pass

    def kXaxis(self):
        '''This is an enum of Axis.
Description: 
Value: 0'''
        pass

    def kYaxis(self):
        '''This is an enum of Axis.
Description: 
Value: 1'''
        pass

    def kZaxis(self):
        '''This is an enum of Axis.
Description: 
Value: 2'''
        pass

    class Axis:
        '''Non-functional class.  Values for this enum:
        kXaxis
        kYaxis
        kZaxis
'''
        def __init__(self):
            pass

class MFnSkinCluster:
    '''skinCluster function set'''
    def __init__(self):
        pass


    def getWeights(self, path, components, weights, influenceCount): 
        '''getWeights(self, path, components, weights, influenceCount)
Arguments:
	[in]	path = MDagPath
	[in]	components = MObject
	[out]	weights = MFloatArray
	[out]	influenceCount = int

This method is obsolete. Maya's skinCluster nodes store their
weights as doubles. This method has been replaced by one which uses
doubles instead of floats. This method only exists for
backwards-compilability of old plug-in code.'''
        pass

    def getPointsAffectedByInfluence(self, path, result, weights): 
        '''getPointsAffectedByInfluence(self, path, result, weights)
Arguments:
	[in]	path = MDagPath
	[out]	result = MSelectionList
	[out]	weights = MFloatArray

This method is obsolete. Maya's skinCluster nodes store their
weights as doubles. This method has been replaced by one which uses
doubles instead of floats. This method only exists for
backwards-compilability of old plug-in code.'''
        pass

    def indexForInfluenceObject(self, mpath): 
        '''indexForInfluenceObject(self, mpath) -> int
Returns: Returns:
The logical index of the influence object

Arguments:
	[in]	mpath = MDagPath

Returns the logical index of the matrix array attribute where
the specified influence object is attached.'''
        pass

    def getBlendWeights(self, path, components, weights): 
        '''getBlendWeights(self, path, components, weights)
Arguments:
	[in]	path = MDagPath
	[in]	components = MObject
	[out]	weights = MDoubleArray

This method returns weights from skinCluster's blend weight
array. These weights are used to determine the blending between
classical linear skinning and dual quaternion bases skinning on a
per vertex basis. The function returns the weights associated with
the components passed. The components are defined on the object
whose dagPath is specified.'''
        pass

    def setWeights(self, path, components, influenceIndices, values, normalize, oldValues): 
        '''setWeights(self, path, components, influenceIndices, values, normalize, oldValues)
Arguments:
	[in]	path = MDagPath
	[in]	components = MObject
	[in]	influenceIndices = MIntArray
	[in]	values = MFloatArray
	[in]	normalize = bool
	[in]	oldValues = MFloatArray

This method is obsolete. Maya's skinCluster nodes store their
weights as doubles. This method has been replaced by one which uses
doubles instead of floats. This method only exists for
backwards-compilability of old plug-in code.'''
        pass

    def setBlendWeights(self, path, components, weights): 
        '''setBlendWeights(self, path, components, weights)
Arguments:
	[in]	path = MDagPath
	[in]	components = MObject
	[out]	weights = MDoubleArray

This method sets weights in skinCluster's blend weight array.
These weights are used to determine the blending between classical
linear skinning and dual quaternion bases skinning on a per vertex
basis. The function sets the weights for the given components of
the object whose dagPath is specified. The array size should match
the number of components passed. Failing this, it will set the
smaller of the two.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def influenceObjects(self, paths): 
        '''influenceObjects(self, paths) -> int
Returns: Returns:
The number of influence objects

Arguments:
	[in]	paths = MDagPathArray

Returns an array of paths to the influence objects for the
skinCluster.'''
        pass

class MFnWeightGeometryFilter:
    '''Weight geometry filter function set.'''
    def __init__(self):
        pass


    def setWeight(self, path, components, values): 
        '''setWeight(self, path, components, values)
Arguments:
	[in]	path = MDagPath
	[in]	components = MObject
	[in]	values = MFloatArray

Sets the weights of the specified components of the object whose
DAG path is specified.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def getWeights(self, path, components, weights): 
        '''getWeights(self, path, components, weights)
Arguments:
	[in]	path = MDagPath
	[in]	components = MObject
	[out]	weights = MFloatArray

Gets the weights of the components that correspond to the
geometry whose DAG path is specified.'''
        pass

    def getWeightPlugStrings(self, list, plugStringArray): 
        '''getWeightPlugStrings(self, list, plugStringArray)
Arguments:
	[in]	list = MSelectionList
	[out]	plugStringArray = MStringArray

Set the plugStringArray argument to contain the names of the
plugs on this node that correspond to the components in the
selection list. The operation will fail if none of the items in the
selection list correspond to components weighted by this
cluster.'''
        pass

    def weightPlugStrings(self, list): 
        '''weightPlugStrings(self, list) -> MString
Returns: Returns:
A string containing the names of the plugs on this node that
correspond to the components in the selection list

Arguments:
	[in]	list = MSelectionList

Sets the plugStrings argument to be a string (separated by
spaces) containing the names of the plugs on this node that
correspond to the components in the selection list. The method can
be useful in conjunction with setting keys on a number of plugs.
The operation will fail if none of the items in the selection list
correspond to components weighted by this cluster.'''
        pass

class MFnWireDeformer:
    '''wire deformer function set'''
    def __init__(self):
        pass


    def wireDropOffDistance(self, wireIndex): 
        '''wireDropOffDistance(self, wireIndex) -> float
Returns: Returns:
The drop off distance

Arguments:
	[in]	wireIndex = int

Return the drop off distance of the wire at the given index.
Increasing this value will give the wire a greater area of
influence.'''
        pass

    def setCrossingEffect(self, crossingEffect): 
        '''setCrossingEffect(self, crossingEffect)
Arguments:
	[in]	crossingEffect = float

Sets the local intensity for this wire deformer.'''
        pass

    def localIntensity(self): 
        '''localIntensity(self) -> float
Returns: Returns:
The local intensity value

Returns the local intensity for this wire deformer.'''
        pass

    def holdingShape(self, wireIndex): 
        '''holdingShape(self, wireIndex) -> MObject
Returns: Returns:
Return status

Arguments:
	[in]	wireIndex = int

Returns the holding shape for the given wire. The holding shape
may be a nurbs curve or a nurbs surface. If the given wire does not
have a holding shape, then a null  MObject  handle will be returned.'''
        pass

    def wireScale(self, wireIndex): 
        '''wireScale(self, wireIndex) -> float
Returns: Returns:
The radial scale value

Arguments:
	[in]	wireIndex = int

Return the radial scale of the wire at the given index. The
scale value affects how the wire modifies the geometry in its area
of influence. A value of between 0.0 and 1.0 causes the wire to
pull the surrounding geometry points towards itself. A value of
greater than one causes the wire to repulse the geometry points
around it. A value of exactly 1.0 causes the wire to neither pull
nor push the points around it.'''
        pass

    def wire(self, wireIndex): 
        '''wire(self, wireIndex) -> MObject
Returns: Returns:
A handle to the given wire curve

Arguments:
	[in]	wireIndex = int

Return the wire at the given index. The returned object will be
a nurbs curve shape suitable for use with the  MFnNurbsCurve  function set.'''
        pass

    def getDropoffLocator(self, wireIndex, locatorIndex, param, percentage): 
        '''getDropoffLocator(self, wireIndex, locatorIndex, param, percentage)
Arguments:
	[in]	wireIndex = int
	[in]	locatorIndex = int
	[out]	param = float
	[out]	percentage = float

Gets the parameters of a drop off locator.'''
        pass

    def setLocalIntensity(self, localIntensity): 
        '''setLocalIntensity(self, localIntensity)
Arguments:
	[in]	localIntensity = float

Sets the local intensity for this wire deformer.'''
        pass

    def create(self): 
        '''create(self) -> MObject
Returns: Returns:
Returns a handle to the new deformer

Creates a new wire deformer. This function set's object is set
to be the new wire deformer node.'''
        pass

    def setWireDropOffDistance(self, wireIndex, dropOff): 
        '''setWireDropOffDistance(self, wireIndex, dropOff)
Arguments:
	[in]	wireIndex = int
	[in]	dropOff = float

Sets the drop off distance of the wire at the given index.
Increasing this value will give the wire a greater area of
influence.'''
        pass

    def setEnvelope(self, envelope): 
        '''setEnvelope(self, envelope)
Arguments:
	[in]	envelope = float

Sets the envelope for this deformer.'''
        pass

    def removeGeometry(self, object): 
        '''removeGeometry(self, object)
Arguments:
	[in]	object = MObject

Removes a piece of geometry from the deformation.'''
        pass

    def setRotation(self, rotation): 
        '''setRotation(self, rotation)
Arguments:
	[in]	rotation = float

Sets the rotation value for this deformer.'''
        pass

    def setHoldingShape(self, wireIndex, holdingShape): 
        '''setHoldingShape(self, wireIndex, holdingShape)
Arguments:
	[in]	wireIndex = int
	[in]	holdingShape = MObject

Sets the holding shape for the given wire. The holding shape may
be a nurbs curve or a nurbs surface.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def crossingEffect(self): 
        '''crossingEffect(self) -> float
Returns: Returns:
The crossing effect value

Returns the crossing effect for this wire deformer.'''
        pass

    def setWireScale(self, wireIndex, scale): 
        '''setWireScale(self, wireIndex, scale)
Arguments:
	[in]	wireIndex = int
	[in]	scale = float

Sets the radial scale value of the wire at the given index. The
scale value affects how the wire modifies the geometry in its area
of influence. A value of between 0.0 and 1.0 causes the wire to
pull the surrounding geometry points towards itself. A value of
greater than one causes the wire to repulse the geometry points
around it. A value of exactly 1.0 causes the wire to neither pull
nor push the points around it.'''
        pass

    def setDropoffLocator(self, wireIndex, locatorIndex, param, percentage): 
        '''setDropoffLocator(self, wireIndex, locatorIndex, param, percentage)
Arguments:
	[in]	wireIndex = int
	[in]	locatorIndex = int
	[in]	param = float
	[in]	percentage = float

Sets the parameters of a drop off locator.'''
        pass

    def envelope(self): 
        '''envelope(self) -> float
Returns: Returns:
The envelope value

Returns the envelope for this deformer.'''
        pass

    def addGeometry(self, object): 
        '''addGeometry(self, object)
Arguments:
	[in]	object = MObject

Adds a piece of geometry to the deformation.'''
        pass

    def numDropoffLocators(self, wireIndex): 
        '''numDropoffLocators(self, wireIndex) -> int
Returns: Returns:
The number of drop off locators for the given curve

Arguments:
	[in]	wireIndex = int

Returns the number of drop off locators.'''
        pass

    def rotation(self): 
        '''rotation(self) -> float
Returns: Returns:
The rotation value

Returns the rotation value for this deformer.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def getAffectedGeometry(self, objects): 
        '''getAffectedGeometry(self, objects)
Arguments:
	[out]	objects = MObjectArray

The geometry affected by this deformer is packed into the
provided list of MObjects. Each of the MObjects will be a DAG node
that has geometry.'''
        pass

    def addWire(self, object): 
        '''addWire(self, object)
Arguments:
	[in]	object = MObject

Adds a new wire curve to the deformation.'''
        pass

    def numWires(self): 
        '''numWires(self) -> int
Returns: Returns:
The number of wires

returns the number of wire curves connected to this
deformer.'''
        pass

class MIkHandleGroup:
    '''IK handle groups.'''
    def __init__(self):
        pass


    def handle(self, ith): 
        '''handle(self, ith) -> MObject
Returns: Returns:
An MObject for the
handle

Arguments:
	[in]	ith = int

Return the ith handle in the handle list for this group.'''
        pass

    def checkEffectorAtGoal(self): 
        '''checkEffectorAtGoal(self) -> bool
Returns: Returns:


true The end-effector is at the goal location
false The end-effector is not at the goal location

Determines whether the end-effector at the handle(goal)
location.'''
        pass

    def solverPriority(self): 
        '''solverPriority(self) -> int
Returns: Returns:
The solver priority

return the priority of the solver used by this handle group.'''
        pass

    def handleCount(self): 
        '''handleCount(self) -> int
Returns: Returns:
The number of handles

Return the number of handles in the handle list for this
group.'''
        pass

    def priority(self): 
        '''priority(self) -> int
Returns: Returns:
The priority

Return the priority value of this handle group.'''
        pass

    def setSolverID(self, id): 
        '''setSolverID(self, id)
Arguments:
	[in]	id = int

Set the solver id for this handle group.'''
        pass

    def solverID(self): 
        '''solverID(self) -> int
Returns: Returns:
The solver id for this group

Return the solver id used by this handle group.'''
        pass

    def setPriority(self, priority): 
        '''setPriority(self, priority)
Arguments:
	[in]	priority = int

Set the priority of this handle group.'''
        pass

    def solve(self): 
        '''solve(self)
Do all ik solving steps for this group.'''
        pass

    def dofCount(self): 
        '''dofCount(self) -> int
Returns: Returns:
The total number of dofs

Return the total number of degrees of freedom of this handle
group.'''
        pass

class MIkSystem:
    '''Inverse kinematics (IK) system class'''
    def __init__(self):
        pass


    def getSolvers(self, names): 
        '''getSolvers(self, names)
Arguments:
	[out]	names = MStringArray

Get a list of the names for the solvers that are available in
the system.'''
        pass

    def isGlobalSolve(self): 
        '''isGlobalSolve(self) -> bool

Determines whether global solving is on.'''
        pass

    def findSolver(self, name): 
        '''findSolver(self, name) -> MObject
Returns: Returns:
The ik solver matching the given name

Arguments:
	[in]	name = MString

Returns the ik solver with the given name. If the solver cannot
be found then a a null  MObject  and an error is returned.'''
        pass

    def setGlobalSolve(self, isSolve): 
        '''setGlobalSolve(self, isSolve)
Arguments:
	[in]	isSolve = bool

Turns global solving on or off.'''
        pass

    def isGlobalSnap(self): 
        '''isGlobalSnap(self) -> bool
Returns: Returns:


true global snapping is on
false global snapping is off

Determines whether global snapping is on. Turning on global
snapping will turn on snapping for all ik handles.'''
        pass

    def setGlobalSnap(self, isSnap): 
        '''setGlobalSnap(self, isSnap)
Arguments:
	[in]	isSnap = bool

Turns global snapping on or off. Turning on global snapping will
turn on snapping for all ik handles.'''
        pass

class MItKeyframe:
    '''Keyframe Iterator.'''
    def __init__(self):
        pass


    def reset(self): 
        '''reset(self)
Resets the keyframe index to 0 (first keyframe) on the Anim
Curve Node to which the iterator is attached.'''
        pass

    def outTangentType(self): 
        '''outTangentType(self) -> MItKeyframe.TangentType
Returns: Returns:
Type of the tangent

Determines the type of the tangent to the curve leaving the
current keyframe.'''
        pass

    def setValue(self, value): 
        '''setValue(self, value)
Arguments:
	[in]	value = double

Sets the value of the current keyframe.'''
        pass

    def getTangentOut(self, x, y): 
        '''getTangentOut(self, x, y)
Arguments:
	[out]	x = float
	[out]	y = float

Determines the x,y value of the tangent to the curve leaving the
current keyframe.'''
        pass

    def setTangentsLocked(self, locked): 
        '''setTangentsLocked(self, locked)
Arguments:
	[in]	locked = bool

Lock or unlock the tangents at this keyframe.'''
        pass

    def inTangentType(self): 
        '''inTangentType(self) -> MItKeyframe.TangentType
Returns: Returns:
Type of the tangent

Determines the type of the tangent to the curve entering the
current keyframe.'''
        pass

    def value(self): 
        '''value(self) -> double
Returns: Returns:
Value of the current keyframe

Determines the value of the current keyframe.'''
        pass

    def next(self): 
        '''next(self)
Moves to the next keyframe on the Anim Curve Node to which the
iterator is attached.'''
        pass

    def kTangentGlobal(self):
        '''This is an enum of TangentType.
Description: 
Value: 0'''
        pass

    def kTangentFast(self):
        '''This is an enum of TangentType.
Description: Fast tangent.
Value: 7'''
        pass

    def kTangentPlateau(self):
        '''This is an enum of TangentType.
Description: Similar to smooth except that minima and maxima between
keyframes are flattened, if necessary, to prevent them overshooting
their keys.
Value: 9'''
        pass

    def kTangentFixed(self):
        '''This is an enum of TangentType.
Description: Normally, if a key is moved tangent values will be adjusted to
maintain their relationships to the surrounding keys (linear,
smooth, etc).
Value: 1'''
        pass

    def kTangentSmooth(self):
        '''This is an enum of TangentType.
Description: The in and out tangents are colinear and set to provide a
smooth transition from the key before to the key after.
Value: 4'''
        pass

    def kTangentStepNext(self):
        '''This is an enum of TangentType.
Description: Upon leaving the keyframe the value immediately jumps to that
of the next keyframe and stays there.
Value: 10'''
        pass

    def kTangentStep(self):
        '''This is an enum of TangentType.
Description: The key's value is maintained until the next key is reached
whereupon it immediately jumps to the new key's value.
Value: 5'''
        pass

    def kTangentClamped(self):
        '''This is an enum of TangentType.
Description: Same as smooth except when two keys are very close together in
which case the tangents between them are treated as linear. This
corrects for slippage which is sometimes seen when spline tangents
are used on keyframes which are close together.
Value: 8'''
        pass

    def kTangentFlat(self):
        '''This is an enum of TangentType.
Description: The tangent is horizontal.
Value: 3'''
        pass

    def kTangentSlow(self):
        '''This is an enum of TangentType.
Description: Slow tangent.
Value: 6'''
        pass

    def kTangentLinear(self):
        '''This is an enum of TangentType.
Description: For an in tangent this sets it to point directly at the
previous key. For an out tangent it points directly to the next
key. This is used to create straight lines between keys.
Value: 2'''
        pass

    class TangentType:
        '''Non-functional class.  Values for this enum:
        kTangentGlobal
        kTangentFast
        kTangentPlateau
        kTangentFixed
        kTangentSmooth
        kTangentStepNext
        kTangentStep
        kTangentClamped
        kTangentFlat
        kTangentSlow
        kTangentLinear
'''
        def __init__(self):
            pass

    def getTangentIn(self, x, y): 
        '''getTangentIn(self, x, y)
Arguments:
	[out]	x = float
	[out]	y = float

Determines the x,y value of the tangent to the curve entering
the current keyframe.'''
        pass

    def setTime(self, time): 
        '''setTime(self, time)
Arguments:
	[in]	time = MTime

Sets the time of the current keyframe. This will fail if setting
the time would require re-ordering of the keyframes.'''
        pass

    def setOutTangentType(self, tangentType): 
        '''setOutTangentType(self, tangentType)
Arguments:
	[in]	tangentType = MItKeyframe.TangentType

Sets the type of the tangent to the curve entering the current
keyframe.'''
        pass

    def time(self): 
        '''time(self) -> MTime
Returns: Returns:
Time (in seconds) of the current keyframe

Determines the time of the current keyframe.'''
        pass

    def setInTangentType(self, tangentType): 
        '''setInTangentType(self, tangentType)
Arguments:
	[in]	tangentType = MItKeyframe.TangentType

Sets the type of the tangent to the curve entering the current
keyframe.'''
        pass

    def tangentsLocked(self): 
        '''tangentsLocked(self) -> bool
Returns: Returns:


true if the tangents are locked
false if the tangents are not locked

Determines whether the tangents are locked at this keyframe.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: Returns:


true Done
false Not done

Indicates that the iterator is at the last keyframe on the Anim
Curve Node to which the iterator is attached (index = number of
keyframes - 1).'''
        pass

