
'''
Stub class file for:
OpenMayaMPx

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




class MPx3dModelView:
    '''3d Model View'''
    def __init__(self):
        pass


    def objectDisplay(self, dispObjs): 
        '''objectDisplay(self, dispObjs) -> bool

Arguments:
	[in]	dispObjs = M3dView.DisplayObjects

Returns true if the passed flag is set.'''
        pass

    def preMultipleDraw(self): 
        '''preMultipleDraw(self)
This method is called before any drawing is performed in the
model view. It should control any setting required for every pass
that will be drawn.   Reprocessed example '''
        pass

    def getCameraSet(self, cameraSet): 
        '''getCameraSet(self, cameraSet)
Arguments:
	[out]	cameraSet = MObject

Get the cameraSet for this view.'''
        pass

    def setDrawAdornments(self, display): 
        '''setDrawAdornments(self, display)
Arguments:
	[in]	display = bool

Toggles the control of how adornments are drawn in the view.
Adornments are objects that are drawn in the viewport that are not
scene entities. This includes the origin axis and the camera
decorations like film gate and resolution gate. These items are
usually drawn last and outside of the multiple refresh loop. You
can choose to disable the drawing of the adornments by specifying
false here, and you can control the drawing of the feature within
their display loop calling displayAdornmentsNow() method on this
class. By default this flag is true; so adornments are always drawn
unless explicitly disabled by you.'''
        pass

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

This method is called when a specified pass is finshed.'''
        pass

    def drawText(self, text, position, textPosition): 
        '''drawText(self, text, position, textPosition)
Arguments:
	[in]	text = MString
	[in]	position = MPoint
	[in]	textPosition = M3dView.TextPosition

Draws the given text at the given spot in the default font. This
method is provided as a convienient way to draw OpenGL text.'''
        pass

    def clearOverlayPlane(self): 
        '''clearOverlayPlane(self)
Clear the overlay plane.'''
        pass

    def updateViewingParameters(self): 
        '''updateViewingParameters(self)
This method tells the camera to set the view's transformation
matrix.'''
        pass

    def setUserDefinedColor(self, index, color): 
        '''setUserDefinedColor(self, index, color)
Arguments:
	[in]	index = int
	[in]	color = MColor

Sets the user defined color at the given index. Valid indices
range between zero and the number of user defined colors.'''
        pass

    def beginGL(self): 
        '''beginGL(self)
Setup port for native OpenGL drawing calls. Only make openGL
calls between the  beginGL() 
and  endGL() 
methods.  M3dView  and  MPx3dModelView  calls should not be made betwen
 beginGL() 
and  endGL() 
calls.'''
        pass

    def setFogEnabled(self, state): 
        '''setFogEnabled(self, state)
Arguments:
	[in]	state = bool

Enables and disables fog. If fog is enabled for one pass and
disabled for another, the background fog will not be drawn. To
display background fog in that configuration, use the  MPx3dModelView::setBackgroundFogEnabled() 
call.'''
        pass

    def viewSelectedPrefix(self): 
        '''viewSelectedPrefix(self) -> MString
Returns: Returns:
The prefix.

Returns the prefix used when displaying the camera name in the
heads up display when view selected in on.'''
        pass

    def setTextureDisplayEnabled(self, textureDisplay): 
        '''setTextureDisplayEnabled(self, textureDisplay)
Arguments:
	[in]	textureDisplay = bool

Enables texture display'''
        pass

    def getColorIndexAndTable(self, glindex, index, table): 
        '''getColorIndexAndTable(self, glindex, index, table)
Arguments:
	[in]	glindex = int
	[out]	index = int
	[out]	table = M3dView.ColorTable

Returns the color table and index representing the given OpenGL
color-index value. This method is useful when converting color
indices obtained from glReadPixels(GL_COLOR_INDEX) to Maya
color-index values suitable for use with the colorAtIndex and
setDrawColor methods.'''
        pass

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


true Only active objects are shaded if this view is in
shaded mode
false All objects are shaded if this view is in shaded
mode

Returns  true  if this view's display style is shaded for
objects that are active and wireframe otherwise.'''
        pass

    def isTwoSidedLighting(self): 
        '''isTwoSidedLighting(self) -> bool
Returns: Returns:
true if two sided lighting is enabled.

Returns the state of two sided lighting.'''
        pass

    def fogColor(self): 
        '''fogColor(self) -> MColor
Returns: Returns:
The fog color.

Returns the fog color.'''
        pass

    def setBackfaceCulling(self, culling): 
        '''setBackfaceCulling(self, culling)
Arguments:
	[in]	culling = bool

Sets backface culling.'''
        pass

    def name(self): 
        '''name(self) -> MString
Returns: Returns:
The name of the view.

Returns the name of the view.'''
        pass

    def isBackgroundFogEnabled(self): 
        '''isBackgroundFogEnabled(self) -> bool
Returns: Returns:
true, if the background fog is enabled, otherwise false.

Returns true if the background fog is enabled.'''
        pass

    def viewSelectedSet(self): 
        '''viewSelectedSet(self) -> MObject
Returns: Returns:
The MObject

Returns an  MObject 
for the set used by view selected. If there is not a set associated
with this view, then an invalid  MObject  will be returned. Check the
isNull() method of the  MObject  to see if a valid set was
found.'''
        pass

    def setLightingMode(self, lightingMode): 
        '''setLightingMode(self, lightingMode)
Arguments:
	[in]	lightingMode = MPx3dModelView.LightingMode

Sets the lighting mode.'''
        pass

    def refresh(self, all, force): 
        '''refresh(self, all, force)
Arguments:
	[in]	all = bool
	[in]	force = bool

Refresh the this view. If  all  is set to  true  then
all of the 3d-view will be refreshed.'''
        pass

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

This method returns the number of multiple draw passes that are
going to be made. By default a 1 is returned.'''
        pass

    def viewToObjectSpace(self, x_pos, y_pos, localMatrixInverse, oPt, oVector): 
        '''viewToObjectSpace(self, x_pos, y_pos, localMatrixInverse, oPt, oVector)
Arguments:
	[in]	x_pos = short
	[in]	y_pos = short
	[in]	localMatrixInverse = MMatrix
	[out]	oPt = MPoint
	[out]	oVector = MVector

Takes a point in port coordinates and returns a corresponding
ray in object coordinates.'''
        pass

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

This method is called immediately before a specific pass is
about to be drawn. The unsigned int argument indictates which pass
is about to be drawn.'''
        pass

    def setDisplayStyle(self, style, activeOnly): 
        '''setDisplayStyle(self, style, activeOnly)
Arguments:
	[in]	style = M3dView.DisplayStyle
	[in]	activeOnly = bool

Sets the display style for this view. The display style can be
wireframe, flat-shaded, or smooth-shaded.'''
        pass

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

Sets the color used for hardware fogging.'''
        pass

    def displayCameraAnnotationOn(self): 
        '''displayCameraAnnotationOn(self) -> bool
Returns: Returns:
true if the camera annotation is displayed.

Returns the camera annotation display state for this  MPx3dModelView .'''
        pass

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

Determines the end location of hardware fogging. This is
meaniful for kFogLinear drop off type (set by the  MPx3dModelView::setFogMode() 
method).'''
        pass

    def beginOverlayDrawing(self): 
        '''beginOverlayDrawing(self)
Setup the OpenGL context for drawing on the overlay plane.'''
        pass

    def setInStereoDrawMode(self, flag): 
        '''setInStereoDrawMode(self, flag)
Arguments:
	[in]	flag = bool

Derived classes should call this method to indicate to Maya
whether the view is currently drawing in stereo.'''
        pass

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

Set the color to draw in. This method should only be used in
RGBA mode. It is a convenient replacement for glColor.'''
        pass

    def setCurrentCameraSetCamera(self, cameraName): 
        '''setCurrentCameraSetCamera(self, cameraName)
Arguments:
	[in]	cameraName = MString

Set a camera used by the currently specified cameraSet as the
controlled camera for this view.'''
        pass

    def kLightSelected(self):
        '''This is an enum of LightingMode.
Description: Selected lights only.
Value: 1'''
        pass

    def kLightNone(self):
        '''This is an enum of LightingMode.
Description: Use no lights.
Value: 4'''
        pass

    def kLightActive(self):
        '''This is an enum of LightingMode.
Description: Active lights only.
Value: 2'''
        pass

    def kLightAll(self):
        '''This is an enum of LightingMode.
Description: Use all lights.
Value: 0'''
        pass

    def kLightDefault(self):
        '''This is an enum of LightingMode.
Description: Default light only.
Value: 3'''
        pass

    def kLightQuality(self):
        '''This is an enum of LightingMode.
Description: Use per pixel lighting.
Value: 5'''
        pass

    class LightingMode:
        '''Non-functional class.  Values for this enum:
        kLightSelected
        kLightNone
        kLightActive
        kLightAll
        kLightDefault
        kLightQuality
'''
        def __init__(self):
            pass

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

This method returns the multiple draw enable state for this
view.'''
        pass

    def displayAxisAtOriginOn(self): 
        '''displayAxisAtOriginOn(self) -> bool
Returns: Returns:
true if the origin axis is displayed.

Returns the origin axis display state for this  MPx3dModelView .'''
        pass

    def getCameraHUDName(self): 
        '''getCameraHUDName(self) -> MString

Return the name to use for the camera in the heads up
display.'''
        pass

    def setFogMode(self, mode): 
        '''setFogMode(self, mode)
Arguments:
	[in]	mode = MPx3dModelView.FogMode

Sets the drop-off mode for fog. The possibilities are:'''
        pass

    def viewSelected(self): 
        '''viewSelected(self) -> bool
Returns: Returns:
true if view selected is enabled.

Returns the state of view selected for this view.'''
        pass

    def fogSource(self): 
        '''fogSource(self) -> MPx3dModelView.FogSource
Returns: Returns:
The algorithm used to compute fog.

Returns the algorithm used to compute fog. See  MPx3dModelView::setFogSource 
for a description.'''
        pass

    def getModelView(self, name): 
        '''getModelView(self, name) -> MPx3dModelView
Returns: Returns:
A pointer to the MPx3dModelView.

Arguments:
	[in]	name = MString

Returns a pointer to a  MPx3dModelView  that has the passed name with
the specified type (the same typed when registering the control).
If one does not exist, then a NULL pointer is returned.'''
        pass

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

This method queries the destruction setting for this  MPx3dModelView  which is employed when the panel
associated with this view is destroyed.'''
        pass

    def backgroundColor(self): 
        '''backgroundColor(self) -> MColor
Returns: Returns:
The template color

Returns the RGB values of the active template color.'''
        pass

    def colorAtIndex(self, index, table): 
        '''colorAtIndex(self, index, table) -> MColor
Returns: Returns:
The color

Arguments:
	[in]	index = int
	[in]	table = M3dView.ColorTable

Returns the RGB values of the color at the given index in the
application's color table.'''
        pass

    def isTextureDisplayEnabled(self): 
        '''isTextureDisplayEnabled(self) -> bool
Returns: Returns:
true if texture display is enabled.

Returns the enable state of texture display.'''
        pass

    def setBackgroundFogEnabled(self, state): 
        '''setBackgroundFogEnabled(self, state)
Arguments:
	[in]	state = bool

Enables and disables background fog.'''
        pass

    def setDoUpdateOnMove(self, value): 
        '''setDoUpdateOnMove(self, value)
Arguments:
	[in]	value = bool

Some viewports require a refresh when the user has moved the top
level window. This flag enables this custom view to trigger a
refresh event when the top level window of the view is moved to a
new location.'''
        pass

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

Users should override this method if they want a stereo buffer
enabled  MPx3dModelView . You must have a graphics card
that can support stereo mode. If your graphics card does not
support stereo mode, a non-stereo buffer is created.'''
        pass

    def templateColor(self): 
        '''templateColor(self) -> MColor
Returns: Returns:
The template color

Returns the RGB values of the template color.'''
        pass

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

Determines the start location of hardware fogging. This is
meaniful for kFogLinear drop off type (set by the  MPx3dModelView::setFogMode() 
method).'''
        pass

    def endOverlayDrawing(self): 
        '''endOverlayDrawing(self)
Set the OpenGL context to for normal screen drawing.'''
        pass

    def kFogLinear(self):
        '''This is an enum of FogMode.
Description: Linear drop off.
Value: 0'''
        pass

    def kFogExponential(self):
        '''This is an enum of FogMode.
Description: Exponential drop-off.
Value: 1'''
        pass

    def kFogExponentialSquared(self):
        '''This is an enum of FogMode.
Description: Squared exponential drop-off.
Value: 2'''
        pass

    class FogMode:
        '''Non-functional class.  Values for this enum:
        kFogLinear
        kFogExponential
        kFogExponentialSquared
'''
        def __init__(self):
            pass

    def isVisible(self): 
        '''isVisible(self) -> bool
Returns: Returns:
true if the view is visible, otherwise false is returned.

This method returns true if this view is visible, otherwise
false is returned.'''
        pass

    def setObjectsToView(self, list): 
        '''setObjectsToView(self, list)
Arguments:
	[in]	list = MSelectionList

Sets the list of objects used by view selected as a selection
list. View selected must be turned on for this to have an
effect.'''
        pass

    def setMultipleDrawEnable(self, enable): 
        '''setMultipleDrawEnable(self, enable)
Arguments:
	[in]	enable = bool

This method turns enables/disables multiple camera drawing for
this view. If multiple draw is disabled, then this view will behave
like a normal Maya view.'''
        pass

    def fogMode(self): 
        '''fogMode(self) -> MPx3dModelView.FogMode
Returns: Returns:
The type of drop off used with fog.

Return the type of drop off used with fog. See  MPx3dModelView::setFogMode 
for description of the drop off types.'''
        pass

    def isXrayEnabled(self): 
        '''isXrayEnabled(self) -> bool
Returns: Returns:
true if xray is enabled.

Returns the state of xray display.'''
        pass

    def userDefinedColorIndex(self, index): 
        '''userDefinedColorIndex(self, index) -> int
Returns: Returns:
Index of user-defined color into the active and dormant
tables

Arguments:
	[in]	index = int

Returns the index for the given user-defined color. Valid values
for the index argument range between zero and the number of
user-defined colors minus one.'''
        pass

    def removingCamera(self, cameraPath): 
        '''removingCamera(self, cameraPath)
Arguments:
	[in]	cameraPath = MDagPath

This method should be overloaded in  MPx3dModelView  derived classes. It will get
called whenever a camera that was used with this  MPx3dModelView  is deleted. The  MPx3dModelView  should then remove any reference
to the deleted camera.'''
        pass

    def displayAxisOn(self): 
        '''displayAxisOn(self) -> bool
Returns: Returns:
true if the axis is displayed.

Returns the axis display state for this  MPx3dModelView .'''
        pass

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

Returns the state of the adornment drawing for this view. See
setDrawAdornments for more information on adornment drawing.'''
        pass

    def setCameraSet(self, cameraSet): 
        '''setCameraSet(self, cameraSet)
Arguments:
	[in]	cameraSet = MObject

Set the cameraSet for this view.'''
        pass

    def displayStyle(self): 
        '''displayStyle(self) -> M3dView.DisplayStyle
Returns: Returns:
The display style for this view

Return the display style for this 3d view. The display style can
be wireframe, flat-shaded, or smooth-shaded.'''
        pass

    def endGL(self): 
        '''endGL(self)
End OpenGL drawing.'''
        pass

    def setViewSelectedSet(self, set): 
        '''setViewSelectedSet(self, set)
Arguments:
	[in]	set = MObject

Sets the list of objects used by view selected as an object set.
View selected must be turned on for this to have an effect.'''
        pass

    def fogDensity(self): 
        '''fogDensity(self) -> double
Returns: Returns:
The fog density.

Returns the fog density.'''
        pass

    def setCameraInDraw(self, camera): 
        '''setCameraInDraw(self, camera)
Arguments:
	[in]	camera = MDagPath

Sets the camera during a draw. If the normal  setCamera() 
method is used, then that camera will not get its parameters loaded
during the draw.'''
        pass

    def portWidth(self): 
        '''portWidth(self) -> int
Returns: Returns:
The width of this viewport

Returns the width of the current viewport.'''
        pass

    def numUserDefinedColors(self): 
        '''numUserDefinedColors(self) -> int
Returns: Returns:
The number of user defined colors

Returns the number of user defined colors in the internal
application color table. These colors may be changed by the user
and assigned to specific objects. See the methods of  MFnDagNode  for information on
assigning user defined colors to individual objects.'''
        pass

    def postMultipleDraw(self): 
        '''postMultipleDraw(self)
This method is called after the drawing is finished. Any cleanup
should be done by this method.   Reprocessed example '''
        pass

    def fogEnd(self): 
        '''fogEnd(self) -> double
Returns: Returns:
The fog end location.

Returns the fog end position.'''
        pass

    def getObjectsToView(self, list): 
        '''getObjectsToView(self, list)
Arguments:
	[out]	list = MSelectionList

Returns a selection list containing all of the objects on the
view selected list.'''
        pass

    def setDestroyOnPanelDestruction(self, how): 
        '''setDestroyOnPanelDestruction(self, how)
Arguments:
	[in]	how = bool

This method enables/disables destruction of the  MPx3dModelView  object when the panel is
destroyed. By default, Maya does not destroy the  MPx3dModelView  when the panel is destroyed.
Example cases of destroying a panel are when you tear off a panel,
or close a torn-off panel.'''
        pass

    def setWireframeOnShaded(self, onShaded): 
        '''setWireframeOnShaded(self, onShaded)
Arguments:
	[in]	onShaded = bool

Displays as wireframe on shaded.'''
        pass

    def setFogDensity(self, density): 
        '''setFogDensity(self, density)
Arguments:
	[in]	density = double

Determines the density of hardware fogging. This is meaniful for
kFogExponential and kFogExponentialSquared drop off types (set by
the  MPx3dModelView::setFogMode() 
method).'''
        pass

    def setObjectDisplay(self, displayType, display): 
        '''setObjectDisplay(self, displayType, display)
Arguments:
	[in]	displayType = M3dView.DisplayObjects
	[in]	display = bool

Sets the display option for various types of objects. By default
everything is displayed.'''
        pass

    def isBackfaceCulling(self): 
        '''isBackfaceCulling(self) -> bool
Returns: Returns:
true if backface culling is enabled.

Returns the state of backface culling.'''
        pass

    def portHeight(self): 
        '''portHeight(self) -> int
Returns: Returns:
The height of this viewport

Returns the height of the current viewport.'''
        pass

    def setDisplayAxisAtOrigin(self, enable): 
        '''setDisplayAxisAtOrigin(self, enable)
Arguments:
	[in]	enable = bool

Sets the origin axis display in the  MPx3dModelView .'''
        pass

    def okForMultipleDraw(self, dp): 
        '''okForMultipleDraw(self, dp) -> bool
Returns: Returns:
true if it is OK to draw the passed object.

Arguments:
	[in]	dp = MDagPath

This method provides some filter capabilities as to what is
drawn. When ever a draw operation during the multiple camera
drawing, this method will get called. If true is returned, then the
object will be drawn.'''
        pass

    def displayHUD(self): 
        '''displayHUD(self) -> bool
Returns: Returns:
The enable state for the HUD

Returns the heads up display state for this view.'''
        pass

    def setDisplayAxis(self, enable): 
        '''setDisplayAxis(self, enable)
Arguments:
	[in]	enable = bool

Sets the axis display in the  MPx3dModelView .'''
        pass

    def isWireframeOnShaded(self): 
        '''isWireframeOnShaded(self) -> bool
Returns: Returns:
true if backface onShaded is enabled.

Returns the state of wireframe on shaded.'''
        pass

    def drawHUDNow(self): 
        '''drawHUDNow(self)
Forces the HUD viewport elements to be drawn immediately. This
should only be called when setDrawAdornments has been set to false.
And this method should only be called in the postMultiple* draw
methods. This allows the drawing of display elements during a
specific pass while attached to a specific camera.'''
        pass

    def drawAdornmentsNow(self): 
        '''drawAdornmentsNow(self)
Forces the adornment viewport elements to be drawn immediately.
This should only be called when setDrawAdornments has been set to
false. And this method should only be called in the postMultiple*
draw methods. This allows you to draw camera adornments during a
specific pass while attached to a specific camera.'''
        pass

    def setViewSelected(self, enable): 
        '''setViewSelected(self, enable)
Arguments:
	[in]	enable = bool

Enables the view selected mode.'''
        pass

    def getAsM3dView(self, view): 
        '''getAsM3dView(self, view)
Arguments:
	[out]	view = M3dView

Get this  MPx3dModelView  as a  M3dView .'''
        pass

    def worldToView(self, worldPt, x_pos, y_pos): 
        '''worldToView(self, worldPt, x_pos, y_pos) -> bool
Returns: Returns:


true point is not clipped
false point is undefined or outside frustum

Arguments:
	[in]	worldPt = MPoint
	[out]	x_pos = short
	[out]	y_pos = short

converts a point in world space to port space. The return value
indicates if the point is not clipped.'''
        pass

    def setCamera(self, camera): 
        '''setCamera(self, camera)
Arguments:
	[in]	camera = MDagPath

Set the camera for this view.'''
        pass

    def setXrayEnabled(self, xray): 
        '''setXrayEnabled(self, xray)
Arguments:
	[in]	xray = bool

Sets xray display state.'''
        pass

    def lightingMode(self): 
        '''lightingMode(self) -> MPx3dModelView.LightingMode
Returns: Returns:
The lighting mode.

Returns the lighting mode.'''
        pass

    def setDisplayHUD(self, enable): 
        '''setDisplayHUD(self, enable)
Arguments:
	[in]	enable = bool

Enables or disables the drawing the heads up display in this
view. This method only affects this view and will stop all heads up
display elements from being drawn in this view.'''
        pass

    def fogStart(self): 
        '''fogStart(self) -> double
Returns: Returns:
The fog start position.

Returns the fog start position.'''
        pass

    def viewToWorld(self, x_pos, y_pos, nearClipPt, farClipPt): 
        '''viewToWorld(self, x_pos, y_pos, nearClipPt, farClipPt)
Arguments:
	[in]	x_pos = short
	[in]	y_pos = short
	[out]	nearClipPt = MPoint
	[out]	farClipPt = MPoint

Takes a point in port coordinates and returns a point on the
near and far clipping planes.'''
        pass

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


the state of the doUpdateOnMove flag

Returns the state of the doUpdateOnMove flag. This flag tells
the refresh architecture if it is necessary to refresh your view
when the user moves the control window for this viewport. If this
flag is true, then refresh will be triggered on window move.'''
        pass

    def setFogSource(self, source): 
        '''setFogSource(self, source)
Arguments:
	[in]	source = MPx3dModelView.FogSource

Sets the type of fog algorithm to use. If the  source 
argument is kFogFragment (default) then fog is computed per pixel.
If the argument is kFogCoordinate then if the geometry has
specified vertex fog coordinates, and the OpenGL extension for
vertex fog is supported by the graphics system, then fog is
computed per vertex.'''
        pass

    def setViewSelectedPrefix(self, prefix): 
        '''setViewSelectedPrefix(self, prefix)
Arguments:
	[in]	prefix = MString

Sets the prefix for the camera name as displayed in the heads up
display when view selected is enabled. The prefix is concatenated
with the camera name.'''
        pass

    def kFogCoordinate(self):
        '''This is an enum of FogSource.
Description: Computed by specified vertex fog coordinates.
Value: 1'''
        pass

    def kFogFragment(self):
        '''This is an enum of FogSource.
Description: Computed per pixel (default).
Value: 0'''
        pass

    class FogSource:
        '''Non-functional class.  Values for this enum:
        kFogCoordinate
        kFogFragment
'''
        def __init__(self):
            pass

    def setTwoSidedLighting(self, twoSided): 
        '''setTwoSidedLighting(self, twoSided)
Arguments:
	[in]	twoSided = bool

Enables two sided lighting.'''
        pass

    def setDisplayCameraAnnotation(self, enable): 
        '''setDisplayCameraAnnotation(self, enable)
Arguments:
	[in]	enable = bool

Sets the camera annotation display in the  MPx3dModelView .'''
        pass

    def numDormantColors(self): 
        '''numDormantColors(self) -> int
Returns: Returns:
The number of dormant colors

Returns the number of dormant object colors in the internal
application color table.'''
        pass

    def getCamera(self, camera): 
        '''getCamera(self, camera)
Arguments:
	[out]	camera = MDagPath

Get the camera for this view.'''
        pass

    def numActiveColors(self): 
        '''numActiveColors(self) -> int
Returns: Returns:
The number of active colors

Returns the number of active object colors in the internal
application color table.'''
        pass

    def getCurrentCameraSetCamera(self, cameraName): 
        '''getCurrentCameraSetCamera(self, cameraName)
Arguments:
	[out]	cameraName = MString

Get the cameraSet for this view.'''
        pass

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

'''
        pass

    def viewType(self): 
        '''viewType(self) -> MString

Returns a string specifying the view type. The view type should
be a different string for every class derived from  MPx3dModelView . The default type is
"MPx3dModelView".'''
        pass

    def isFogEnabled(self): 
        '''isFogEnabled(self) -> bool
Returns: Returns:
true is fog is enabled.

Returns true if fog is enabled.'''
        pass

class MPxBakeEngine:
    '''Baking functionality.'''
    def __init__(self):
        pass


    def bake(self, objectPath, cameraPath, samplePlug, result): 
        '''bake(self, objectPath, cameraPath, samplePlug, result)
Arguments:
	[in]	objectPath = MDagPath
	[in]	cameraPath = MDagPath
	[in]	samplePlug = MPlug
	[out]	result = MImage

Bake the texture Maya will use to approximate shading
properties.'''
        pass

    def setNeedTransparency(self, t): 
        '''setNeedTransparency(self, t)
Arguments:
	[in]	t = bool

Set whether the bake engine needs to produce an image with
transparency.'''
        pass

    def getUVRange(self, minUV, maxUV): 
        '''getUVRange(self, minUV, maxUV)
Arguments:
	[out]	minUV = MFloatArray
	[out]	maxUV = MFloatArray

Tells Maya the UV range the baked texture should cover.'''
        pass

class MPxCacheFormat:
    '''CacheFormat definition.'''
    def __init__(self):
        pass


    def beginWriteChunk(self): 
        '''beginWriteChunk(self) -> virtualvoid

Perform any actions required prior to writing a chunk's
information. A chunk contains the cache information for a specfic
time, and may contain multiple channels. 
  Reprocessed example '''
        pass

    def endWriteChunk(self): 
        '''endWriteChunk(self) -> virtualvoid

Perform any actions required after writing a chunk's
information. A chunk contains the cache information for a specfic
time, and may contain multiple channels. 
  Reprocessed example '''
        pass

    def extension(self): 
        '''extension(self) -> virtual MString

Provide the disk file extension for this format. This is not the
same as the format's key, which is used by the plugin to identify
itself.   Reprocessed example '''
        pass

    def writeHeader(self, version, startTime, endTime): 
        '''writeHeader(self, version, startTime, endTime) -> virtual MStatus

Arguments:
	[in]	version = MString
	[in]	startTime = MTime
	[in]	endTime = MTime

Write the header for the current cache. 
  Reprocessed example '''
        pass

    def readHeader(self): 
        '''readHeader(self) -> virtual MStatus

Read the header from the current cache data file, and store any
data that may be required.   Reprocessed example '''
        pass

    def writeTime(self, time): 
        '''writeTime(self, time) -> virtual MStatus

Arguments:
	[in]	time = MTime

Write the current time to the cache.'''
        pass

    def beginReadChunk(self): 
        '''beginReadChunk(self) -> virtual MStatus

Perform any actions required prior to reading a chunk's
information. A chunk contains the cache information for a specfic
time, and may contain multiple channels. 
  Reprocessed example '''
        pass

    def endReadChunk(self): 
        '''endReadChunk(self) -> virtualvoid

Perform any actions required after reading a chunk's
information. A chunk contains the cache information for a specfic
time, and may contain multiple channels. 
  Reprocessed example '''
        pass

    def readTime(self, time): 
        '''readTime(self, time) -> virtual MStatus

Arguments:
	[out]	time = MTime

Read the current time from the cache.'''
        pass

    def open(self, fileName, mode): 
        '''open(self, fileName, mode) -> virtual MStatus
Returns: Returns:
success if the cache file is supported.

Arguments:
	[in]	fileName = MString
	[in]	mode = MPxCacheFormat.FileAccessMode

Attempt to open the specified cache format. It is important that
this function only return success if the cache file is definitely
supported by this implementation.'''
        pass

    def kReadWrite(self):
        '''This is an enum of FileAccessMode.
Description: read and write (e.g. append, edit, etc.)
Value: 2'''
        pass

    def kWrite(self):
        '''This is an enum of FileAccessMode.
Description: write only
Value: 1'''
        pass

    def kRead(self):
        '''This is an enum of FileAccessMode.
Description: read only
Value: 0'''
        pass

    class FileAccessMode:
        '''Non-functional class.  Values for this enum:
        kReadWrite
        kWrite
        kRead
'''
        def __init__(self):
            pass

class MPxCameraSet:
    '''Base class for user-defined camera set nodes.'''
    def __init__(self):
        pass


    active = ''
    '''Boolean attribute determining if layer will
be processed. Child of 'cameraLayer'.'''

    camera = ''
    '''Message attribute connecting to layer's
camera transform. Child of 'cameraLayer'.'''

    cameraLayer = ''
    '''Compound array attribute for storing the
list of camera layers.'''

    order = ''
    '''Integer attribute giving the processing
order of the layer. Child of 'cameraLayer'.'''

    sceneData = ''
    '''Message attribute connecting to layer's
objectSet. Child of 'cameraLayer'.'''

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

Returns the type of node that this is. This is used to
differentiate user defined nodes that are derived off different MPx
base classes.'''
        pass

class MPxCommand:
    '''Base class for user commands.'''
    def __init__(self):
        pass


    def displayInfo(self, theInfo): 
        '''displayInfo(self, theInfo)
Arguments:
	[in]	theInfo = MString

This method is used to display information in the script
editor.'''
        pass

    def setCommandString(self, name): 
        '''setCommandString(self, name)
Arguments:
	[in]	name = MString

Sets the command string that is associated with this command
object.'''
        pass

    def syntax(self): 
        '''syntax(self) -> MSyntax

This method is intended to be used in an MArgDataBase or
 MArgParser  contructor when the
plugin command's syntax is being initialized. The user should
declare and define a syntax contstructing method that must be
registered with Maya by passing the function pointer as a parameter
in  MFnPlugin::registerCommand() .
The result is that when  MPxCommand::syntax() 
is called it returns the syntax object that the user has created in
the custom syntax constructing method that was registered. To avoid
conflicts it is important that the user's custom syntax defining
method be given a name other than "syntax." It can have any other
name as long as it corresponds with the function pointer used to
register the method with Maya.'''
        pass

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

This method specifies whether or not the command has a syntax
object.'''
        pass

    def commandString(self): 
        '''commandString(self) -> MString

This method returns the command string that is associated with
this command.'''
        pass

    def doIt(self, args): 
        '''doIt(self, args)
Arguments:
	[in]	args = MArgList

This method should perform a command by setting up internal
class data and then calling the  redoIt  method. The actual
action performed by the command should be done in the  redoIt 
method. This is a pure virtual method, and must be overridden in
derived classes.'''
        pass

    def redoIt(self): 
        '''redoIt(self)
This method should do the actual work of the command based on
the internal class data only. Internal class data should be set in
the  doIt  method.'''
        pass

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

Returns whether history is on.'''
        pass

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

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

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

    def kNoArg(self):
        '''This is an enum of MResultType.
Description: 
Value: 3'''
        pass

    class MResultType:
        '''Non-functional class.  Values for this enum:
        kLong
        kString
        kDouble
        kNoArg
'''
        def __init__(self):
            pass

    def currentDoubleResult(self): 
        '''currentDoubleResult(self) -> double
Returns: Returns:
The double result.

This method gets the current node's result as a double, if
possible.'''
        pass

    def undoIt(self): 
        '''undoIt(self)
This method should undo the work done be the  redoIt 
method based on the internal class data only.'''
        pass

    def appendToResult(self, val): 
        '''appendToResult(self, val)
Arguments:
	[in]	val = MStringArray

This method will add the given value to the end of the result
array of strings. The result array can only be of a single type so
this method can only be used when the result string has not been
set or is already of type string.'''
        pass

    def currentResultType(self): 
        '''currentResultType(self) -> MPxCommand.MResultType

'''
        pass

    def currentStringResult(self): 
        '''currentStringResult(self) -> MString
Returns: Returns:
The string result.

This method gets the current node's result as a  MString ,
if possible.'''
        pass

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

This method is used to specify whether or not the command is
undoable. In the base class, it always returns false. If you are
writing a command that might be eligible for undo, you should
override this method.'''
        pass

    def displayWarning(self, theWarning, wantDisplayLineNumber): 
        '''displayWarning(self, theWarning, wantDisplayLineNumber)
Arguments:
	[in]	theWarning = MString
	[in]	wantDisplayLineNumber = bool

This method is used to display a warning in the script
editor.'''
        pass

    def currentIntResult(self): 
        '''currentIntResult(self) -> int
Returns: Returns:
The int result.

This method gets the current node's result as a int, if
possible.'''
        pass

    def getCurrentResult(self, val): 
        '''getCurrentResult(self, val)
Arguments:
	[out]	val = MStringArray

This method gets the current node's result as an array of
strings, if possible.'''
        pass

    def displayError(self, theError, wantDisplayLineNumber): 
        '''displayError(self, theError, wantDisplayLineNumber)
Arguments:
	[in]	theError = MString
	[in]	wantDisplayLineNumber = bool

This method is used to display an error in the script
editor.'''
        pass

    def setHistoryOn(self, state): 
        '''setHistoryOn(self, state)
Arguments:
	[in]	state = bool

This method specifies if history for this command is on.'''
        pass

    def setResult(self, val): 
        '''setResult(self, val)
Arguments:
	[in]	val = MStringArray

This method puts the given values into the return value area for
a command.'''
        pass

    def clearResult(self): 
        '''clearResult(self)
'''
        pass

class MPxComponentShape:
    '''Component helper class for surface shapes.'''
    def __init__(self):
        pass


    def setControlPoints(self, cps): 
        '''setControlPoints(self, cps)
Arguments:
	[in]	cps = MVectorArray

Push the given control points into the node's data block'''
        pass

    def createFullVertexGroup(self): 
        '''createFullVertexGroup(self) -> MObject

This method is used to create a component containing every
vertex/CV in the object.'''
        pass

    def componentToPlugs(self, component, list): 
        '''componentToPlugs(self, component, list)
Arguments:
	[in]	component = MObject
	[in]	list = MSelectionList

Converts the given component into a selection list of plugs.
This method is used to associate a shapes components into the
corresponding attributes (plugs) within the shape.'''
        pass

    def transformUsing(self, mat, componentList, cachingMode, pointCache): 
        '''transformUsing(self, mat, componentList, cachingMode, pointCache)
Arguments:
	[in]	mat = MMatrix
	[in]	componentList = MObjectArray
	[in]	cachingMode = MPxSurfaceShape.MVertexCachingMode
	[in]	pointCache = MPointArray

Transform the given components using the specified
transformation matrix. This method should be overridden if the
shape supports components that can be transformed using maya's
move, scale, and rotate tools.'''
        pass

    def match(self, mask, componentList): 
        '''match(self, mask, componentList) -> bool
Returns: Returns:


true the match was successfull
false the match failed

Arguments:
	[in]	mask = MSelectionMask
	[in]	componentList = MObjectArray

This method is used to check for matches between a selection
type (or mask) and a given component. This method is used to match
up your components with selection masks.'''
        pass

    def localShapeInAttr(self): 
        '''localShapeInAttr(self) -> MObject

Returns the input attribute of the shape, which are the control
points.'''
        pass

    def getControlPoints(self): 
        '''getControlPoints(self) -> MVectorArray

Extract the control points from the data block and store them
locally.'''
        pass

class MPxConstraint:
    '''Proxy constraint node.'''
    def __init__(self):
        pass


    def kObjectRotation(self):
        '''This is an enum of UpVectorType.
Description: Object rotation up vector.
Value: 2'''
        pass

    def kLast(self):
        '''This is an enum of UpVectorType.
Description: Last value, used for counting.
Value: 4'''
        pass

    def kScene(self):
        '''This is an enum of UpVectorType.
Description: Scene up vector.
Value: 0'''
        pass

    def kObject(self):
        '''This is an enum of UpVectorType.
Description: Object up vector.
Value: 1'''
        pass

    def kVector(self):
        '''This is an enum of UpVectorType.
Description: Specified vector.
Value: 3'''
        pass

    class UpVectorType:
        '''Non-functional class.  Values for this enum:
        kObjectRotation
        kLast
        kScene
        kObject
        kVector
'''
        def __init__(self):
            pass

    def closestNormal(self, dataGeometryObject, toThisPoint, theNormal): 
        '''closestNormal(self, dataGeometryObject, toThisPoint, theNormal)
Arguments:
	[in]	dataGeometryObject = MObject
	[in]	toThisPoint = MPoint
	[out]	theNormal = MVector

Returns the closest normal on this surface to the given
point.'''
        pass

    def passiveOutputAttribute(self): 
        '''passiveOutputAttribute(self) -> const MObject

'''
        pass

    def worldConstraintPoint(self, parentInverseMatrix, translate, rotatePivot, rotatePivotTranslate): 
        '''worldConstraintPoint(self, parentInverseMatrix, translate, rotatePivot, rotatePivotTranslate) -> MPoint

Arguments:
	[in]	parentInverseMatrix = MMatrix
	[in]	translate = MVector
	[in]	rotatePivot = MVector
	[in]	rotatePivotTranslate = MVector

Returns the world constraint point.'''
        pass

    def closestTangent(self, dataGeometryObject, toThisPoint, theTangent): 
        '''closestTangent(self, dataGeometryObject, toThisPoint, theTangent)
Arguments:
	[in]	dataGeometryObject = MObject
	[in]	toThisPoint = MPoint
	[out]	theTangent = MVector

Returns the closest tangent on this surface to the given
point.'''
        pass

    def weightAttribute(self): 
        '''weightAttribute(self) -> const MObject

Returns the weight attribute for the constraint. Default
implementation returns  MObject::kNullObj . 
  Reprocessed example '''
        pass

    def enableRestPosition(self): 
        '''enableRestPosition(self) -> MPxConstraint.MObject 

'''
        pass

    def computeAim(self, parentInverseMatrix, targetVector, aimVector, upVector, wUpVector, order, jointOrient): 
        '''computeAim(self, parentInverseMatrix, targetVector, aimVector, upVector, wUpVector, order, jointOrient) -> MEulerRotation

Arguments:
	[in]	parentInverseMatrix = MMatrix
	[in]	targetVector = MVector
	[in]	aimVector = MVector
	[in]	upVector = MVector
	[in]	wUpVector = MVector
	[in]	order = MEulerRotation.RotationOrder
	[in]	jointOrient = MQuaternion

Returns the rotation which aligns the aimVector in local space
with the targetVector in local space while keeping the upVector in
local space and the wUpVector world space aligned as closely as
possible.'''
        pass

    def closestPoint(self, dataGeometryObject, toThisPoint, theClosestPoint): 
        '''closestPoint(self, dataGeometryObject, toThisPoint, theClosestPoint)
Arguments:
	[in]	dataGeometryObject = MObject
	[in]	toThisPoint = MPoint
	[out]	theClosestPoint = MPoint

Returns the closest point on this surface to the given
point.'''
        pass

    def getOutputAttributes(self, attributeArray): 
        '''getOutputAttributes(self, attributeArray)
Arguments:
	[out]	attributeArray = MObjectArray

Returns output attributes for the constraint. Default
implementation clears the input attributeArray and returns. 
  Reprocessed example '''
        pass

    def constraintRotateOrderAttribute(self): 
        '''constraintRotateOrderAttribute(self) -> const MObject

'''
        pass

    def targetAttribute(self): 
        '''targetAttribute(self) -> const MObject

Returns the target attribute for the constraint. Default
implementation returns  MObject::kNullObj . 
  Reprocessed example '''
        pass

    def worldUpVector(self, upType, upVector, upMatrix, constrPoint): 
        '''worldUpVector(self, upType, upVector, upMatrix, constrPoint) -> MVector

Arguments:
	[in]	upType = MPxConstraint.UpVectorType
	[in]	upVector = MVector
	[in]	upMatrix = MMatrix
	[in]	constrPoint = MPoint

Returns the world up vector based on the requested up type.'''
        pass

class MPxConstraintCommand:
    '''Proxy constraint command.'''
    def __init__(self):
        pass


    def kLast(self):
        '''This is an enum of TargetType.
Description: Last value, used for counting.
Value: 2'''
        pass

    def kGeometryShape(self):
        '''This is an enum of TargetType.
Description: Geometry shape(or children of) targets.
Value: 1'''
        pass

    def kTransform(self):
        '''This is an enum of TargetType.
Description: Transform target.
Value: 0'''
        pass

    class TargetType:
        '''Non-functional class.  Values for this enum:
        kLast
        kGeometryShape
        kTransform
'''
        def __init__(self):
            pass

    def connectObjectAttribute(self, objectAttr, constraintAttr, toConstraint, instanced): 
        '''connectObjectAttribute(self, objectAttr, constraintAttr, toConstraint, instanced)
Arguments:
	[in]	objectAttr = MObject
	[in]	constraintAttr = MObject
	[in]	toConstraint = bool
	[in]	instanced = bool

This method is used  
connectObjectAndConstraint()  to make any required connections
between the constraint and the constrained object.'''
        pass

    def parseArgs(self, argList): 
        '''parseArgs(self, argList)
Arguments:
	[in]	argList = MArgList

This method is used for parsing any custom flags/params that
have been added to the command. Return  MS::kUnknownParameter 
to allow the processing of base flags/params.'''
        pass

    def doEdit(self): 
        '''doEdit(self)
This method is used for editing any custom setting on the
command. Return  MS::kUnknownParameter 
to allow processing of the base class functionality.'''
        pass

    def syntax(self): 
        '''syntax(self) -> MSyntax
Returns: Returns:


the syntax object

USE _syntax() IN SCRIPT.'''
        pass

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

'''
        pass

    def worldUpTypeAttribute(self): 
        '''worldUpTypeAttribute(self) -> const MObject

'''
        pass

    def worldUpVectorAttribute(self): 
        '''worldUpVectorAttribute(self) -> const MObject

'''
        pass

    def aimVectorAttribute(self): 
        '''aimVectorAttribute(self) -> const MObject

'''
        pass

    def worldUpMatrixAttribute(self): 
        '''worldUpMatrixAttribute(self) -> const MObject

'''
        pass

    def constraintTargetInstancedAttribute(self): 
        '''constraintTargetInstancedAttribute(self) -> const MObject

This method returns the constraintTargetInstanced attribute for
the constraint.'''
        pass

    def handleNewTargets(self, dagObject): 
        '''handleNewTargets(self, dagObject)
Arguments:
	[in]	dagObject = MDagPath

This method is used to perform any special processing when
targets are added to the constraint. For example, the constraint
may need to keep track of the list of targets to properly calculate
an offset.'''
        pass

    def constraintTargetAttribute(self): 
        '''constraintTargetAttribute(self) -> const MObject

This method returns the constraintTarget attribute for the
constraint.'''
        pass

    def connectTarget(self, targetPath, index): 
        '''connectTarget(self, targetPath, index)
Arguments:
	[in]	targetPath = MDagPath
	[in]	index = int

This method is called to make connections between the constraint
and the target. Since the default behaviour is to do nothing it is
generally necessary to override this method if your constraint is
to work properly. The  connectTargetAttribute() 
convenience method can be useful in this regard.'''
        pass

    def doIt(self, args): 
        '''doIt(self, args)
Arguments:
	[in]	args = MArgList

This method should execute a command by setting up internal
class data and then return control to Maya for executing the base
constraint command functionality. This is a virtual, and can be
overridden in derived classes.'''
        pass

    def redoIt(self): 
        '''redoIt(self)
This method should do the actual work of the command based on
the internal class data only. Internal class data should be set in
the  doIt  method.'''
        pass

    def constraintTargetWeightAttribute(self): 
        '''constraintTargetWeightAttribute(self) -> const MObject

This method returns the constraintTargetWeight attribute for the
constraint.'''
        pass

    def transformObject(self): 
        '''transformObject(self) -> const MObject

'''
        pass

    def doCreate(self): 
        '''doCreate(self)
This method is used for creating resources required by the
command. Return MS:kUnknownParameter to allow processing of base
class functionality.'''
        pass

    def constraintInstancedAttribute(self): 
        '''constraintInstancedAttribute(self) -> const MObject

This method returns the attribute on the constraint node that
connects to an instanced constraint attribute of the constrained
object.'''
        pass

    def appendSyntax(self): 
        '''appendSyntax(self)
This method should be overridden to append syntax to the
constraint command. The syntax object can be obtained by calling
the syntax method. The following flags cannot be used as
user-defined flags as they are reserved for edit and query: "-e",
"-edit", "-q", "-query".'''
        pass

    def objectAttribute(self): 
        '''objectAttribute(self) -> const MObject

This method returns the attribute this constraint will drive on
the constrained object.'''
        pass

    def upVectorAttribute(self): 
        '''upVectorAttribute(self) -> const MObject

'''
        pass

    def constraintRestAttribute(self): 
        '''constraintRestAttribute(self) -> const MObject

'''
        pass

    def connectObjectAndConstraint(self, modifier): 
        '''connectObjectAndConstraint(self, modifier)
Arguments:
	[in]	modifier = MDGModifier

This method is used for connecting the constraint and
constrained object. The utility method  
MPxConstraintCommand::connectObjectAttribute()  is used to
connect the attributes.'''
        pass

    def connectTargetAttribute(self, targetPath, index, targetAttribute, constraintAttr, instanced): 
        '''connectTargetAttribute(self, targetPath, index, targetAttribute, constraintAttr, instanced)
Arguments:
	[in]	targetPath = MDagPath
	[in]	index = int
	[in]	targetAttribute = MObject
	[in]	constraintAttr = MObject
	[in]	instanced = bool

Utility method to make any required connections for the
constraint.'''
        pass

    def constraintOutputAttribute(self): 
        '''constraintOutputAttribute(self) -> const MObject

This method returns the attribute this constraint will connect
to the constrained attribute of the constrained object.'''
        pass

    def targetType(self): 
        '''targetType(self) -> MPxConstraintCommand.TargetType

Maya supports constraints targets which are either transforms or
nodes derived from "geometryShape". Return the appropriate target
type in this method.'''
        pass

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

'''
        pass

    def offsetAttribute(self): 
        '''offsetAttribute(self) -> const MObject

'''
        pass

    def getObjectAttributesArray(self, array): 
        '''getObjectAttributesArray(self, array)
Arguments:
	[out]	array = MObjectArray

'''
        pass

    def doQuery(self): 
        '''doQuery(self)
This method is used for querying information defined in the
command. Return MS:kUnknownParameter to allow processing of base
class functionality.'''
        pass

    def constraintEnableRestAttribute(self): 
        '''constraintEnableRestAttribute(self) -> const MObject

'''
        pass

    def constraintTypeId(self): 
        '''constraintTypeId(self) -> MTypeId

This method is used to return the  MTypeId  of the  MPxConstraint  node that is used with
this command. This virtual must be implemented in a proxy
constraint command.'''
        pass

    def undoIt(self): 
        '''undoIt(self)
This method should undo the work done be the  redoIt 
method based on the internal class data only.'''
        pass

    def createdConstraint(self, constraint): 
        '''createdConstraint(self, constraint)
Arguments:
	[in]	constraint = MPxConstraint

This method is called when an  MPxConstraintCommand  creates a new
 MPxConstraint  node. It can be used for
transferring state from the command to the node object.'''
        pass

    def connectGeometryAttribute(self, opaqueTarget, index, constraintAttribute): 
        '''connectGeometryAttribute(self, opaqueTarget, index, constraintAttribute)
Arguments:
	[in]	opaqueTarget = void
	[in]	index = int
	[in]	constraintAttribute = MObject

Utility method to make any required connections for the
constraint. Note that it is called by the default implementation of
 connectTarget() .'''
        pass

class MPxContext:
    '''Base class for user defined contexts.A context is  by pressing the toolButton for that
context. Once the context is activated, it will handle the events
that occur within 3d panel.'''
    def __init__(self):
        pass


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

This method is called to update the numerical feedback. The
format and values for the feedback line can be set through the
methods in  MFeedbackLine , specifically setFormat and
setValue. The return value should indicate whether or not the
numerical feedback has been provided.'''
        pass

    def image(self, index): 
        '''image(self, index) -> MString
Returns: Returns:
String name

Arguments:
	[in]	index = MPxContext.ImageIndex

This method is used to retrieve an XPM icon image that has
previously been set for this tool context. This icon image will be
used to represent this tool context in various places including the
tool bar and can be queried from mel using the contextInfo
command.'''
        pass

    def dragMarquee(self, event): 
        '''dragMarquee(self, event)
Arguments:
	[in]	event = MEvent

USE _dragMarquee() IN SCRIPT.'''
        pass

    def doHold(self, event): 
        '''doHold(self, event)
Arguments:
	[in]	event = MEvent

This method is called when a mouse button is pressed but before
the mouse is dragged. The base method does nothing and should be
overriden if the user needs to do anything on a button hold.'''
        pass

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

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

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

    class ImageIndex:
        '''Non-functional class.  Values for this enum:
        kImage1
        kImage3
        kImage2
'''
        def __init__(self):
            pass

    def argTypeNumericalInput(self, index): 
        '''argTypeNumericalInput(self, index) -> MSyntax.MArgType
Returns: Returns:
MSyntax::kNoArg the default return
value

Arguments:
	[in]	index = int

This method is used by the feedback line to determine what units
to display. Users should override this method to return the
appropriate argument type for the given index of the numeric input
field. Specifically, this method should be overridden to return one
of the following:'''
        pass

    def processNumericalInput(self, values, flags, isAbsolute): 
        '''processNumericalInput(self, values, flags, isAbsolute) -> bool
Returns: Returns:
false the default return value

Arguments:
	[in]	values = MDoubleArray
	[in]	flags = MIntArray
	[in]	isAbsolute = bool

This method processes the input from the numerical input field.
Users can override this method if they wish to process numerical
input. For a given entry in the numeric input field, if the user
types a dot ".", this indicates that the entry should not be
modified. The overridden version of this method should take this
into account using the ignoreEntry method with the flags that are
passed in. The overridden version of this method should also
process the numeric input as an absolute input or relative input
depending on whether the isAbsolute flag is true or not. The return
value should indicate whether or not the numerical input has been
processed.'''
        pass

    def newToolCommand(self): 
        '''newToolCommand(self) -> MPxToolCommand

CALL _newToolCommand() IN SCRIPT.'''
        pass

    def stringClassName(self): 
        '''stringClassName(self) -> MString

This method is called to determine the name that uniquely
identifies the context. Either this method, or the getClassName
method, should be overridden such that the name is set to the
appropriate string. For example:'''
        pass

    def deleteAction(self): 
        '''deleteAction(self)
'''
        pass

    def setTitleString(self, str): 
        '''setTitleString(self, str)
Arguments:
	[in]	str = MString

USE _setTitleString() IN SCRIPT.'''
        pass

    def doEnterRegion(self, event): 
        '''doEnterRegion(self, event)
Arguments:
	[in]	event = MEvent

This method is called when the mouse pointer enters a screen
panel region. The base method sets the help string and the cursor
which may have been set via  setHelpString  and
 setCursor  respectively.'''
        pass

    def setCursor(self, newCursor): 
        '''setCursor(self, newCursor)
Arguments:
	[in]	newCursor = MCursor

USE _setCursor() IN SCRIPT.'''
        pass

    def doPress(self, event): 
        '''doPress(self, event)
Arguments:
	[in]	event = MEvent

This method is called when any mouse button is pressed. The base
method does nothing and should be overriden if the user needs to do
anything on a button press.'''
        pass

    def toolOnSetup(self, event): 
        '''toolOnSetup(self, event)
Arguments:
	[in]	event = MEvent

This method is called when the context is activated, i.e when
the toolButton for the context is pressed. Users can override this
method and use it to set up any user defined data that needs to be
initialized on each activation.'''
        pass

    def setHelpString(self, str): 
        '''setHelpString(self, str)
Arguments:
	[in]	str = MString

USE _setHelpString() IN SCRIPT.'''
        pass

    def addManipulator(self, manipulator): 
        '''addManipulator(self, manipulator)
Arguments:
	[in]	manipulator = MObject

This method adds a manipulator to the context.'''
        pass

    def beginMarquee(self, event): 
        '''beginMarquee(self, event)
Arguments:
	[in]	event = MEvent

USE _beginMarquee() IN SCRIPT.'''
        pass

    def abortAction(self): 
        '''abortAction(self)
'''
        pass

    def toolOffCleanup(self): 
        '''toolOffCleanup(self)
This method is called when the context is deactivated, i.e when
another context is activated. Users can override this method and
use it to reset any user defined data to a specific state.'''
        pass

    def ignoreEntry(self, flags, entry): 
        '''ignoreEntry(self, flags, entry) -> bool
Returns: Returns:


true the given entry should be ignored
false the given entry should not be ignored

Arguments:
	[in]	flags = MIntArray
	[in]	entry = int

USE _ignoreEntry() IN SCRIPT.'''
        pass

    def setImage(self, image, index): 
        '''setImage(self, image, index)
Arguments:
	[in]	image = MString
	[in]	index = MPxContext.ImageIndex

This method is used to set an XPM icon image that is to be used
to represent this tool context in various places including the tool
bar and can be queried from mel using the contextInfo command.'''
        pass

    def releaseMarquee(self, event, top, left, bottom, right): 
        '''releaseMarquee(self, event, top, left, bottom, right)
Arguments:
	[in]	event = MEvent
	[out]	top = short
	[out]	left = short
	[out]	bottom = short
	[out]	right = short

USE _releaseMarquee() IN SCRIPT.'''
        pass

    def completeAction(self): 
        '''completeAction(self)
This method is called when the complete key is pressed. The
default complete key in Maya is the  enter  key. Users can
override this method if a tool has several steps. For example, a
tool may have several steps where the user must select objects and
then press the completion key before proceeding. 
  Reprocessed example '''
        pass

    def deleteManipulators(self): 
        '''deleteManipulators(self)
This method deletes all the manipulators that belong to the
context.'''
        pass

    def doRelease(self, event): 
        '''doRelease(self, event)
Arguments:
	[in]	event = MEvent

This method is called when any mouse button is released. The
base method does nothing and should be overriden if the user needs
to do anything on a button release.'''
        pass

    def doDrag(self, event): 
        '''doDrag(self, event)
Arguments:
	[in]	event = MEvent

This method is called when a mouse drag event occurs. The base
method does nothing and should be overriden if the user needs to do
anything during a mouse drag.'''
        pass

    def helpStateHasChanged(self, event): 
        '''helpStateHasChanged(self, event)
Arguments:
	[in]	event = MEvent

This method is called whenever the help state may need to be
updated. The base method does nothing and should be overriden if
the user needs to change the help information based on events.'''
        pass

class MPxContextCommand:
    '''Base class for context creation commands.'''
    def __init__(self):
        pass


    def doEditFlags(self): 
        '''doEditFlags(self)
This method is called when the command is called in edit mode.
This method should be overridden by context commands to determine
which edit flags are set in conjunction with the argument parser
for this command. The argument parser for this command can be
obtained by calling the parser method. If the command is called
with both the edit flag and the query flag, then the query flag
will be ignored.'''
        pass

    def makeObj(self): 
        '''makeObj(self) -> MPxContext

This function is used to instantiate a proxy context. In your
derived class, declare this function:'''
        pass

    def parser(self): 
        '''parser(self) -> MArgParser
Returns: Returns:
The argument parser

USE _parser() IN SCRIPT.'''
        pass

    def doQueryFlags(self): 
        '''doQueryFlags(self)
This method is called when the command is called in query mode.
This method should be overridden by context commands to determine
which query flags are set in conjunction with the argument parser
for this command. The argument parser for this command can be
obtained by calling the parser method. If the command is called
with both the edit flag and the query flag, then the query flag
will be ignored.'''
        pass

    def syntax(self): 
        '''syntax(self) -> MSyntax
Returns: Returns:
The syntax object

USE _syntax() IN SCRIPT.'''
        pass

    def setResult(self, result): 
        '''setResult(self, result)
Arguments:
	[out]	result = MString

This method should be called when the result of the context
command a string.'''
        pass

    def appendSyntax(self): 
        '''appendSyntax(self)
This method should be overridden to append syntax to the context
command. The syntax object can be obtained by calling the syntax
method. The following flags cannot be used as user-defined flags as
they are reserved for edit and query: "-e", "-edit", "-q",
"-query".'''
        pass

class MPxControlCommand:
    '''Base class for control creation commands.'''
    def __init__(self):
        pass


    def control(self): 
        '''control(self) -> MPxUIControl

USE _control() IN SCRIPT.'''
        pass

    def doEditFlags(self): 
        '''doEditFlags(self)
This method is called when the command is called in edit mode.
This method should be overridden by control commands to determine
which edit flags are set in conjunction with the argument parser
for this command. The argument parser for this command can be
obtained by calling the parser method.'''
        pass

    def skipFlagForCreate(self, longFlag): 
        '''skipFlagForCreate(self, longFlag) -> bool
Returns: Returns:
true if the flag shoiuld be skipped during creation.

Arguments:
	[in]	longFlag = MString

Returns true if the passed long flag name should be skipped
during the creation portion of the command.'''
        pass

    def parser(self): 
        '''parser(self) -> MArgParser
Returns: Returns:
The argument parser

USE _parser() IN SCRIPT.'''
        pass

    def doQueryFlags(self): 
        '''doQueryFlags(self)
This method is invoked during query mode, and the default method
should be overridden in user-defined control commands to determine
which query flags are set in conjunction with the argument parser
for the command. The argument parser for this command can be
obtained by calling the parser method. If the command is called
with both the edit flag and the query flag, then the query flag
will be ignored.'''
        pass

    def syntax(self): 
        '''syntax(self) -> MSyntax
Returns: Returns:


the syntax object

USE _syntax() IN SCRIPT.'''
        pass

    def setResult(self, result): 
        '''setResult(self, result)
Arguments:
	[out]	result = MIntArray

This method should be called when the result of the control
command is a integer array.'''
        pass

    def appendSyntax(self): 
        '''appendSyntax(self)
This method should be overridden to append syntax to the control
command. The syntax object can be obtained by calling the syntax
method. The following flags cannot be used as user-defined flags as
they are reserved for edit and query: "-e", "-edit", "-q",
"-query".'''
        pass

    def makeControl(self): 
        '''makeControl(self) -> MPxUIControl

This method is called when the UI control should be created. You
need to create a new  MPxUIControl  on call to this
method (the base implementation is abstract, so that the compiler
will force you to define an implementation of this method).'''
        pass

    def clearResult(self): 
        '''clearResult(self)
'''
        pass

class MPxData:
    '''Base Class for User-defined Dependency Graph Data Types.'''
    def __init__(self):
        pass


    def writeASCII(self, outarg): 
        '''writeASCII(self, outarg)
Arguments:
	[in]	outarg = std.ostream

/fn  MStatus   MPxData::writeASCII(
std::ostream& out)  Encodes Data in accordance with the
ASCII file format and outputs it to the given stream.'''
        pass

    def readBinary(self, inarg, length): 
        '''readBinary(self, inarg, length)
Arguments:
	[in]	inarg = std.istream
	[in]	length = int

/fn  MStatus   MPxData::readBinary(
std::istream& in, unsigned int length )  Creates Data in
Data Block as specified by binary data from the given stream.'''
        pass

    def readASCII(self, argList, endOfTheLastParsedElement): 
        '''readASCII(self, argList, endOfTheLastParsedElement)
Arguments:
	[in]	argList = MArgList
	[in]	endOfTheLastParsedElement = int

Creates Data in Data Block as specified by input from ASCII file
record.'''
        pass

    def name(self): 
        '''name(self) -> MString

Determines the type name of the Data object. This is a pure
virtual method, and must be overridden in derived classes.'''
        pass

    def typeId(self): 
        '''typeId(self) -> MTypeId

Determines the type id of the Data object. This is a pure
virtual method, and must be overridden in derived classes.'''
        pass

    def copy(self, src): 
        '''copy(self, src)
Arguments:
	[in]	src = MPxData

This method initializes an instance of an  MPxData 
derived class from another existing instance. This method can be
thought of as the  second half  of a copy constructor for
the class. The default constructor has already been called for the
instance, and this method is used to set the private data by
copying the values from an existing instance. This is a pure
virtual method, and must be overridden in derived classes.'''
        pass

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

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

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

    class Type:
        '''Non-functional class.  Values for this enum:
        kGeometryData
        kLast
        kData
'''
        def __init__(self):
            pass

    def writeBinary(self, outarg): 
        '''writeBinary(self, outarg)
Arguments:
	[in]	outarg = std.ostream

/fn  MStatus   MPxData::writeBinary(
std::ostream& out)  Encodes Data in accordance with the
binary file format and outputs it to the given stream.'''
        pass

class MPxDeformerNode:
    '''Base class for user defined Deformers.Deformers are full dependency nodes and can have attributes and adeform()method. In general, to derive the full benefit of the Maya deformer
base class, it is suggested that you do not write your owncompute()method. Instead, write the deform()method, which is called by the MPxDeformerNode's compute()method. However, there are some exceptions when you would instead
write your own compute(),
namely:In the case where you cannot simply override the 
deform() method, the following example code shows one possiblecompute()method implementation. This compute()example creates an iterator for the deformer set corresponding to
the output geometry being computed. Note that this sample compute()implementation does not do any deformation, and does not implement
handling of the nodeState attribute. If you do choose to overridecompute()in your node, there is no reason to implement the deform()method, since it will not be called by the base class.'''
    def __init__(self):
        pass


    weightList = ''
    '''weight list attribute, multi'''

    envelope = ''
    '''envelope attribute'''

    outputGeom = ''
    '''geometry output attribute'''

    weights = ''
    '''weight attribute, multi'''

    inputGeom = ''
    '''input geometry attribute'''

    input = ''
    '''input attribute, multi'''

    groupId = ''
    '''input group id attribute'''

    def weightValue(self, block, multiIndex, wtIndex): 
        '''weightValue(self, block, multiIndex, wtIndex) -> float
Returns: Returns:
Weight

Arguments:
	[in]	block = MDataBlock
	[in]	multiIndex = int
	[in]	wtIndex = int

This method returns the weightValue stored in the datablock for
the given geometry's lattice point/CV/vertex.'''
        pass

    def setUseExistingConnectionWhenSetEditing(self, state): 
        '''setUseExistingConnectionWhenSetEditing(self, state)
Arguments:
	[in]	state = bool

This method allows the plugin node to request special treatment
during set editing. It controls the connection behavior if all of a
geometry's points are removed from the deformer set, and then
points are subsequently added back in to the set again. By default,
Maya will reconnect the deformer to the shape using a new
input/output index. If this method is called in the custom
deformer's postConstructor method and the state is set to true, the
deformer will attempt to use the original input/output index when
reconnecting to the shape.'''
        pass

    def deform(self, block, iterator, matrix, multiIndex): 
        '''deform(self, block, iterator, matrix, multiIndex)
Arguments:
	[in]	block = MDataBlock
	[in]	iterator = MItGeometry
	[in]	matrix = MMatrix
	[in]	multiIndex = int

This method performs the deformation algorithm. A status code of
 MS::kSuccess  should be
returned unless there was a problem during the deformation, such as
insufficient memory or required input data is missing or
invalid.'''
        pass

    def setModifiedCallback(self, list, listAdded): 
        '''setModifiedCallback(self, list, listAdded)
Arguments:
	[in]	list = MSelectionList
	[in]	listAdded = bool

This callback method can be overriden and is called whenever the
set this deformer is operating on is modified. It passes in a
selection list of items that are either being added/removed.'''
        pass

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

Retrieves the value set by  setDeformationDetails() .
See the documentation of that method for the interpretation of the
value.'''
        pass

    def kDeformsColors(self):
        '''This is an enum of DeformationDetails.
Description: The deformer will deform colors.
Value: 4'''
        pass

    def kDeformsUVs(self):
        '''This is an enum of DeformationDetails.
Description: The deformer will deform UVs.
Value: 2'''
        pass

    class DeformationDetails:
        '''Non-functional class.  Values for this enum:
        kDeformsColors
        kDeformsUVs
'''
        def __init__(self):
            pass

    def setDeformationDetails(self, flags): 
        '''setDeformationDetails(self, flags)
Arguments:
	[in]	flags = int

This method allows the plug-in node to inform the system that it
intends to deform components other than just positions.'''
        pass

    def accessoryAttribute(self): 
        '''accessoryAttribute(self) -> MObject

This method returns an  MObject  for the attribute to which an
accessory shape is connected. If the accessory shape is deleted,
the deformer node will automatically be deleted.'''
        pass

    def accessoryNodeSetup(self, cmd): 
        '''accessoryNodeSetup(self, cmd)
Arguments:
	[in]	cmd = MDagModifier

This method is called by the "deformer -type" command when your
node is specified.'''
        pass

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

This method returns the type of the node. This method should not
be overridden by the user. It will return  MPxNode::kDeformerNode .'''
        pass

class MPxDragAndDropBehavior:
    '''Drag and Drop Behavior.'''
    def __init__(self):
        pass


    def connectAttrToNode(self, sourcePlug, destinationNode, force): 
        '''connectAttrToNode(self, sourcePlug, destinationNode, force)
Arguments:
	[in]	sourcePlug = MPlug
	[in]	destinationNode = MObject
	[in]	force = bool

This method is called by the defaultNavigation command to
connect a source attribute to a destination node.You should
override this method if you can determine from the type of source
node and attribute and the type of destination node what the user
is trying to do and you know the appropriate connections that must
be made for the end result to be what the user expects.'''
        pass

    def connectNodeToNode(self, sourceNode, destinationNode, force): 
        '''connectNodeToNode(self, sourceNode, destinationNode, force)
Arguments:
	[in]	sourceNode = MObject
	[in]	destinationNode = MObject
	[in]	force = bool

This method is called by the defaultNavigation command to
connect a source node to a destination node.You should override
this method if you can determine from the type of source node and
the type of destination node what the user is trying to do and you
know the appropriate connections that must be made for the end
result to be what the user expects.'''
        pass

    def connectAttrToAttr(self, sourcePlug, destinationPlug, force): 
        '''connectAttrToAttr(self, sourcePlug, destinationPlug, force)
Arguments:
	[in]	sourcePlug = MPlug
	[in]	destinationPlug = MPlug
	[in]	force = bool

This method is called by the defaultNavigation command to
connect a source attribute to a destination attribute. If this
method is overidden it should attempt to determine what the user
probably wants this connection to be, and set up the connection
appropriately. If the force argument is true it is intended to
notify the user to break any existing connections to the plug,
similar to what the mel command "connectAttr" -f flag is used
for.'''
        pass

    def shouldBeUsedFor(self, sourceNode, destinationNode, sourcePlug, destinationPlug): 
        '''shouldBeUsedFor(self, sourceNode, destinationNode, sourcePlug, destinationPlug) -> bool

Arguments:
	[in]	sourceNode = MObject
	[in]	destinationNode = MObject
	[in]	sourcePlug = MPlug
	[in]	destinationPlug = MPlug

This method must be overridden in order to use a drag and drop
behavior. The overridden method will be called by the
defaultNavigation command to determine wether or not to use this
drag and drop behavior to finish a connection. If the user would
like to handle the connection between sourceNode/Plug and
destinationNode/Plug than this routine must pass back true,
otherwise the routine must pass back false in order for the default
connection mechinism to work between these two nodes. sourcePlug
and destinationPlug may be null depending on if there were any
attributes given in the drag and drop. Use the isNull() method on
 MPlug  to assure the
plugs are valid.'''
        pass

    def connectNodeToAttr(self, sourceNode, destinationPlug, force): 
        '''connectNodeToAttr(self, sourceNode, destinationPlug, force)
Arguments:
	[in]	sourceNode = MObject
	[in]	destinationPlug = MPlug
	[in]	force = bool

This method is called by the defaultNavigation command to
connect a source node to a destination attribute. You should
override this method if you can determine from the type of source
node and the type of destination node and attribute what the user
is trying to do and you know the appropriate connections that must
be made for the end result to be what the user expects.'''
        pass

class MPxEmitterNode:
    '''Base class for user defined particle emitters.'''
    def __init__(self):
        pass


    mMinDistance = ''
    '''min distance attribute'''

    mOwnerVelData = ''
    '''owner velocity attribute, multi'''

    mOwnerCentroid = ''
    '''owner centroid attribute'''

    mOutput = ''
    '''output particle attribute, multi'''

    mDirection = ''
    '''direction attribute'''

    mIsFull = ''
    '''flag for maximum count attribute'''

    mRate = ''
    '''rate attribute'''

    mSeed = ''
    '''random seed attribute'''

    mMaxDistance = ''
    '''max distance attribute'''

    mOwnerPosData = ''
    '''owner postion attribute, multi'''

    mCurrentTime = ''
    '''current time attribute'''

    mSweptGeometry = ''
    '''input swept geometry attribute'''

    mOwnerCentroidY = ''
    '''Y component of mOwnerCentroid.'''

    mOwnerCentroidX = ''
    '''X component of mOwnerCentroid.'''

    mDirectionY = ''
    '''Y component of mDirection.'''

    mDirectionX = ''
    '''X component of mDirection.'''

    mRandState = ''
    '''random state attribute'''

    mEmitterType = ''
    '''emitter type attribute'''

    mInheritFactor = ''
    '''inherit factor attribute'''

    mDeltaTime = ''
    '''delta time attribute'''

    mSpeed = ''
    '''speed attribute'''

    mDirectionZ = ''
    '''Z component of mDirection.'''

    mWorldMatrix = ''
    '''world matrix attribute'''

    mOwnerCentroidZ = ''
    '''Z component of mOwnerCentroid.'''

    mStartTime = ''
    '''start time attribute'''

    def hasValidEmission2dTexture(self, texAttr): 
        '''hasValidEmission2dTexture(self, texAttr) -> bool
Returns: Returns:
true if the node connected to the specified emitter attribute
is a texture that can be evaluated using the evalEmission2dTexture()
method, false otherwise.

Arguments:
	[in]	texAttr = MObject

Certain aspects of Maya's particle and fluid emitters can be
textured using 2d textures. For example, surface particle emitters
can use a 2d texture to modulate the emission rate over the
surface. For these purposes, only a subset of Maya's textures are
supported, namely the default 2d textures (bulge, checker, cloth,
file, fluid texture 2d, fractal, grid, mountain, movie, noise,
ocean, ramp, water). No other nodes are supported. This method
takes an attribute on an emitter, and determines if there is a
supported texture connected to it. If the texture is supported,
then the  evalEmission2dTexture() 
method can be called to evaluate the texture at various (u,v)
coordinate values.'''
        pass

    def getOwnerShape(self): 
        '''getOwnerShape(self) -> MObject

If the emitter is a emitting from an object, this method returns
the shape node for the object.'''
        pass

    def getRandomState(self, plugIndex, block): 
        '''getRandomState(self, plugIndex, block)
Arguments:
	[in]	plugIndex = int
	[out]	block = MDataBlock

Intended to be called from within the emitter's  compute() 
method, this method copies the emitter node attribute representing
the current random state for a particular emitter target into a
local variable on the emitter object, to facilitate efficient
random number generation using the  randgen() 
method. See the documentation for  resetRandomState() 
for a description of how to use this method in conjunction with the
other random stream methods of this class.'''
        pass

    def getDeltaTime(self, plugIndex, block): 
        '''getDeltaTime(self, plugIndex, block) -> MTime
Returns: Returns:
The time delta for the current emitter evaluation on the
specified target.

Arguments:
	[in]	plugIndex = int
	[out]	block = MDataBlock

Intended to be called from within the emitter's  compute() 
method, this method returns the width of the time interval
represented by the current emitter evaluation. Usually emitter
emission rates are given as rates per second, so by converting this
deltaTime value to seconds, plugin emitters can determine how many
particles or how much fluid to emit in the current evaluation. This
value is taken from the emitter's "deltaTime" attribute value, and
can vary between different emitter targets (particle systems or
fluid shapes into which the emitter is emitting), due to potential
differences in oversampling settings. The "plugIndex" parameter
indicates which target's time delta is being evaluated.'''
        pass

    def getStartTime(self, plugIndex, block): 
        '''getStartTime(self, plugIndex, block) -> MTime
Returns: Returns:
The start time for the specified target, ie the time at which
the emitter is to start emitting into that target.

Arguments:
	[in]	plugIndex = int
	[out]	block = MDataBlock

Intended to be called from within the emitter's  compute() 
method, this method returns the start times for each particle
system or fluid into which the emitter is emitting. Each of these
"targets" is identified by an index value corresponding to the
order in which they are connected to the emitter. The start time
value gives the time at which the given target is to start
receiving particles or fluid. If the current time is less than the
start time for a target, then nothing should be emitted into that
target in the current evaluation. This value is taken by evaluating
an element of the emitter node's "startTime" array attribute.'''
        pass

    def volumePrimitiveBoundingBox(self, box): 
        '''volumePrimitiveBoundingBox(self, box) -> bool
Returns: Returns:
true if the emitter has an associated volume primitive, false
otherwise.

Arguments:
	[out]	box = MBoundingBox

For volume emitters, this method returns the object-space
bounding box of the volume primitive associated with the
emitter.'''
        pass

    def volumePrimitivePointInside(self, worldPoint, emitterWorldMatrix): 
        '''volumePrimitivePointInside(self, worldPoint, emitterWorldMatrix) -> bool
Returns: Returns:
true if the point lies inside the emitter's volume primitive,
false otherwise.

Arguments:
	[in]	worldPoint = MPoint
	[in]	emitterWorldMatrix = MMatrix

For volume emitters, this method determines whether a particular
point in space lies within the volume defined by the emitter's
volume primitive.'''
        pass

    def resetRandomState(self, plugIndex, block): 
        '''resetRandomState(self, plugIndex, block)
Arguments:
	[in]	plugIndex = int
	[out]	block = MDataBlock

Intended to be called from within the emitter's  compute() 
method, this method resets the emitter's random state data member.
To implement repeatable randomized emitter behavior, the following
steps should be followed:'''
        pass

    def getRate(self, block): 
        '''getRate(self, block) -> double
Returns: Returns:
The emission rate for the emitter.

Arguments:
	[out]	block = MDataBlock

Intended to be called from within the emitter's  compute() 
method, this method retrieves the "rate" attribute value common to
all particle and fluid emitters. For particle emitters, this
indicates the number of particles to be emitted per second. For
fluid emitters, this value is usually used as a multiplier applied
to the emission rates for various fluid grids such as density,
temperature, etc.'''
        pass

    def getCurrentTime(self, block): 
        '''getCurrentTime(self, block) -> MTime
Returns: Returns:
The time at which the emitter is being evaluated.

Arguments:
	[out]	block = MDataBlock

Intended to be called from within the emitter's  compute() 
method, this method returns the time at which the emitter is
currently being evaluated. This is equivalent to querying the
"currentTime" attribute on the emitter.'''
        pass

    def setRandomState(self, plugIndex, block): 
        '''setRandomState(self, plugIndex, block)
Arguments:
	[in]	plugIndex = int
	[out]	block = MDataBlock

Intended to be called from within the emitter's  compute() 
method, this method copies the emitter node class random state data
member onto the emitter node's random state attribute. See the
documentation for  resetRandomState() 
for a description of how to use this method in conjunction with the
other random stream methods of this class.'''
        pass

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

    def kVolume(self):
        '''This is an enum of MEmitterType.
Description: 
Value: 4'''
        pass

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

    def kCurve(self):
        '''This is an enum of MEmitterType.
Description: 
Value: 3'''
        pass

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

    class MEmitterType:
        '''Non-functional class.  Values for this enum:
        kSurface
        kVolume
        kDirectional
        kCurve
        kOmni
'''
        def __init__(self):
            pass

    def volumePrimitiveDistanceFromAxis(self, worldPoint, emitterWorldMatrix): 
        '''volumePrimitiveDistanceFromAxis(self, worldPoint, emitterWorldMatrix) -> double
Returns: Returns:
The distance from the point to the major axis of the emitter's
volume primitive.

Arguments:
	[in]	worldPoint = MPoint
	[in]	emitterWorldMatrix = MMatrix

For volume emitters, this method determines the distance from a
particular point to the major axis of the volumetric primitive
associated with the emitter. For fluid emitters, this distance can
be used to implement simple emission dropoff behavior.'''
        pass

    def draw(self, view, path, style): 
        '''draw(self, view, path, style)
Arguments:
	[in]	view = M3dView
	[in]	path = MDagPath
	[in]	style = M3dView.DisplayStyle

Overriding this method allows the drawing of custom geometry
using standard OpenGL calls. The OpenGL state should be left in the
same state that it was in previously. The OpenGL routine
glPushAttrib may be used to make this easier.'''
        pass

    def getWorldMatrix(self): 
        '''getWorldMatrix(self) -> MMatrix

Returns the matrix that maps from the emitter's local space
coordinates to worldspace.'''
        pass

    def getRandomSeed(self, plugIndex, block): 
        '''getRandomSeed(self, plugIndex, block) -> int
Returns: Returns:
The random seed value for the specified target.

Arguments:
	[in]	plugIndex = int
	[out]	block = MDataBlock

Intended to be called from within the emitter's  compute() 
method, this method returns the random seed for a specified
emission target (particle system or fluid shape into which the
emitter is emitting). This seed value is set on the target itself,
and should be used to ensure that any randomized emission behavior
is repeatable when animations are played back repeatedly. The
 resetRandomState() 
method uses this value (see its documentation for details on how to
implement repeatable randomized behaviour in emitters). This value
is obtained by evaluating an element of the emitter's "seed" array
attribute.'''
        pass

    def getWorldPosition(self): 
        '''getWorldPosition(self) -> MPoint

Returns the worldspace coordinates of the emitter. For curve,
surface, and volume emitters, this returns the worldspace
coordinates of the center of the emitter's local space. For point
emitters, this value usually corresponds to the position of the
emitter object itself.'''
        pass

    def getEmitterType(self, block): 
        '''getEmitterType(self, block) -> MPxEmitterNode.MEmitterType
Returns: Returns:
An MEmitterType value representing the type of emitter
(directional, omni, surface, curve, or volume)

Arguments:
	[out]	block = MDataBlock

Retrieves the type of the emitter, determined by the
"emitterType" attribute value. This is intended to be called from
within the emitter's  compute() 
method, in order to decide how the emitter should behave when
evaluated.'''
        pass

    def getMinDistance(self, block): 
        '''getMinDistance(self, block) -> double
Returns: Returns:
The minimum emission distance for the emitter.

Arguments:
	[out]	block = MDataBlock

Intended to be called from within the emitter's  compute() 
method, this method retrieves the "minDistance" attribute value
common to all particle and fluid emitters. This value indicates the
minimum distance from the emitter center at which fluid or
particles will be emitted.'''
        pass

    def evalEmission2dTexture(self, texAttr, uCoords, vCoords, resultColors, resultAlphas): 
        '''evalEmission2dTexture(self, texAttr, uCoords, vCoords, resultColors, resultAlphas)
Arguments:
	[in]	texAttr = MObject
	[in]	uCoords = MDoubleArray
	[in]	vCoords = MDoubleArray
	[out]	resultColors = MVectorArray
	[out]	resultAlphas = MDoubleArray

If a supported 2d texture (see  hasValidEmission2dTexture() 
method documentation) is connected to the given emitter attribute,
this method can be called to evaluate that texture at a number of
(u,v) texture coordinate values.'''
        pass

    def compute(self, plug, dataBlock): 
        '''compute(self, plug, dataBlock)
Arguments:
	[in]	plug = MPlug
	[out]	dataBlock = MDataBlock

This method should be overridden in user defined nodes.'''
        pass

    def getMaxDistance(self, block): 
        '''getMaxDistance(self, block) -> double
Returns: Returns:
The maximum emission distance for the emitter.

Arguments:
	[out]	block = MDataBlock

Intended to be called from within the emitter's  compute() 
method, this method retrieves the "maxDistance" attribute value
common to all particle and fluid emitters. This value indicates the
maximum distance from the emitter center at which fluid or
particles will be emitted.'''
        pass

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

This method returns the type of the node. It should not be
overridden by the user. It will return  MPxNode::kEmitterNode .'''
        pass

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

Intended to be called from within the emitter's  compute() 
method, this method generates a double-precision random number in
the rand [0,1]. The emitter object's random state data member is
used to generate the random number, and will be updated after the
number is generated. To generate a stream of random numbers for a
particular target, ensure that  getRandomState() 
is called before calling  randgen() ,
and that  setRandomState() 
is called after all the random numbers have been generated. See the
documentation for  resetRandomState() 
for a description of how to use this method in conjunction with the
other random stream methods of this class.'''
        pass

class MPxFieldNode:
    '''Base class for user defined fields.'''
    def __init__(self):
        pass


    mDeltaTime = ''
    '''child attribute'''

    mOwnerCentroidX = ''
    '''X component of mOwnerCentroid.'''

    mInputPPData = ''
    '''Attribute for input pp data from
particleShape.'''

    mInputVelocities = ''
    '''child attribute, multi'''

    mInputPositions = ''
    '''child attribute, multi'''

    mInputForce = ''
    '''forces input attribute, multi'''

    mWorldMatrix = ''
    '''world matrix attribute'''

    mOwnerVelData = ''
    '''owner velocity attribute, multi'''

    mMagnitude = ''
    '''magnitude attribute'''

    mOwnerCentroid = ''
    '''owner centroid attribute'''

    mApplyPerVertex = ''
    '''flag for per vertex attribute'''

    mOwnerPosData = ''
    '''owner position attribute, multi'''

    mAttenuation = ''
    '''attenuation attribute'''

    mOwnerCentroidY = ''
    '''Y component of mOwnerCentroid.'''

    mInputMass = ''
    '''child attribute, multi'''

    mOwnerCentroidZ = ''
    '''Z component of mOwnerCentroid.'''

    mMaxDistance = ''
    '''maximum distance attribute'''

    mUseMaxDistance = ''
    '''flag for maximum distance
attribute'''

    mOutputForce = ''
    '''forces output attribute, multi'''

    mOwnerPPData = ''
    '''Attribute for input pp data from owner
particleShape.'''

    mInputData = ''
    '''input attribute compound, multi'''

    def isFalloffCurveConstantOne(self): 
        '''isFalloffCurveConstantOne(self) -> bool
Returns: Returns:
true if the falloff curve is a constant one, false
otherwise

Returns true if the falloffCurve is a constant one (default) or
false if not.'''
        pass

    def draw(self, view, path, style): 
        '''draw(self, view, path, style)
Arguments:
	[in]	view = M3dView
	[in]	path = MDagPath
	[in]	style = M3dView.DisplayStyle

Overriding this method allows the drawing of custom geometry
using standard OpenGL calls. The OpenGL state should be left in the
same state that it was in previously. The OpenGL routine
glPushAttrib may be used to make this easier.'''
        pass

    def compute(self, plug, dataBlock): 
        '''compute(self, plug, dataBlock)
Arguments:
	[in]	plug = MPlug
	[out]	dataBlock = MDataBlock

This method should be overridden in user defined nodes.'''
        pass

    def iconSizeAndOrigin(self, width, height, xbo, ybo): 
        '''iconSizeAndOrigin(self, width, height, xbo, ybo)
Arguments:
	[out]	width = MPxFieldNode.GLuint
	[out]	height = MPxFieldNode.GLuint
	[out]	xbo = MPxFieldNode.GLuint
	[out]	ybo = MPxFieldNode.GLuint

Define the size and the origin of the field's icon.'''
        pass

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

This method returns the type of the node. This method should not
be overridden by the user. It will return  MPxNode::kFieldNode .'''
        pass

    def falloffCurve(self, param): 
        '''falloffCurve(self, param) -> double
Returns: Returns:
The falloff value at the given the param.

Arguments:
	[in]	param = double

Returns the falloff at the given parameter value.'''
        pass

    def getForceAtPoint(self, point, velocity, mass, deltaTime, force): 
        '''getForceAtPoint(self, point, velocity, mass, deltaTime, force)
Arguments:
	[in]	point = MVectorArray
	[in]	velocity = MVectorArray
	[in]	mass = MDoubleArray
	[out]	force = MVectorArray
	[in]	deltaTime = double

This method is not required to be overridden, it is only
necessary for compatibility with the  MFnField  function set.'''
        pass

    def iconBitmap(self, bitmap): 
        '''iconBitmap(self, bitmap)
Arguments:
	[out]	bitmap = MPxFieldNode.GLubyte

Define the bitmap for the field's icon.'''
        pass

class MPxFileTranslator:
    '''Base Class for creating Maya File Translators.'''
    def __init__(self):
        pass


    def writer(self, file, optionsString, mode): 
        '''writer(self, file, optionsString, mode)
Arguments:
	[in]	file = MFileObject
	[in]	optionsString = MString
	[in]	mode = MPxFileTranslator.FileAccessMode

This routine is called by Maya when it is necessary to save a
file of a type supported by this translator.'''
        pass

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

When a file is imported or referenced into an existing scene,
there is the possibility that nodes in the incoming file will have
the same names as nodes already in the scene. Although DAG nodes
may legally have the same name so long as their DAG paths are
different, in all other cases node names must be unique.'''
        pass

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

This routine is called by Maya while it is executing in the
 MPxFileTranslator 
constructor. Maya uses this entry point to query the translator and
determine if it can open files. The default is  true .'''
        pass

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

This routine is called by Maya while it is executing in the
 MPxFileTranslator 
constructor. Maya uses this entry point to query the translator and
determine if it provides a reader method.'''
        pass

    def filter(self): 
        '''filter(self) -> MString

This virtual method may be overloaded in a derived class to set
the filter extension that will be used by the file dialog. If the
defaultExtension method is not implemented in a derived class, the
standard filter *.* will be returned by  MPxFileTranslator 
and used by the file dialog. If defaultExtension is implemented in
a derived class, that extension will be used in the proper
format.'''
        pass

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

This routine is called by Maya while it is executing in the
 MPxFileTranslator 
constructor. Maya uses this entry point to query the translator and
determine if it provides a write method.'''
        pass

    def kCouldBeMyFileType(self):
        '''This is an enum of MFileKind.
Description: Translator is not best available to read/write this file.
Value: 1'''
        pass

    def kNotMyFileType(self):
        '''This is an enum of MFileKind.
Description: Translator does not understand how to read/write this
file.
Value: 2'''
        pass

    def kIsMyFileType(self):
        '''This is an enum of MFileKind.
Description: Translator understands how to read/write this file.
Value: 0'''
        pass

    class MFileKind:
        '''Non-functional class.  Values for this enum:
        kCouldBeMyFileType
        kNotMyFileType
        kIsMyFileType
'''
        def __init__(self):
            pass

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

This routine is called by Maya while it is executing in the
 MPxFileTranslator 
constructor. Maya uses this entry point to query the translator and
determine if it provides a reference method.'''
        pass

    def defaultExtension(self): 
        '''defaultExtension(self) -> MString

This routine is called by Maya whenever it needs to know the
default extension of a translator.'''
        pass

    def reader(self, file, optionsString, mode): 
        '''reader(self, file, optionsString, mode)
Arguments:
	[in]	file = MFileObject
	[in]	optionsString = MString
	[in]	mode = MPxFileTranslator.FileAccessMode

This routine is called by Maya when it is necessary to load a
file of a type supported by this translator.'''
        pass

    def identifyFile(self, file, buffer, size): 
        '''identifyFile(self, file, buffer, size) -> MPxFileTranslator.MFileKind
Returns: Returns:


MFileKind::kIsMyFileType this file is understood by this
translator
MFileKind::kNotMyFileType this file is not understood by
this translator
MFileKind::kCouldBeMyFileType this file is understood by
this translator, but this translator is not the best one to use for
reading or writing it

Arguments:
	[in]	file = MFileObject
	[in]	buffer = char
	[in]	size = short

This routine is called by Maya when a file selection dialog
accesses a new directory. It will potentially be called once for
every file in the directory.'''
        pass

    def fileAccessMode(self): 
        '''fileAccessMode(self) -> MPxFileTranslator.FileAccessMode

This routine returns the fileAccess mode maya is currently
in.'''
        pass

    def kExportActiveAccessMode(self):
        '''This is an enum of FileAccessMode.
Description: Export active (selected) data.
Value: 6'''
        pass

    def kUnknownAccessMode(self):
        '''This is an enum of FileAccessMode.
Description: Unknown file access mode.
Value: 0'''
        pass

    def kOpenAccessMode(self):
        '''This is an enum of FileAccessMode.
Description: Import data into new scene.
Value: 1'''
        pass

    def kExportAccessMode(self):
        '''This is an enum of FileAccessMode.
Description: Export data.
Value: 5'''
        pass

    def kSaveAccessMode(self):
        '''This is an enum of FileAccessMode.
Description: Save data.
Value: 4'''
        pass

    def kImportAccessMode(self):
        '''This is an enum of FileAccessMode.
Description: Import data into current scene.
Value: 3'''
        pass

    def kReferenceAccessMode(self):
        '''This is an enum of FileAccessMode.
Description: Reference data into current scene.
Value: 2'''
        pass

    class FileAccessMode:
        '''Non-functional class.  Values for this enum:
        kExportActiveAccessMode
        kUnknownAccessMode
        kOpenAccessMode
        kExportAccessMode
        kSaveAccessMode
        kImportAccessMode
        kReferenceAccessMode
'''
        def __init__(self):
            pass

class MPxFluidEmitterNode:
    '''Base class for user defined particle emitters.'''
    def __init__(self):
        pass


    mFluidColorB = ''
    '''emission blue color channel
attribute'''

    mFluidColorG = ''
    '''emission green color channel
attribute'''

    mFluidDensityEmission = ''
    '''density emission rate attribute'''

    mFluidJitter = ''
    '''emission jitter attribute'''

    mFluidFuelEmission = ''
    '''fuel emission rate attribute'''

    mEmissionFunction = ''
    '''emission function attribute'''

    mFluidColorR = ''
    '''emission red color channel
attribute'''

    mFluidColor = ''
    '''emission color attribute'''

    mFluidHeatEmission = ''
    '''heat emission rate attribute'''

    mEmitFluidColor = ''
    '''color emission toggle attribute'''

    mTurbulence = ''
    '''emission turbulence attribute'''

    mFluidDropoff = ''
    '''emission dropoff attribute'''

    def fluidJitter(self, block): 
        '''fluidJitter(self, block) -> bool
Returns: Returns:
true if jitter should be applied to the emission behavior,
false otherwise.

Arguments:
	[out]	block = MDataBlock

Intended to be called from within the emitter's  
compute()  method, this method retrieves the "fluidJitter"
attribute value common to all fluid emitters. This specifies how
the voxel grid should be sampled for emission. Without jitter, the
grid is sampled only at voxel centers, but with jitter enabled,
each voxel is sampled at a random location. The fluid emitter is
responsible for implementing this behavior. It is recommended that
the random stream methods on  MPxEmitterNode 
be used to implement repeatable randomized behavior in this
area.'''
        pass

    def compute(self, plug, dataBlock): 
        '''compute(self, plug, dataBlock)
Arguments:
	[in]	plug = MPlug
	[out]	dataBlock = MDataBlock

This method should be overridden in user defined nodes.'''
        pass

    def fluidDensityEmission(self, block): 
        '''fluidDensityEmission(self, block) -> double
Returns: Returns:
The fluid density emission rate for the fluid emitter.

Arguments:
	[out]	block = MDataBlock

Intended to be called from within the emitter's  
compute()  method, this method retrieves the
"fluidDensityEmission" attribute value common to all fluid
emitters. This indicates the amount of fluid material to be emitted
per second, and it is modulated by the emitter's "rate" attribute
value.'''
        pass

    def fluidEmitColor(self, block): 
        '''fluidEmitColor(self, block) -> bool
Returns: Returns:
true if the emitter should emit color into the fluid, false
otherwise.

Arguments:
	[out]	block = MDataBlock

Intended to be called from within the emitter's  
compute()  method, this method retrieves the "fluidEmitColor"
attribute value common to all fluid emitters. This indicates
whether or not the emitter should emit color into the fluid.'''
        pass

    def fluidDropoff(self, block): 
        '''fluidDropoff(self, block) -> double
Returns: Returns:
The dropoff rate for the fluid emitter.

Arguments:
	[out]	block = MDataBlock

Intended to be called from within the emitter's  
compute()  method, this method retrieves the "fluidDropoff"
attribute value common to all fluid emitters. This specifies the
the speed with which fluid emission drops off with increasing
distance from the emitter, with higher values meaning faster
dropoff.'''
        pass

    def fluidFuelEmission(self, block): 
        '''fluidFuelEmission(self, block) -> double
Returns: Returns:
The fluid fuel emission rate for the fluid emitter.

Arguments:
	[out]	block = MDataBlock

Intended to be called from within the emitter's  
compute()  method, this method retrieves the "fluidFuelEmission"
attribute value common to all fluid emitters. This indicates the
amount of fuel to be emitted per second, and it is modulated by the
emitter's "rate" attribute value.'''
        pass

    def turbulence(self, block): 
        '''turbulence(self, block) -> double
Returns: Returns:
The turbulence value for the fluid emitter.

Arguments:
	[out]	block = MDataBlock

Intended to be called from within the emitter's  
compute()  method, this method retrieves the "turbulence"
attribute value common to all fluid emitters. This specifies the
amount of turbulence that should be applied to the emitter's
output.'''
        pass

    def fluidHeatEmission(self, block): 
        '''fluidHeatEmission(self, block) -> double
Returns: Returns:
The fluid heat emission rate for the fluid emitter.

Arguments:
	[out]	block = MDataBlock

Intended to be called from within the emitter's  
compute()  method, this method retrieves the "fluidHeatEmission"
attribute value common to all fluid emitters. This indicates the
amount of heat to be emitted per second, and it is modulated by the
emitter's "rate" attribute value.'''
        pass

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

This method returns the type of the node. It should not be
overridden by the user. It will return  MPxNode::kEmitterNode .'''
        pass

    def fluidEmitter(self, fluidObj, worldMatrix, plugIndex): 
        '''fluidEmitter(self, fluidObj, worldMatrix, plugIndex)
Arguments:
	[in]	fluidObj = MObject
	[in]	worldMatrix = MMatrix
	[in]	plugIndex = int

This is the main method that plug-in fluid emitter nodes must
override in order to emit into fluids. When an emitter is attached
to a fluid, at every evaluation step the fluid will call this
method on the emitter. The method receives a fluid object into
which to emit, the index of the fluid in the array of fluid targets
for this emitter, and the worldspace matrix of the fluid. The
emitter should query its attributes to determine how much density,
heat, color, and/or fuel to emit into the fluid, then call the
 MFnFluid::emitIntoArrays() 
method to actually add the necessary quantities to the fluid.'''
        pass

    def fluidColor(self, block): 
        '''fluidColor(self, block) -> MColor
Returns: Returns:
The color that should be emitted into the fluid.

Arguments:
	[out]	block = MDataBlock

Intended to be called from within the emitter's  
compute()  method, this method retrieves the "fluidColor"
attribute value common to all fluid emitters. This specifies the
color to be added to the fluid.'''
        pass

class MPxGeometryData:
    '''Base Class for User-defined Dependency Graph Geometry Data Types.'''
    def __init__(self):
        pass


    def smartCopy(self, srcGeom): 
        '''smartCopy(self, srcGeom)
Arguments:
	[in]	srcGeom = MPxGeometryData

This method is used in conjunction with  MPxSurfaceShape 
classes which support maya's deformations.'''
        pass

    def name(self): 
        '''name(self) -> MString

Determines the type name of the Data object. This is a pure
virtual method, and must be overridden in derived classes.'''
        pass

    def iterator(self, componentList, component, useComponents, world): 
        '''iterator(self, componentList, component, useComponents, world) -> MPxGeometryIterator
Returns: Returns:
A pointer to an iterator for your geometry

Arguments:
	[in]	componentList = MObjectArray
	[in]	component = MObject
	[in]	useComponents = bool
	[in]	world = bool

Associates a control point based geometry iterator with this
data. This method is used in conjunction with  MPxSurfaceShape  and
should be overridden if your shape is to support maya's
deformations.'''
        pass

    def typeId(self): 
        '''typeId(self) -> MTypeId

Determines the type id of the Data object. This is a pure
virtual method, and must be overridden in derived classes.'''
        pass

    def setMatrix(self, m): 
        '''setMatrix(self, m)
Arguments:
	[in]	m = MMatrix

Store the matrix associated to  
MPxGeometryData . The matrix transformation will take place when
the data is used, for example in deformer.'''
        pass

    def deleteComponentsFromGroups(self, compList, groupIdArray, groupComponentArray): 
        '''deleteComponentsFromGroups(self, compList, groupIdArray, groupComponentArray) -> bool
Returns: Returns:
true if the deletion was successfull, false otherwise

Arguments:
	[in]	compList = MObjectArray
	[in]	groupIdArray = MIntArray
	[in]	groupComponentArray = MObjectArray

This method should be overridden to modify the groups that flows
along with the geometry, as part of the data, based on the
components being deleted. It should intelligently update the groups
based on what gets deleted. The class  MFnGeometryData  can be used to
access and modify grouping information for data.'''
        pass

    def copy(self, src): 
        '''copy(self, src)
Arguments:
	[in]	src = MPxData

This method initializes an instance of an  
MPxGeometryData  derived class from another existing instance.
This method can be thought of as the  second half  of a copy
constructor for the class. The default constructor has already been
called for the instance, and this method is used to set the private
data by copying the values from an existing instance. This is a
pure virtual method, and must be overridden in derived classes.'''
        pass

    def updateCompleteVertexGroup(self, component): 
        '''updateCompleteVertexGroup(self, component) -> bool
Returns: Returns:
Returns true if the component was updated, false if it was
already complete

Arguments:
	[in]	component = MObject

This method is used in conjunction with  MPxSurfaceShape 
classes which support maya's deformations.'''
        pass

    def deleteComponent(self, compList): 
        '''deleteComponent(self, compList) -> bool
Returns: Returns:
true if the deletion was successfull, false otherwise

Arguments:
	[in]	compList = MObjectArray

This method should be overridden if this data is to support
component deletion. For user defined shapes ( MPxSurfaceShape )
which support components, this method must be overridden if
component deletion is to be supported when the shape has
history.'''
        pass

    def matrix(self, m): 
        '''matrix(self, m) -> bool
Returns: Returns:
true if m is not an identity matrix, false otherwise

Arguments:
	[out]	m = MMatrix

Return the matrix associated to  
MPxGeometryData .'''
        pass

class MPxGeometryIterator:
    '''Base class for user defined geometry iterators.'''
    def __init__(self):
        pass


    def reset(self): 
        '''reset(self)
Resets the iterator to the start of the components so that
another pass over them may be made. 
  Reprocessed example '''
        pass

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

Returns a unique index for the current item in the iteration. If
the iteration is over the whole geometry then this index is the
same as current point. If the iteration is over some elements of
the geometry specified by a component then this index is the index
in your geometry.'''
        pass

    def setObject(self, shape): 
        '''setObject(self, shape)
Arguments:
	[in]	shape = MPxSurfaceShape

Optional method to set a shape object to iterate over to allow
tweaking of the shape's history (input geometry).'''
        pass

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

Returns a unique index for the current item in the iteration
Rather than being the iterator index this is the index for the
actual item when simplification is skipping items. This index will
be equal to  
index()  if no simplification, otherwise it will be larger.'''
        pass

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

Returns an estimate of how many items will be iterated over.'''
        pass

    def point(self): 
        '''point(self) -> MPoint

Returns the current component's positional data.'''
        pass

    def geometry(self): 
        '''geometry(self) -> void*

'''
        pass

    def setPoint(self, point): 
        '''setPoint(self, point)
Arguments:
	[in]	point = MPoint

Sets the current component's positional data.'''
        pass

    def component(self, component): 
        '''component(self, component)
Arguments:
	[out]	component = MObject

Returns a component for the current item in the iteration.'''
        pass

    def next(self): 
        '''next(self)
'''
        pass

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

Indicates whether the underlying geometry has normals.'''
        pass

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

Indicates whether the underlying geometry has point data.'''
        pass

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

Returns the index that is being iterated on. This value is used
when iterating over all elements of your geometry, i.e. when there
are no components specified.'''
        pass

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

Set the current index of the iteration. This value is used when
iterating over all elements of your geometry, i.e. when there are
no components specified.'''
        pass

    def setPointGetNext(self, point): 
        '''setPointGetNext(self, point) -> int
Returns: Returns:
The next index value

Arguments:
	[in]	point = MPoint

Sets the current component's positional data, gets the next
point.'''
        pass

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

Returns the largest index that will be iterated over. This value
is used when iterating over all elements of your geometry, i.e.
when there are no components specified.'''
        pass

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

Indicates if all the items have been traversed yet.'''
        pass

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

Sets the largest index that will be iterated over. This value is
used when iterating over all elements of your geometry, i.e. when
there are no components specified.'''
        pass

class MPxGlBuffer:
    '''Base class for user defined GL buffers.'''
    def __init__(self):
        pass


    def close(self): 
        '''close(self)
Close and deallocate the actual pixel buffer.'''
        pass

    def beginBufferNotify(self): 
        '''beginBufferNotify(self)
This method is called when the GL buffer is being setup by the
viewport renderer. Overriding this call will allow you to access
the full GL state after it has been setup but before any drawing
has occurred.'''
        pass

    def endBufferNotify(self): 
        '''endBufferNotify(self)
This method is called when the GL buffer is being shutdown by
the viewport renderer. Overriding this call will allow you to
access the full GL state after drawing has completed but just
before the GL buffer is shut down.'''
        pass

class MPxHardwareShader:
    '''Base class for user defined hardware shaders.'''
    def __init__(self):
        pass


    outColorR = ''
    '''output color red'''

    outColor = ''
    '''output color value'''

    outColorB = ''
    '''output color blue'''

    outColorG = ''
    '''output color green'''

    def profile(self): 
        '''profile(self) -> const MRenderProfile

Override this method to specify the renderers your shader
supports. If this method is not overridden, Maya will assume your
shader supports only Maya's iternal OpenGL based renderer.'''
        pass

    def kNoTransparencyPolygonSort(self):
        '''This is an enum of TransparencyOptions.
Description: When set means ignore polygon sorting.
Value: 4'''
        pass

    def kIsTransparent(self):
        '''This is an enum of TransparencyOptions.
Description: When set means draw transparent.
Value: 1'''
        pass

    def kNoTransparencyFrontBackCull(self):
        '''This is an enum of TransparencyOptions.
Description: When set means ignore front back cull.
Value: 2'''
        pass

    class TransparencyOptions:
        '''Non-functional class.  Values for this enum:
        kNoTransparencyPolygonSort
        kIsTransparent
        kNoTransparencyFrontBackCull
'''
        def __init__(self):
            pass

    def renderImage(self, context, imageName, region, imageWidth, imageHeight): 
        '''renderImage(self, context, imageName, region, imageWidth, imageHeight)
Arguments:
	[in]	context = MPxHardwareShader.ShaderContext
	[in]	imageName = MString
	[in]	region = floatRegion
	[out]	imageWidth = int
	[out]	imageHeight = int

This method is not available in Python.'''
        pass

    def getAvailableImages(self, context, uvSetName, imageNames): 
        '''getAvailableImages(self, context, uvSetName, imageNames)
Arguments:
	[in]	context = MPxHardwareShader.ShaderContext
	[in]	uvSetName = MString
	[out]	imageNames = MStringArray

This method is not available in Python.'''
        pass

    def render(self, iterator): 
        '''render(self, iterator)
Arguments:
	[in]	iterator = MGeometryList

Override this method to render geometry using your hardware
shader. It is important to note that you can only access surface
data (e.g. uv sets) that you specified in populateRequirements. Any
data you did not ask for is unlikely to be available in the
geometry cache passed to you.'''
        pass

    def setVaryingParameters(self, parameters, remapCurrentValues, dagModifier): 
        '''setVaryingParameters(self, parameters, remapCurrentValues, dagModifier)
Arguments:
	[in]	parameters = MVaryingParameterList
	[in]	remapCurrentValues = bool
	[in]	dagModifier = MDagModifier

Call this method to set the list of varying parameters this
shader uses. Once set, you can use these parameters directly to
access geometry data for surfaces being shaded. When using this
method to manage shader varying parameters, there is no need to
override populateRequirements or handle the node interface as Maya
will handle parameter setup, presentation and configuration for
you.'''
        pass

    def populateRequirements(self, context, requirements): 
        '''populateRequirements(self, context, requirements)
Arguments:
	[in]	context = MPxHardwareShader.ShaderContext
	[out]	requirements = MGeometryRequirements

Override this method to let Maya know what surface data (e.g.
positions, normals, uv sets, tangents, binormals, etc) your shader
needs in order to render the specified geometry. This is the only
data your shader will be able to access when rendering the
geometry. For example, if your shader needs uv set "foo" to render
a texture, you must include that here before trying to use it in
your render method.'''
        pass

    def getHardwareShaderPtr(self, object): 
        '''getHardwareShaderPtr(self, object) -> MPxHardwareShader
Returns: Returns:
A pointer to an MPxHardwareShader.
If the method failed for any reason then a 0 (null) will be
returned.

Arguments:
	[in]	object = MObject

This is a static convenience method to be able to get an
 MPxHardwareShader 
from an  MObject 
provided by a swatch generator class (Class derived from  MSwatchRenderRegister ).'''
        pass

    def setUniformParameters(self, parameters, remapCurrentValues, dagModifier): 
        '''setUniformParameters(self, parameters, remapCurrentValues, dagModifier)
Arguments:
	[in]	parameters = MUniformParameterList
	[in]	remapCurrentValues = bool
	[in]	dagModifier = MDagModifier

Call this method to set the list of uniform parameters this
shader uses. Once set, you can use these parameters to access the
cached values of shader parameters, including testing when the
value has been updated (to minimise the shader state changes). When
using this method to manage uniform parameters, Maya will handle
the underlyintg attributes, serialization and user interface for
you.'''
        pass

    def findResource(self, name, shaderPath): 
        '''findResource(self, name, shaderPath) -> MString
Returns: Returns:
The full path of the resource (e.g.
"C:/shaders/textures/normals.dds")

Arguments:
	[in]	name = MString
	[in]	shaderPath = MString

This is a static utility to find the full path to a shader
resource (typically a texture). This method will search the list of
paths in the MAYA_HW_SHADER_RESOURCE_PATH environment variable,
resolving relative paths based on the directory containing the
shader.'''
        pass

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

This method returns transparency options for usage as hints for
Maya's internal draw during a given rendering pass. Parameters are
returned via an integer containing masked out bits. By default the
mask is set to 0, meaning that the drawing should be treated as
regular opaque object drawing. This will generally mean one call
per draw pass.'''
        pass

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

This method returns the type of the node. This method should not
be overridden by the user. It will return  MPxNode::kHwShaderNode .'''
        pass

    def renderSwatchImage(self, image): 
        '''renderSwatchImage(self, image)
Arguments:
	[in]	image = MImage

If the shader specifies to override swatch rendering, then this
method must be overridden in order to draw anything into a swatch.
The default implementation is to draw nothing. The basic logic to
draw a swatch is as follows:'''
        pass

class MPxHwShaderNode:
    '''Base class for user defined hardware shaders.'''
    def __init__(self):
        pass


    outColorB = ''
    '''output color blue'''

    outTransparencyR = ''
    '''output transparency red'''

    outGlowColorG = ''
    '''output glow color green'''

    outColorG = ''
    '''output color green'''

    outMatteOpacity = ''
    '''output matte opacity value'''

    outMatteOpacityB = ''
    '''output matte opacity blue'''

    outGlowColorB = ''
    '''output glow color blue'''

    outMatteOpacityG = ''
    '''output matte opacity green'''

    outColorR = ''
    '''output color red'''

    outColor = ''
    '''output color value'''

    outGlowColor = ''
    '''output glow color value'''

    outTransparencyG = ''
    '''output transparency green'''

    outGlowColorR = ''
    '''output glow color red'''

    outMatteOpacityR = ''
    '''output matte opacity red'''

    outTransparency = ''
    '''output transparency value'''

    outTransparencyB = ''
    '''output transparency blue'''

    def currentPath(self): 
        '''currentPath(self) -> const MDagPath

This method returns a reference to the current path that the
shader is invoked for.'''
        pass

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

Specifies whether or not this shader supports batched rendering
of shapes.'''
        pass

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

This method returns a "dirty" mask that indicates which geometry
items have changed from the last invocation of the plugin to draw.
The mask is valid at the time that  geometry() 
or  glGeometry() 
is called and at no other time.'''
        pass

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

Specifies whether this shader requires inverted texture
coordinates. (i.e. where the top-left hand corner of UV space is
(0,0) instead of the bottom-left corner).'''
        pass

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

This method returns transparency options for usage as hints for
Maya's internal draw during a given rendering pass. Parameters are
returned via an integer containing masked out bits. By default the
mask is set to 0, meaning that the drawing should be treated as
regular opaque object drawing. This will generally mean one call
per draw pass.'''
        pass

    def currentShadingEngine(self): 
        '''currentShadingEngine(self) -> MObject

This method returns an  MObject  to the shading engine that is
currently being rendered. This method will only return a valid
 MObject  during the
following calls:'''
        pass

    def glGeometry(self, shapePath, prim, indexCount, indexArray, vertexCount, vertexIDs, vertexArray, normalCount, normalArrays, colorCount, colorArrays, texCoordCount, texCoordArrays, writable): 
        '''glGeometry(self, shapePath, prim, indexCount, indexArray, vertexCount, vertexIDs, vertexArray, normalCount, normalArrays, colorCount, colorArrays, texCoordCount, texCoordArrays, writable)
Arguments:
	[in]	shapePath = MDagPath
	[in]	prim = int
	[out]	writable = int
	[in]	indexCount = int
	[in]	indexArray = int
	[in]	vertexCount = int
	[in]	vertexIDs = int
	[in]	vertexArray = float
	[in]	normalCount = int
	[in]	normalArrays = floatArrayPtr
	[in]	colorCount = int
	[in]	colorArrays = floatArrayPtr
	[in]	texCoordCount = int
	[in]	texCoordArrays = floatArrayPtr

This method should only be overridden for hardware
rendering.'''
        pass

    def kWriteAll(self):
        '''This is an enum of Writeable.
Description: 
Value: 15'''
        pass

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

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

    def kWriteTexCoordArrays(self):
        '''This is an enum of Writeable.
Description: 
Value: 8'''
        pass

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

    def kWriteColorArrays(self):
        '''This is an enum of Writeable.
Description: 
Value: 4'''
        pass

    class Writeable:
        '''Non-functional class.  Values for this enum:
        kWriteAll
        kWriteNormalArray
        kWriteVertexArray
        kWriteTexCoordArrays
        kWriteNone
        kWriteColorArrays
'''
        def __init__(self):
            pass

    def glUnbind(self, shapePath): 
        '''glUnbind(self, shapePath)
Arguments:
	[in]	shapePath = MDagPath

This method should only be overridden for hardware
rendering.'''
        pass

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

This method returns a boolean value that indicates whether the
object will be drawn transparently or not. Transparent objects must
be drawn after all the opaque objects in the scene or they will not
display correctly. Maya uses the return value to determine when it
can draw this shape.'''
        pass

    def kDirtyColorArrays(self):
        '''This is an enum of DirtyMask.
Description: 
Value: 4'''
        pass

    def kDirtyTexCoordArrays(self):
        '''This is an enum of DirtyMask.
Description: 
Value: 8'''
        pass

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

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

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

    def kDirtyAll(self):
        '''This is an enum of DirtyMask.
Description: 
Value: 15'''
        pass

    class DirtyMask:
        '''Non-functional class.  Values for this enum:
        kDirtyColorArrays
        kDirtyTexCoordArrays
        kDirtyVertexArray
        kDirtyNone
        kDirtyNormalArray
        kDirtyAll
'''
        def __init__(self):
            pass

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

This method returns the type of the node. This method should not
be overridden by the user. It will return  MPxNode::kHwShaderNode .'''
        pass

    def renderSwatchImage(self, image): 
        '''renderSwatchImage(self, image)
Arguments:
	[in]	image = MImage

If the shader specifies to override swatch rendering, then this
method must be overridden in order to draw anything into a swatch.
The default implementation is to draw nothing. The basic logic to
draw a swatch is as follows:'''
        pass

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

This method returns a boolean value that indicates whether a map
of the vertex IDs will be provided to the geometry method.'''
        pass

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

Specifies how many normals per vertex the HW shader would like
Maya to provide. This can range from 0 to 3. The first normal is
the surface normal. The second "normal" is the primary tangent
(generally the "u" direction). The third "normal" is the secondary
tangent or the binormal (generally the "v" direction). Together,
the normal, tangent and binormal form an orthogonal basis
frequently named "tangent space basis".'''
        pass

    def glBind(self, shapePath): 
        '''glBind(self, shapePath)
Arguments:
	[in]	shapePath = MDagPath

This method should only be overridden for hardware
rendering.'''
        pass

    def getHwShaderNodePtr(self, object): 
        '''getHwShaderNodePtr(self, object) -> MPxHwShaderNode
Returns: Returns:
A pointer to an MPxHwShaderNode.
If the method failed for any reason then a 0 (null) will be
returned.

Arguments:
	[in]	object = MObject

This is a static convenience method to be able to get an
 MPxHwShaderNode 
from an  MObject 
provided by a swatch generator class (Class derived from  MSwatchRenderRegister ).'''
        pass

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

This method returns the number of texture coordinate values per
vertex that the hw shader node would like to receive from Maya.
Maya will attempt to provide all the texture coordinate data that
the shader would like but it will never provide more data than is
actually available in the shape. The uv sets returned by  getTexCoordSetNames()  will override
the number of uv sets specified by  texCoordsPerVertex() .
If you do not override this method or  getTexCoordSetNames() , Maya will
provide no texture coordinates per vertex.'''
        pass

    def unbind(self, request, view): 
        '''unbind(self, request, view)
Arguments:
	[in]	request = MDrawRequest
	[in]	view = M3dView

This method is invoked for hardware rendering to Maya's 3D
view.'''
        pass

    def kNoTransparencyPolygonSort(self):
        '''This is an enum of TransparencyOptions.
Description: Do not use two-pass drawing of back-to-front sorted
polygons.
Value: 4'''
        pass

    def kIsTransparent(self):
        '''This is an enum of TransparencyOptions.
Description: Draw as a transparent object. If this bit is not set then the
others are ignored.
Value: 1'''
        pass

    def kNoTransparencyFrontBackCull(self):
        '''This is an enum of TransparencyOptions.
Description: Do not use the two-pass front-and-back culling algorithm.
Value: 2'''
        pass

    class TransparencyOptions:
        '''Non-functional class.  Values for this enum:
        kNoTransparencyPolygonSort
        kIsTransparent
        kNoTransparencyFrontBackCull
'''
        def __init__(self):
            pass

    def geometry(self, request, view, prim, indexCount, indexArray, vertexCount, vertexIDs, vertexArray, normalCount, normalArrays, colorCount, colorArrays, texCoordCount, texCoordArrays, writable): 
        '''geometry(self, request, view, prim, indexCount, indexArray, vertexCount, vertexIDs, vertexArray, normalCount, normalArrays, colorCount, colorArrays, texCoordCount, texCoordArrays, writable)
Arguments:
	[in]	request = MDrawRequest
	[in]	view = M3dView
	[in]	prim = int
	[out]	writable = int
	[in]	indexCount = int
	[in]	indexArray = int
	[in]	vertexCount = int
	[in]	vertexIDs = int
	[in]	vertexArray = float
	[in]	normalCount = int
	[in]	normalArrays = floatArrayPtr
	[in]	colorCount = int
	[in]	colorArrays = floatArrayPtr
	[in]	texCoordCount = int
	[in]	texCoordArrays = floatArrayPtr

This method is invoked for hardware rendering to Maya's 3D
view.'''
        pass

    def bind(self, request, view): 
        '''bind(self, request, view)
Arguments:
	[in]	request = MDrawRequest
	[in]	view = M3dView

This method is invoked for hardware rendering to Maya's 3D
view.'''
        pass

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

This method returns the number of color values per vertex that
the hw shader node would like to receive from Maya. Maya will
attempt to provide all the color data that the shader would like
but it will never provide more data that is actually available in
the shape. The color sets returned by  getColorSetNames()  will override the
number of color sets specified by  colorsPerVertex() .
If you do not override this method or  getColorSetNames() , Maya will
provide no colors per vertex.'''
        pass

class MPxIkSolverNode:
    '''Base class for user defined IK solvers.Note that the following virtual methods (declared in MPxNode) are
irrelevant for the MPxIkSolverNode. If
these methods are overridden in a class derived from MPxIkSolverNode, they
will be ignored.A creator method is necessary to return an instance of the user
solver:'''
    def __init__(self):
        pass


    def toSolverSpace(self): 
        '''toSolverSpace(self) -> const MMatrix

Returns the local space matrix for this solver.'''
        pass

    def setRotatePlane(self, rotatePlane): 
        '''setRotatePlane(self, rotatePlane)
Arguments:
	[in]	rotatePlane = bool

This method sets whether or not this solver supports the rotate
plane. Solvers that support the rotate plane allow the user to
manipulate the IK handle's pole vector with the rotate plane
manipulators.'''
        pass

    def setJointAngles(self, angles): 
        '''setJointAngles(self, angles)
Arguments:
	[in]	angles = MDoubleArray

This method is not available in Python.'''
        pass

    def solverTypeName(self): 
        '''solverTypeName(self) -> MString

This method returns the type name of the solver. The user must
override this method in order for the solver to be identifiable
when it is registered.'''
        pass

    def setPositionOnly(self, positionOnly): 
        '''setPositionOnly(self, positionOnly)
Arguments:
	[in]	positionOnly = bool

Sets whether or not the solver supports handle orientation.'''
        pass

    def snapHandle(self, handle): 
        '''snapHandle(self, handle)
Arguments:
	[in]	handle = MObject

This function positions the handle at the end effector position.
The user can override this method.'''
        pass

    def setHandleGroup(self, group): 
        '''setHandleGroup(self, group)
Arguments:
	[in]	group = MIkHandleGroup

Set the handle group of this solver.'''
        pass

    def setSingleChainOnly(self, singleChainOnly): 
        '''setSingleChainOnly(self, singleChainOnly)
Arguments:
	[in]	singleChainOnly = bool

This method sets whether or not this solver is a single chain
solver. Single chain solvers are solvers which act on one handle
only, i.e. the handle groups have only one handle if they are for
single chain solvers.'''
        pass

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

This method indicates whether this solver is a single chain
solver. Single chain solvers are solvers which act on one handle
only, i.e. the handle groups have only one handle if they are for
single chain solvers.'''
        pass

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

This method indicates whether the solver provides a unique
solution.'''
        pass

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

Indicates whether the ik solution is dependent on the ikHandle
position only or also uses the orientation.'''
        pass

    def toWorldSpace(self): 
        '''toWorldSpace(self) -> const MMatrix

Returns the world space matrix for this solver.'''
        pass

    def getJointAngles(self, angles): 
        '''getJointAngles(self, angles)
Arguments:
	[out]	angles = MDoubleArray

This method is not available in Python.'''
        pass

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

This method returns the type of the node. This method should not
be overridden by the user. It will return  MPxNode::kIkSolverNode .'''
        pass

    def setSupportJointLimits(self, supportJointLimits): 
        '''setSupportJointLimits(self, supportJointLimits)
Arguments:
	[in]	supportJointLimits = bool

This method sets whether or not the solver supports limits on
joint angles.'''
        pass

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

Return the the maximum nuber of itertations for a solution by
this solver.'''
        pass

    def setUniqueSolution(self, uniqueSolution): 
        '''setUniqueSolution(self, uniqueSolution)
Arguments:
	[in]	uniqueSolution = bool

This method sets whether or not the solver provides a unique
solution.'''
        pass

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

Set the error value for this solver. The user can override this
if any other calcluations should be done here.'''
        pass

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

This method indicates whether the solver supports limits on
joint angles.'''
        pass

    def postSolve(self): 
        '''postSolve(self)
This method is called after  doSolve  has finished. The
user should override this method if there are any post calculations
to be done.'''
        pass

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

This method indicates whether this solver supports the rotate
plane. Solvers that support the rotate plane allow the user to
manipulate the IK handle's pole vector with the rotate plane
manipulators.'''
        pass

    def preSolve(self): 
        '''preSolve(self)
This method is called before  doSolve . Users should
override this method if there is any preprocessing that needs to be
done before solving..'''
        pass

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

Return the error value for this solver.'''
        pass

    def doSolve(self): 
        '''doSolve(self)
This is where the main solving takes place. The user must
override this method.'''
        pass

    def setToRestAngles(self): 
        '''setToRestAngles(self)
'''
        pass

    def handleGroup(self): 
        '''handleGroup(self) -> MIkHandleGroup

Returns the handle group for this solver. The handle group
provides access to handles associated with the solver.'''
        pass

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

Set the maximum iterations for a solution by this solver. The
user can override this if any other calcluations should be done
here.'''
        pass

class MPxImageFile:
    '''Image manipulation.'''
    def __init__(self):
        pass


    def load(self, image, imageNumber): 
        '''load(self, image, imageNumber)
Arguments:
	[in]	image = MImage
	[in]	imageNumber = int

Load the previously opened image file into an  MImage .'''
        pass

    def close(self): 
        '''close(self)
Close the image file.'''
        pass

    def open(self, pathname, info): 
        '''open(self, pathname, info)
Arguments:
	[in]	pathname = MString
	[out]	info = MImageFileInfo

Attempt to open the specified file as an image and extract the
image characteristics. It is important that this function only
return success if the image is definitely supported by this
implementation.'''
        pass

    def glLoad(self, info, imageNumber): 
        '''glLoad(self, info, imageNumber)
Arguments:
	[in]	info = MImageFileInfo
	[in]	imageNumber = int

Load the previously opened image file as an OpenGL texture. The
OpenGL texture will already have been bound by the caller of this
method (i.e. do not call glBind again inside your implementation of
this method - just use glTexImage2D or equivalent to load the
texture). The type of texture that has been bound is specified in
the information structure provided. It is important that your
implementation verifies this type before loading any data, as
loading an incompatible type may lead to instability. By overriding
this method, you can implement non-2D texture support (such as cube
maps), non-byte texture support (such as float and half), and
compressed hardware texture support (such as DXT). You are free to
use any available OpenGL extensions you want to load in the
texture. While standard Maya shaders will only be able to use
standard 2D textures, plugin hardware shaders can access non-2D
textures loaded via this method. If your plugin set mipmaps to true
at file open time, it is responsible for loading or generating the
mipmap information inside this method.'''
        pass

class MPxImagePlane:
    '''Base class for user defined imagePlane nodes.'''
    def __init__(self):
        pass


    composite = ''
    '''Separate file that contains depth
information.'''

    sourceTexture = ''
    '''Controls how the image file will be fit into
the image plane.'''

    alphaGain = ''
    '''A multiplier that is applied to the alpha
value.'''

    maxShadingSamples = ''
    '''Specifies the max number of shading samples
can be taken for this surface during rendering.'''

    lockedToCamera = ''
    '''If enabled, the image plane is locked to the
camera's position.'''

    offsetY = ''
    '''Vertical component of Offset.'''

    depthOversample = ''
    '''Separate file that contains depth
information.'''

    squeezeCorrection = ''
    '''Applies a horizontal scaling to an
image.'''

    colorGain = ''
    '''A multiplier applied to the colors in the
image plane.'''

    coverageOriginY = ''
    '''The pixel position of the bottom edge of the
area of the source image to be used.'''

    coverageOriginX = ''
    '''The pixel position of the left edge of the
area of the source image to be used.'''

    size = ''
    '''Controls the width and height of the image
plane.'''

    colorOffsetB = ''
    '''The blue component of Color
Offset.'''

    alreadyPremult = ''
    '''Indicates that the image plane has depth
information.'''

    depthBias = ''
    '''Depth offset value -- centered at the center
of the view frustum.'''

    fit = ''
    '''Controls how the image file will be fit into
the image plane.'''

    colorOffsetG = ''
    '''The green component of Color
Offset.'''

    depthFile = ''
    '''Separate file that contains depth
information.'''

    colorOffset = ''
    '''An additive value applied to the colors in
the image plane.'''

    width = ''
    '''Controls the width of the image plane in
world space.'''

    colorOffsetR = ''
    '''The red component of Color
Offset.'''

    imageName = ''
    '''The frame extension in Image Name is
replaced by the number here.'''

    centerZ = ''
    '''Z component of Center.'''

    centerX = ''
    '''X component of Center.'''

    centerY = ''
    '''Y component of Center.'''

    visibleInReflections = ''
    '''Rotation of the image plane around the view
vector.'''

    coverageOrigin = ''
    '''The pixel position of the left edge of the
area of the source image to be used.'''

    imageType = ''
    '''controls the source of the image on the
Image plane.'''

    shadingSamplesOverride = ''
    '''The flag to control if this surface should
override global shading sample settings.'''

    useFrameExtension = ''
    '''The frame extension in Image Name is
replaced by the number here.'''

    frameExtension = ''
    '''The frame extension in Image Name is
replaced by the number here.'''

    sizeX = ''
    '''Image plane width.'''

    coverageY = ''
    '''The height in pixels of the area on the
source image to be used.'''

    coverageX = ''
    '''The width in pixels of the area on the
source image to be used.'''

    displayMode = ''
    '''A multiplier applied to the colors in the
image plane.'''

    sizeY = ''
    '''Image plane height.'''

    useDepthMap = ''
    '''Indicates that the image plane has depth
information.'''

    visibleInRefractions = ''
    '''Rotation of the image plane around the view
vector.'''

    coverage = ''
    '''Controls the amount of the image that will
be used in the image plane.'''

    offset = ''
    '''Horizontal component of Offset.'''

    height = ''
    '''Controls the height of the image plane in
world space.'''

    rotate = ''
    '''Rotation of the image plane around the view
vector.'''

    displayOnlyIfCurrent = ''
    '''A multiplier applied to the colors in the
image plane.'''

    center = ''
    '''X component of Center.'''

    colorGainR = ''
    '''The red component of Color Gain.'''

    offsetX = ''
    '''Horizontal component of Offset.'''

    shadingSamples = ''
    '''Specifies the minimum number of shading
samples should be taken for this surface during
rendering.'''

    depthScale = ''
    '''Scale the depth -- centered at the center of
the view frustum.'''

    depth = ''
    '''Controls the distance of the plane from the
camera.'''

    colorGainB = ''
    '''The blue component of Color Gain.'''

    separateDepth = ''
    '''Separate file that contains depth
information.'''

    colorGainG = ''
    '''The green component of Color
Gain.'''

    def sourceTexture(self): 
        '''sourceTexture(self) -> MPxImagePlane.MObject 

'''
        pass

    def alreadyPremult(self): 
        '''alreadyPremult(self) -> MPxImagePlane.MObject 

'''
        pass

    def displayOnlyIfCurrent(self): 
        '''displayOnlyIfCurrent(self) -> MPxImagePlane.MObject 

'''
        pass

    def center(self): 
        '''center(self) -> MPxImagePlane.MObject 

'''
        pass

    def useFrameExtension(self): 
        '''useFrameExtension(self) -> MPxImagePlane.MObject 

'''
        pass

    def getExactImageFile(self, refFileName, actualName): 
        '''getExactImageFile(self, refFileName, actualName) -> bool
Returns: Returns:


true The file was found and the file name was
expanded.
false The file was not found and the file name was not
expanded.

Arguments:
	[in]	refFileName = MString
	[in]	actualName = MString

API users can call this method to resolve a file name. Sometimes
the file path specified by the user node are relative or contain
environment variables that require expansion. Also  getExactImageFile() 
will try to find the image file sequence if use sequence is on. API
users do not have to call this method, and it is only provided for
convienence purposes. The full path name will be returned in
actualName.'''
        pass

    def composite(self): 
        '''composite(self) -> MPxImagePlane.MObject 

'''
        pass

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

Returns the type of node that this is. This is used to
differentiate user defined nodes that are derived off different MPx
base classes.'''
        pass

    def coverageOrigin(self): 
        '''coverageOrigin(self) -> MPxImagePlane.MObject 

'''
        pass

    def loadImageMap(self, fileName, frame, image): 
        '''loadImageMap(self, fileName, frame, image)
Arguments:
	[in]	fileName = MString
	[in]	frame = int
	[in]	image = MImage

Override this method to load the file of name fileName into the
image  MImage .'''
        pass

    def exactImageFile(self, refFileName): 
        '''exactImageFile(self, refFileName) -> MString
Returns: Returns:
String containing the image file name, will be empty string on
failure

Arguments:
	[in]	refFileName = MString

API users can call this method to resolve a file name. Sometimes
the file path specified by the user node are relative or contain
environment variables that require expansion. Also  getExactImageFile() 
will try to find the image file sequence if use sequence is on. API
users do not have to call this method, and it is only provided for
convienence purposes. The full path name will be returned in
actualName.'''
        pass

    def depthOversample(self): 
        '''depthOversample(self) -> MPxImagePlane.MObject 

'''
        pass

    def imageName(self): 
        '''imageName(self) -> MPxImagePlane.MObject 

'''
        pass

    def displayMode(self): 
        '''displayMode(self) -> MPxImagePlane.MObject 

'''
        pass

    def visibleInRefractions(self): 
        '''visibleInRefractions(self) -> MPxImagePlane.MObject 

'''
        pass

    def offset(self): 
        '''offset(self) -> MPxImagePlane.MObject 

'''
        pass

    def visibleInReflections(self): 
        '''visibleInReflections(self) -> MPxImagePlane.MObject 

'''
        pass

    def setImageDirty(self): 
        '''setImageDirty(self)
'''
        pass

    def refreshImage(self): 
        '''refreshImage(self)
'''
        pass

    def separateDepth(self): 
        '''separateDepth(self) -> MPxImagePlane.MObject 

'''
        pass

class MPxLocatorNode:
    '''Base class for user defined locators.'''
    def __init__(self):
        pass


    instObjGroups = ''
    '''instances object group info
attribute'''

    intermediateObject = ''
    '''intermediate object attribute'''

    underWorldObject = ''
    '''under world attribute'''

    localPositionZ = ''
    '''Z component of localPosition.'''

    localPositionX = ''
    '''X component of localPosition.'''

    nodeBoundingBoxMin = ''
    '''bounding box minimum point'''

    worldPosition = ''
    '''world position attribute'''

    nodeBoundingBoxSizeX = ''
    '''X component of boundingBoxSize.'''

    worldInverseMatrix = ''
    '''inverse world matrix attribute'''

    isTemplated = ''
    '''template attribute'''

    matrix = ''
    '''matrix attribute'''

    nodeBoundingBoxSize = ''
    '''bounding box size vector'''

    objectGroupId = ''
    '''group id attribute'''

    useObjectColor = ''
    '''controls choice of wireframe dormant object
color'''

    localScaleX = ''
    '''X component of localScale.'''

    localScaleY = ''
    '''Y component of localScale.'''

    localScaleZ = ''
    '''Z component of localScale.'''

    worldMatrix = ''
    '''world matrix attribute'''

    nodeBoundingBox = ''
    '''bounding box attribute'''

    objectGrpCompList = ''
    '''component in object groups
attribute'''

    worldPositionY = ''
    '''Y component of worldPosition.'''

    worldPositionX = ''
    '''X component of worldPosition.'''

    worldPositionZ = ''
    '''Z component of worldPosition.'''

    parentInverseMatrix = ''
    '''inverse parent matrix attribute'''

    localPosition = ''
    '''local position attribute'''

    objectGroups = ''
    '''object groups attributes'''

    objectGroupColor = ''
    '''group id attribute'''

    visibility = ''
    '''visibility attribute'''

    parentMatrix = ''
    '''parent matrix attribute'''

    nodeBoundingBoxMaxZ = ''
    '''Z component of boundingBoxMax.'''

    nodeBoundingBoxSizeY = ''
    '''Y component of boundingBoxSize.'''

    nodeBoundingBoxMaxX = ''
    '''X component of boundingBoxMax.'''

    nodeBoundingBoxMaxY = ''
    '''Y component of boundingBoxMax.'''

    localPositionY = ''
    '''Y component of localPosition.'''

    nodeBoundingBoxMinX = ''
    '''X component of boundingBoxMin.'''

    nodeBoundingBoxMinY = ''
    '''Y component of boundingBoxMin.'''

    nodeBoundingBoxMinZ = ''
    '''Z component of boundingBoxMin.'''

    boundingBoxCenterZ = ''
    '''Z component of boundingBoxCenter.'''

    nodeBoundingBoxMax = ''
    '''bounding box maximum point'''

    boundingBoxCenterX = ''
    '''X component of boundingBoxCenter.'''

    boundingBoxCenterY = ''
    '''Y component of boundingBoxCenter.'''

    center = ''
    '''object center attribute'''

    localScale = ''
    '''local scale attribute'''

    nodeBoundingBoxSizeZ = ''
    '''Z component of boundingBoxSize.'''

    objectColor = ''
    '''the per object dormant wireframe
color'''

    inverseMatrix = ''
    '''inverse matrix attribute'''

    def draw(self, view, path, style, status): 
        '''draw(self, view, path, style, status)
Arguments:
	[in]	view = M3dView
	[in]	path = MDagPath
	[in]	style = M3dView.DisplayStyle
	[in]	status = M3dView.DisplayStatus

Overriding this method allows the drawing of custom geometry
using standard OpenGL calls. The OpenGL state should be left in the
same state that it was in previously. The OpenGL routine
glPushAttrib may be used to make this easier.'''
        pass

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

Indicates that this locator uses transparency during draw method
calls. Objects with transparency must be drawn in a special queue,
i.e. after all opaque objects are drawn.'''
        pass

    def colorRGB(self, displayStatus): 
        '''colorRGB(self, displayStatus) -> MColor
Returns: Returns:
The color

Arguments:
	[in]	displayStatus = M3dView.DisplayStatus

This method returns the RGB values of the default draw color for
the given display status.'''
        pass

    def color(self, displayStatus): 
        '''color(self, displayStatus) -> int
Returns: Returns:
The index of the color

Arguments:
	[in]	displayStatus = M3dView.DisplayStatus

This method returns the index of the color that is the default
draw color for the given display status. The index should be used
with the methods of  M3dView . The value is not an index into the
OpenGL color table.'''
        pass

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

When the modelPanel is set to not draw locators, returing true
will also not draw the custom locator. If false is returned, the
custom locator will also be drawn.'''
        pass

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

This method should be overridden to return true if the user
supplies a bounding box routine. Supplying a bounding box routine
makes refresh and selection more efficient.'''
        pass

    def boundingBox(self): 
        '''boundingBox(self) -> MBoundingBox

This method should be overridden to return a bounding box for
the locator. If this method is overridden, then  MPxLocatorNode::isBounded 
should also be overridden to return true.'''
        pass

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

Indicates that this locator should be the last item draw in a
given refresh cycle. Objects drawn out-of-order will not preserve
the proper transparency sorting. Conflicts among multiple objects
with the drawLast indicator set to TRUE will be resolved by their
order in the Outliner, where they will be drawn top-to-bottom.'''
        pass

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

This method returns the type of the node. This method should not
be overridden by the user. It will return  MPxNode::kLocatorNode .'''
        pass

class MPxManipulatorNode:
    '''Base class for manipulator creation.This class can work standalone or with MPxManipContainer.'''
    def __init__(self):
        pass


    connectedNodes = ''
    '''Connected node, message
attribute.'''

    def glFirstHandle(self, firstHandle): 
        '''glFirstHandle(self, firstHandle)
Arguments:
	[out]	firstHandle = MPxManipulatorNode.MGLuint

This method is used to find the unsigned int value that should
be used for the first GL handle.'''
        pass

    def yColor(self): 
        '''yColor(self) -> short

'''
        pass

    def addDoubleValue(self, valueName, defaultValue, valueIndex): 
        '''addDoubleValue(self, valueName, defaultValue, valueIndex)
Arguments:
	[in]	valueName = MString
	[in]	defaultValue = double
	[out]	valueIndex = int

Manipulators which call  
connectPlugToValue()  must first create the value on the node.
Use this method to create a value of double type.'''
        pass

    def mouseRayWorld(self, linePoint, lineDirection): 
        '''mouseRayWorld(self, linePoint, lineDirection)
Arguments:
	[out]	linePoint = MPoint
	[out]	lineDirection = MVector

This method returns the location of the mouse within a view. The
location is defined by a point and a direction through the point.
Both point and direction are in world space.'''
        pass

    def connectPlugToValue(self, plug, valueIndex, plugIndex): 
        '''connectPlugToValue(self, plug, valueIndex, plugIndex)
Arguments:
	[in]	plug = MPlug
	[in]	valueIndex = int
	[out]	plugIndex = int

This method is called in the  
connectToDependNode()  virtual if it is implemented for the
custom manipulator. It will connect a plug to an already added
manipulator value of the same type.'''
        pass

    def mouseRay(self, linePoint, lineDirection): 
        '''mouseRay(self, linePoint, lineDirection)
Arguments:
	[out]	linePoint = MPoint
	[out]	lineDirection = MVector

This method returns the location of the mouse within a view. The
location is defined by a point and a direction through the point.
Both point and direction are in local space.'''
        pass

    def setVectorValue(self, valueIndex, value): 
        '''setVectorValue(self, valueIndex, value)
Arguments:
	[in]	valueIndex = int
	[in]	value = MVector

This method is used for setting a  MVector  value
associated with the manipulator.'''
        pass

    def finishAddingManips(self): 
        '''finishAddingManips(self)
This method should be called from the user-defined manipulator
plug-in near the end of the connectToDependNode method so that the
converter in the manipulator can be initialized. The converter
cannot be initialized until all the connections from the manip
values to the plug values have been specified.'''
        pass

    def xColor(self): 
        '''xColor(self) -> short

'''
        pass

    def labelColor(self): 
        '''labelColor(self) -> short

'''
        pass

    def mouseDown(self, x_pos, y_pos): 
        '''mouseDown(self, x_pos, y_pos)
Arguments:
	[out]	x_pos = short
	[out]	y_pos = short

This method returns the mouse down position within a view. The
position is in port coordinates.'''
        pass

    def getDoubleValue(self, valueIndex, previousValue, value): 
        '''getDoubleValue(self, valueIndex, previousValue, value)
Arguments:
	[in]	valueIndex = int
	[in]	previousValue = bool
	[out]	value = double

This method is used for getting a double value associated with
the manipulator.'''
        pass

    def doPress(self, view): 
        '''doPress(self, view)
Arguments:
	[in]	view = M3dView

This method gets called when the manipulator receives a mouse
down event.'''
        pass

    def draw(self, view, path, style, status): 
        '''draw(self, view, path, style, status)
Arguments:
	[in]	view = M3dView
	[in]	path = MDagPath
	[in]	style = M3dView.DisplayStyle
	[in]	status = M3dView.DisplayStatus

This method is overloaded to draw the manipulators. Selection is
also setup with this method using the  
colorAndName()  method call.'''
        pass

    def connectToDependNode(self, node): 
        '''connectToDependNode(self, node)
Arguments:
	[in]	node = MObject

This method connects the manipulator to the dependency node.
This is a virtual method and needs to be overridden from the
plug-in.'''
        pass

    def addPointValue(self, valueName, defaultValue, valueIndex): 
        '''addPointValue(self, valueName, defaultValue, valueIndex)
Arguments:
	[in]	valueName = MString
	[in]	defaultValue = MPoint
	[out]	valueIndex = int

Manipulators which call  
connectPlugToValue()  must first create the value on the node.
Use this method to create a value of double  MPoint .'''
        pass

    def setDoubleValue(self, valueIndex, value): 
        '''setDoubleValue(self, valueIndex, value)
Arguments:
	[in]	valueIndex = int
	[in]	value = double

This method is used for setting a double value associated with
the manipulator.'''
        pass

    def zColor(self): 
        '''zColor(self) -> short

'''
        pass

    def getVectorValue(self, valueIndex, previousValue, value): 
        '''getVectorValue(self, valueIndex, previousValue, value)
Arguments:
	[in]	valueIndex = int
	[in]	previousValue = bool
	[out]	value = MVector

This method is used for getting a  MVector  value
associated with the manipulator.'''
        pass

    def prevColor(self): 
        '''prevColor(self) -> short

'''
        pass

    def dimmedColor(self): 
        '''dimmedColor(self) -> short

'''
        pass

    def mousePosition(self, x_pos, y_pos): 
        '''mousePosition(self, x_pos, y_pos)
Arguments:
	[out]	x_pos = short
	[out]	y_pos = short

This method returns the current mouse position within a view.
The position is in port coordinates.'''
        pass

    def addVectorValue(self, valueName, defaultValue, valueIndex): 
        '''addVectorValue(self, valueName, defaultValue, valueIndex)
Arguments:
	[in]	valueName = MString
	[in]	defaultValue = MVector
	[out]	valueIndex = int

Manipulators which call  
connectPlugToValue()  must first create the value on the node.
Use this method to create a value of double  MVector .'''
        pass

    def labelBackgroundColor(self): 
        '''labelBackgroundColor(self) -> short

'''
        pass

    def selectedColor(self): 
        '''selectedColor(self) -> short

'''
        pass

    def mouseUp(self, x_pos, y_pos): 
        '''mouseUp(self, x_pos, y_pos)
Arguments:
	[out]	x_pos = short
	[out]	y_pos = short

This method returns the mouse up position within a view. The
position is in port coordinates.'''
        pass

    def setPointValue(self, valueIndex, value): 
        '''setPointValue(self, valueIndex, value)
Arguments:
	[in]	valueIndex = int
	[in]	value = MPoint

This method is used for setting an  MPoint 
value associated with the manipulator.'''
        pass

    def getPointValue(self, valueIndex, previousValue, value): 
        '''getPointValue(self, valueIndex, previousValue, value)
Arguments:
	[in]	valueIndex = int
	[in]	previousValue = bool
	[out]	value = MPoint

This method is used for getting a  MPoint 
value associated with the manipulator.'''
        pass

    def lineColor(self): 
        '''lineColor(self) -> short

'''
        pass

    def doRelease(self, view): 
        '''doRelease(self, view)
Arguments:
	[in]	view = M3dView

This method gets called when the manipulator recieves a mouse
release event.'''
        pass

    def mainColor(self): 
        '''mainColor(self) -> short

'''
        pass

    def doDrag(self, view): 
        '''doDrag(self, view)
Arguments:
	[in]	view = M3dView

This method gets called when the manipulator recieves a mouse
drag event.'''
        pass

    def newManipulator(self, manipName, manipObject): 
        '''newManipulator(self, manipName, manipObject) -> MPxManipulatorNode

Arguments:
	[in]	manipName = MString
	[in]	manipObject = MObject

This static function is used to create a user-defined
manipulator. The manipObject argument is set to the new manipulator
node. Note that the manipName argument must be the name of a
manipulator derived from  MPxManipulatorNode . Also
note that this method creates the newManipulator, but doesn't add
it to the DAG. The primary use of this method is in conjunction
with  
MPxSelectionContext::addManipulator , to add user-defined
manipulators to a context.'''
        pass

    def colorAndName(self, view, glName, glNameIsPickable, colorIndex): 
        '''colorAndName(self, view, glName, glNameIsPickable, colorIndex)
Arguments:
	[in]	view = M3dView
	[in]	glName = MPxManipulatorNode.MGLuint
	[in]	glNameIsPickable = bool
	[in]	colorIndex = short

This method is used to set the color of the GL component that is
being drawn next. It is also used to set GL name of the component
so that picking can be supported.'''
        pass

    def glActiveName(self, glName): 
        '''glActiveName(self, glName)
Arguments:
	[out]	glName = MPxManipulatorNode.MGLuint

This method returns the unsigned int value which specifies the
current active handle.'''
        pass

class MPxManipContainer:
    '''Base class for user defined manipulator containers.'''
    def __init__(self):
        pass


    def addPlugToManipConversion(self, manipIndex): 
        '''addPlugToManipConversion(self, manipIndex)
Arguments:
	[in]	manipIndex = int

This method adds a plug to manipulator converter for the
specified manipulator value (e.g. the start point of a distance
manip). The converter must be implemented in the  
plugToManipConversion()  virtual method of this class.'''
        pass

    def removeFromManipConnectTable(self, id): 
        '''removeFromManipConnectTable(self, id)
Arguments:
	[in]	id = MTypeId

This method removes the user defined node entry from the
manipConnectTable.'''
        pass

    def addStateManip(self, manipName, stateName): 
        '''addStateManip(self, manipName, stateName) -> MDagPath
Returns: Returns:
New StateManip

Arguments:
	[in]	manipName = MString
	[in]	stateName = MString

This method creates a StateManip and adds it to the  MPxManipContainer 
container.'''
        pass

    def plugToManipConversion(self, manipIndex): 
        '''plugToManipConversion(self, manipIndex) -> MManipData
Returns: Returns:
New manipulator value.

Arguments:
	[in]	manipIndex = int

This virtual method calculates and returns the requested
manipulator value, based upon the values of plugs on the nodes
being manipulated.'''
        pass

    def addDiscManip(self, manipName, angleName): 
        '''addDiscManip(self, manipName, angleName) -> MDagPath
Returns: Returns:
New DiscManip

Arguments:
	[in]	manipName = MString
	[in]	angleName = MString

This method creates a DiscManip and adds it to the  MPxManipContainer 
container.'''
        pass

    def draw(self, view, path, style, status): 
        '''draw(self, view, path, style, status)
Arguments:
	[in]	view = M3dView
	[in]	path = MDagPath
	[in]	style = M3dView.DisplayStyle
	[in]	status = M3dView.DisplayStatus

This method can be overloaded to customize the drawing of the
child manipulators. If the default draw is also required, this
method should be called from the derived method.'''
        pass

    def addToggleManip(self, manipName, toggleName): 
        '''addToggleManip(self, manipName, toggleName) -> MDagPath
Returns: Returns:
New ToggleManip

Arguments:
	[in]	manipName = MString
	[in]	toggleName = MString

This method creates a ToggleManip and adds it to the  MPxManipContainer 
container.'''
        pass

    def getConverterManipValue(self, manipIndex, xform): 
        '''getConverterManipValue(self, manipIndex, xform)
Arguments:
	[in]	manipIndex = int
	[out]	xform = MTransformationMatrix

This method retrieves the value of a converterManipValue of type
 MTransformationMatrix  at a given index
from the converter.'''
        pass

    def initialize(self): 
        '''initialize(self)
This method initializes the manipulator, and should be overriden
in user-defined manipulators.'''
        pass

    def finishAddingManips(self): 
        '''finishAddingManips(self)
This method should be called from the user-defined manipulator
plug-in near the end of the connectToDependNode method so that the
converter in the manipulator can be initialized. The converter
cannot be initialized until all the connections from the manip
values to the plug values have been specified.'''
        pass

    def kCircleSweepManip(self):
        '''This is an enum of baseType.
Description: 
Value: 6'''
        pass

    def kCurveSegmentManip(self):
        '''This is an enum of baseType.
Description: 
Value: 9'''
        pass

    def kDiscManip(self):
        '''This is an enum of baseType.
Description: 
Value: 5'''
        pass

    def kStateManip(self):
        '''This is an enum of baseType.
Description: 
Value: 8'''
        pass

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

    def kCustomManip(self):
        '''This is an enum of baseType.
Description: 
Value: 10'''
        pass

    def kToggleManip(self):
        '''This is an enum of baseType.
Description: 
Value: 7'''
        pass

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

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

    def kPointOnSurfaceManip(self):
        '''This is an enum of baseType.
Description: 
Value: 4'''
        pass

    def kPointOnCurveManip(self):
        '''This is an enum of baseType.
Description: 
Value: 3'''
        pass

    class baseType:
        '''Non-functional class.  Values for this enum:
        kCircleSweepManip
        kCurveSegmentManip
        kDiscManip
        kStateManip
        kDistanceManip
        kCustomManip
        kToggleManip
        kFreePointTriadManip
        kDirectionManip
        kPointOnSurfaceManip
        kPointOnCurveManip
'''
        def __init__(self):
            pass

    def getConverterPlugValue(self, plugIndex, rotation): 
        '''getConverterPlugValue(self, plugIndex, rotation)
Arguments:
	[in]	plugIndex = int
	[out]	rotation = MEulerRotation

This method retrieves the value of a converterPlugValue of type
 MEulerRotation  at a given index from the
converter.'''
        pass

   

    def addToManipConnectTable(self, mid): 
        '''addToManipConnectTable(self, mid)
Arguments:
	[in]	mid = MTypeId

This method adds the user defined node as an entry in the
manipConnectTable so that when this node is selected the user can
use the show manip tool to get the user defined manipulator
associated with this node. Note that the name of the manipulator
node has to be the name of the plug-in node appended with
"Manip".'''
        pass

    def doDrag(self): 
        '''doDrag(self)
This method gets called when the manipulator recieves a mouse
drag event.'''
        pass

    def addScaleManip(self, manipName, scaleName): 
        '''addScaleManip(self, manipName, scaleName) -> MDagPath
Returns: Returns:
Dag path to the new scale manipulator

Arguments:
	[in]	manipName = MString
	[in]	scaleName = MString

This method creates a scale manipulator and adds it to the
 MPxManipContainer 
container.'''
        pass

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

This method returns the type of the node.'''
        pass

    def addMPxManipulatorNode(self, manipTypeName, manipName, proxyManip): 
        '''addMPxManipulatorNode(self, manipTypeName, manipName, proxyManip)
Arguments:
	[in]	manipTypeName = MString
	[in]	manipName = MString
	[out]	proxyManip = MPxManipulatorNode

This method creates a custom  MPxManipulatorNode  and
adds it to the  MPxManipContainer 
container.'''
        pass

    def addFreePointTriadManip(self, manipName, pointName): 
        '''addFreePointTriadManip(self, manipName, pointName) -> MDagPath
Returns: Returns:
New FreePointTriadManip

Arguments:
	[in]	manipName = MString
	[in]	pointName = MString

This method creates a FreePointTriadManip and adds it to the
 MPxManipContainer 
container.'''
        pass

    def addPointOnCurveManip(self, manipName, paramName): 
        '''addPointOnCurveManip(self, manipName, paramName) -> MDagPath
Returns: Returns:
New PointOnCurveManip

Arguments:
	[in]	manipName = MString
	[in]	paramName = MString

This method creates a PointOnCurveManip and adds it to the
 MPxManipContainer 
container.'''
        pass

    def connectToDependNode(self, node): 
        '''connectToDependNode(self, node)
Arguments:
	[in]	node = MObject

This method connects the manipulator to the dependency node.
This is a virtual method and needs to be overridden from the
plug-in.'''
        pass

    def isManipActive(self, manipType, manipObject): 
        '''isManipActive(self, manipType, manipObject) -> bool
Returns: Returns:


true custom manip is active
false custom manip is inactive

Arguments:
	[in]	manipType = MFn.Type
	[in]	manipObject = MObject

This method determines if custom manip is active & gets the
current manip object.'''
        pass

    def addCircleSweepManip(self, manipName, angleName): 
        '''addCircleSweepManip(self, manipName, angleName) -> MDagPath
Returns: Returns:
New CircleSweepManip

Arguments:
	[in]	manipName = MString
	[in]	angleName = MString

This method creates a CircleSweepManip and adds it to the
 MPxManipContainer 
container.'''
        pass

    def addDirectionManip(self, manipName, directionName): 
        '''addDirectionManip(self, manipName, directionName) -> MDagPath
Returns: Returns:
New DirectionManip

Arguments:
	[in]	manipName = MString
	[in]	directionName = MString

This method creates a DirectionManip and adds it to the
 MPxManipContainer 
container.'''
        pass

    def addDistanceManip(self, manipName, distanceName): 
        '''addDistanceManip(self, manipName, distanceName) -> MDagPath
Returns: Returns:
New DistanceManip

Arguments:
	[in]	manipName = MString
	[in]	distanceName = MString

This method creates a DistanceManip and adds it to the  MPxManipContainer 
container.'''
        pass

    def addPointOnSurfaceManip(self, manipName, paramName): 
        '''addPointOnSurfaceManip(self, manipName, paramName) -> MDagPath
Returns: Returns:
New PointOnSurfaceManip

Arguments:
	[in]	manipName = MString
	[in]	paramName = MString

This method creates a PointOnSurfaceManip and adds it to the
 MPxManipContainer 
container.'''
        pass

    def addCurveSegmentManip(self, manipName, startParamName, endParamName): 
        '''addCurveSegmentManip(self, manipName, startParamName, endParamName) -> MDagPath
Returns: Returns:
New CurveSegmentManip

Arguments:
	[in]	manipName = MString
	[in]	startParamName = MString
	[in]	endParamName = MString

This method creates a CurveSegmentManip and adds it to the
 MPxManipContainer 
container.'''
        pass

    def addManipToPlugConversion(self, plug): 
        '''addManipToPlugConversion(self, plug) -> int
Returns: Returns:
Index used to identify the plug inside the manipToPlugConversion()
method.

Arguments:
	[in]	plug = MPlug

This method adds a manipulator to plug converter for the
specified plug. The converter must be implemented in the  manipToPlugConversion() 
virtual method of this class.'''
        pass

    def manipToPlugConversion(self, plugIndex): 
        '''manipToPlugConversion(self, plugIndex) -> MManipData
Returns: Returns:
New plug value.

Arguments:
	[in]	plugIndex = int

This virtual method calculates and returns the requested plug
value, based upon the container's manipulator values.'''
        pass

    def createChildren(self): 
        '''createChildren(self)
This method should be overridden in user defined manipulators.
This method is called after the user node derived from  MPxManipContainer 
is set up.   Reprocessed example '''
        pass

    def doRelease(self): 
        '''doRelease(self)
This method gets called when the manipulator recieves a mouse
release event.'''
        pass

    def addRotateManip(self, manipName, rotationName): 
        '''addRotateManip(self, manipName, rotationName) -> MDagPath
Returns: Returns:
Dag path to the new rotate manipulator

Arguments:
	[in]	manipName = MString
	[in]	rotationName = MString

This method creates a rotate manipulator and adds it to the
 MPxManipContainer 
container.'''
        pass

    def doPress(self): 
        '''doPress(self)
This method gets called when the manipulator recieves a mouse
down event.'''
        pass

    def newManipulator(self, manipName, manipObject): 
        '''newManipulator(self, manipName, manipObject) -> MPxManipContainer

Arguments:
	[in]	manipName = MString
	[in]	manipObject = MObject

This static function is used to create a user-defined
manipulator. The manipObject argument is set to the new manipulator
node. Note that the manipName argument must be the name of a
manipulator derived from  MPxManipContainer .
Also note that this method creates the newManipulator, but doesn't
add it to the DAG. The primary use of this method is in conjunction
with  
MPxSelectionContext::addManipulator , to add user-defined
manipulators to a context.'''
        pass

class MPxMaterialInformation:
    '''Material information proxy.'''
    def __init__(self):
        pass


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

Tells Maya whether to this material should be displayed as a
texture, ie whether it should be baked.'''
        pass

    def fMaterialType(self): 
        '''fMaterialType(self) -> MPxMaterialInformation.MaterialType 

'''
        pass

    def textureDisconnected(self, plug): 
        '''textureDisconnected(self, plug) -> bool
Returns: Returns:
true if connection should be treated as a texture, false
otherwise

Arguments:
	[in]	plug = MPlug

Called whenever an incoming connection to the shader is
broken.'''
        pass

    def computeMaterial(self, data): 
        '''computeMaterial(self, data) -> bool
Returns: Returns:
true if valid material properties/information were created,
false otherwise

Arguments:
	[in]	data = MaterialInputData

Compute the material properties/information for the shader.
These properties are the parameters for a simple phong shading
model used for display in the viewport'''
        pass

    def materialInfoIsDirty(self, plug): 
        '''materialInfoIsDirty(self, plug) -> bool
Returns: Returns:
true if the material information is dirty, false otherwise

Arguments:
	[in]	plug = MPlug

Called by Maya to when a plug on the shader has been changed.
This method tells Maya if the material information is dirty. If it
is dirty Maya triggers a refresh of the viewport.'''
        pass

    def connectAsTexture(self, plug): 
        '''connectAsTexture(self, plug) -> bool
Returns: Returns:
true if connection should be treated as a texture, false
otherwise

Arguments:
	[in]	plug = MPlug

Called by Maya to when an incoming connection is made to plug on
the shader. This method tells Maya if connection should be treated
as a to a texture. If the connection is treated as a texture the
Maya will bake the properties of the source plug for display in the
viewport. Currently only one channel/plug on the shader can be
treated as a texture.'''
        pass

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

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

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

    class MaterialType:
        '''Non-functional class.  Values for this enum:
        kTexture
        kSimpleMaterial
        kOverrideDraw
'''
        def __init__(self):
            pass

class MPxMayaAsciiFilter:
    '''Translator to output filtered Maya ASCII files.'''
    def __init__(self):
        pass


    def writesCreateNode(self, node): 
        '''writesCreateNode(self, node) -> bool

Arguments:
	[in]	node = MObject

Determines if a "createNode" command should be written for a
particular node.'''
        pass

    def writesParentNode(self, parent, child): 
        '''writesParentNode(self, parent, child) -> bool
Returns: Returns:
bool true if the disconnectAttr should be written; false
otherwise.

Arguments:
	[in]	parent = MDagPath
	[in]	child = MDagPath

Determines if a "parent" command should be written for a
particular parent and child.'''
        pass

    def writePreCreateNodesBlock(self, filterOutput): 
        '''writePreCreateNodesBlock(self, filterOutput)
Arguments:
	[in]	filterOutput = MPxMayaAsciiFilterOutput

Allows data to be written out to the file before the create
nodes block.'''
        pass

    def writePreTrailer(self, filterOutput): 
        '''writePreTrailer(self, filterOutput)
Arguments:
	[in]	filterOutput = MPxMayaAsciiFilterOutput

Allows data to be written out to the file before the trailer
block.'''
        pass

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

Overrides  MPxFileTranslator::haveReadMethod() 
to indicate that this translator has a read method. In general this
should not be overridden.'''
        pass

    def writesConnectAttr(self, srcPlug, destPlug): 
        '''writesConnectAttr(self, srcPlug, destPlug) -> bool
Returns: Returns:
bool true if the connectAttr should be written; false
otherwise.

Arguments:
	[in]	srcPlug = MPlug
	[in]	destPlug = MPlug

Determines if a "connectAttr" command should be written for a
particular node.'''
        pass

    def writePostHeader(self, filterOutput): 
        '''writePostHeader(self, filterOutput)
Arguments:
	[in]	filterOutput = MPxMayaAsciiFilterOutput

Allows data to be written out to the file after the header
block.'''
        pass

    def file(self): 
        '''file(self) -> const MFileObject

Returns the  MFileObject 
associated with the file currently being read or written, allowing
access to the file's name, path and so on.'''
        pass

    def writesDisconnectAttr(self, srcPlug, destPlug): 
        '''writesDisconnectAttr(self, srcPlug, destPlug) -> bool
Returns: Returns:
bool true if the disconnectAttr should be written; false
otherwise.

Arguments:
	[in]	srcPlug = MPlug
	[in]	destPlug = MPlug

Determines if a "disconnectAttr" command should be written for a
particular connection.'''
        pass

    def processWriteOptions(self, optionsString): 
        '''processWriteOptions(self, optionsString)
Arguments:
	[in]	optionsString = MString

Allows the translator to handle any options passed into the
 
reader()  method, above. This call is made before the file is
actually read. The default implementation does nothing.'''
        pass

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

Determines if "requires" commands should be written in the
file.'''
        pass

    def writer(self, file, optionsString, mode): 
        '''writer(self, file, optionsString, mode)
Arguments:
	[in]	file = MFileObject
	[in]	optionsString = MString
	[in]	mode = MPxMayaAsciiFilter.FileAccessMode

Writer method for the ascii filter translator. In general this
should not be overridden, since internal Maya methods are called in
this method.'''
        pass

    def writePostCreateNodesBlock(self, filterOutput): 
        '''writePostCreateNodesBlock(self, filterOutput)
Arguments:
	[in]	filterOutput = MPxMayaAsciiFilterOutput

Allows data to be written out to the file after the create nodes
block.'''
        pass

    def writePostRequires(self, filterOutput): 
        '''writePostRequires(self, filterOutput)
Arguments:
	[in]	filterOutput = MPxMayaAsciiFilterOutput

Allows data to be written out to the file after the requires
block.'''
        pass

    def reader(self, file, optionsString, mode): 
        '''reader(self, file, optionsString, mode)
Arguments:
	[in]	file = MFileObject
	[in]	optionsString = MString
	[in]	mode = MPxMayaAsciiFilter.FileAccessMode

Reader method for the ascii filter translator. In general this
should not be overridden, since internal Maya methods are called in
this method.'''
        pass

    def writePreConnectAttrsBlock(self, filterOutput): 
        '''writePreConnectAttrsBlock(self, filterOutput)
Arguments:
	[in]	filterOutput = MPxMayaAsciiFilterOutput

Allows data to be written out to the file before the connect
attrs block.'''
        pass

    def writesSetAttr(self, srcPlug): 
        '''writesSetAttr(self, srcPlug) -> bool
Returns: Returns:
bool true if the setAttr should be written; false
otherwise.

Arguments:
	[in]	srcPlug = MPlug

Determines if a "setAttr" command should be written for a
particular node.'''
        pass

    def writesFileReference(self, referenceFile): 
        '''writesFileReference(self, referenceFile) -> bool
Returns: Returns:
bool true if the fileReference should be written; false
otherwise.

Arguments:
	[in]	referenceFile = MFileObject

Determines if a "fileReference" command should be written for a
file.'''
        pass

    def writesSelectNode(self, node): 
        '''writesSelectNode(self, node) -> bool
Returns: Returns:
bool true if the select should be written; false
otherwise.

Arguments:
	[in]	node = MObject

Determines if a "select" command should be written for a
particular node.'''
        pass

    def processReadOptions(self, optionsString): 
        '''processReadOptions(self, optionsString)
Arguments:
	[in]	optionsString = MString

Allows the translator to handle any options passed into the
 
reader()  method, above. This call is made before the file is
actually read. The default implementation does nothing.'''
        pass

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

Overrides  MPxFileTranslator::haveWriteMethod() 
to indicate that this translator has a write method. In general
this should not be overridden.'''
        pass

    def writePostConnectAttrsBlock(self, filterOutput): 
        '''writePostConnectAttrsBlock(self, filterOutput)
Arguments:
	[in]	filterOutput = MPxMayaAsciiFilterOutput

Allows data to be written out to the file after the connect
attrs block.'''
        pass

class MPxMayaAsciiFilterOutput:
    '''Wrapper for a Maya Ascii file output stream.'''
    def __init__(self):
        pass


class MPxMidiInputDevice:
    '''Midi input device.'''
    def __init__(self):
        pass


    def nameButtons(self): 
        '''nameButtons(self)
Assign names to the buttons of the device. 
  Reprocessed example '''
        pass

    def addChannel(self, channel): 
        '''addChannel(self, channel)
Arguments:
	[in]	channel = MDeviceChannel

'''
        pass

    def nameAxes(self): 
        '''nameAxes(self)
Assign names to the axes of the device. 
  Reprocessed example '''
        pass

    def doMovementEvents(self, val): 
        '''doMovementEvents(self, val)
Arguments:
	[in]	val = bool

'''
        pass

    def setNumberOfButtons(self, buttons): 
        '''setNumberOfButtons(self, buttons)
Arguments:
	[in]	buttons = int

'''
        pass

    def doButtonEvents(self, val): 
        '''doButtonEvents(self, val)
Arguments:
	[in]	val = bool

'''
        pass

    def openDevice(self): 
        '''openDevice(self)
'''
        pass

    def closeDevice(self): 
        '''closeDevice(self)
'''
        pass

    def getMessage(self, messageType, messageResponse): 
        '''getMessage(self, messageType, messageResponse) -> char*

Arguments:
	[in]	messageType = char
	[in]	messageResponse = char

'''
        pass

    def sendMessage(self, messageType, messageParams): 
        '''sendMessage(self, messageType, messageParams)
Arguments:
	[in]	messageType = char
	[in]	messageParams = char

'''
        pass

    def setNamedButton(self, buttonName, button): 
        '''setNamedButton(self, buttonName, button)
Arguments:
	[in]	buttonName = MString
	[in]	button = short

'''
        pass

    def setDegreesOfFreedom(self, freedom): 
        '''setDegreesOfFreedom(self, freedom)
Arguments:
	[in]	freedom = int

'''
        pass

    def deviceState(self): 
        '''deviceState(self) -> MDeviceState

Return the current state of the input device. 
  Reprocessed example '''
        pass

class MPxModelEditorCommand:
    '''Base class for editor creation commands.'''
    def __init__(self):
        pass


    def parser(self): 
        '''parser(self) -> MArgParser
Returns: Returns:
The argument parser

USE _parser() IN SCRIPT.'''
        pass

    def doEditFlags(self): 
        '''doEditFlags(self)
This method is called when the command is called in edit mode.
This method should be overridden by panel commands to determine
which edit flags are set in conjunction with the argument parser
for this command. The argument parser for this command can be
obtained by calling the parser method. If the command is called
with both the edit flag and the query flag, then the query flag
will be ignored.'''
        pass

    def skipFlagForCreate(self, longFlag): 
        '''skipFlagForCreate(self, longFlag) -> bool
Returns: Returns:
Return true if the flag shoiuld be skipped during
creation.

Arguments:
	[in]	longFlag = MString

Returns true if the passed long flag name should be skipped
during the creation portion of the command.'''
        pass

    def makeModelView(self): 
        '''makeModelView(self) -> MPx3dModelView
Returns: Returns:


NULL - unable to create the modelView for this
command.
pointer to modelView - modelView successfully
created.

This method is called when the modelEditor is being created and
it can be overriden to allow the user to handle the allocation of
the modelView directly. Also, as this method exists on  MPxModelEditorCommand ,
the user has direct access to the command line flags in create mode
for the command (an example use would be to detect that a
-quadbuffer flag was passed on creating the view, and you could
then bring up the panel with quadbuffering enabled).'''
        pass

    def doQueryFlags(self): 
        '''doQueryFlags(self)
This method is called when the command is called in query mode.
This method should be overridden by panel commands to determine
which query flags are set in conjunction with the argument parser
for this command. The argument parser for this command can be
obtained by calling the parser method. If the command is called
with both the edit flag and the query flag, then the query flag
will be ignored.'''
        pass

    def syntax(self): 
        '''syntax(self) -> MSyntax
Returns: Returns:
The syntax object

USE _syntax() IN SCRIPT.'''
        pass

    def editorCommandName(self): 
        '''editorCommandName(self) -> MString

Returns the name of editor command.'''
        pass

    def modelView(self): 
        '''modelView(self) -> MPx3dModelView

Returns a pointer to the  MPx3dModelView  created by this command. If the
 MPx3dModelView  was not created, NULL may be
returned.'''
        pass

    def setResult(self, result): 
        '''setResult(self, result)
Arguments:
	[out]	result = MIntArray

This method should be called when the result of the panel
command is an integer array.'''
        pass

    def appendSyntax(self): 
        '''appendSyntax(self)
This method should be overridden to append syntax to the panel
command. The syntax object can be obtained by calling the syntax
method. The following flags cannot be used as user-defined flags as
they are reserved for edit and query: "-e", "-edit", "-q",
"-query".'''
        pass

    def editorMenuScriptName(self): 
        '''editorMenuScriptName(self) -> MString

Returns the name of the script that should get executed to
construct the menu for the editor. The script should take a string
argument that holds the name of the created editor.'''
        pass

class MPxNode:
    '''Base class for user defined dependency nodes.'''
    def __init__(self):
        pass


    isHistoricallyInteresting = ''
    '''is historically interesting
attribute'''

    setMPSafe = ''
    '''USE _setMPSafe() IN SCRIPT. '''

    state = ''
    '''state attribute'''

    forceCache = ''
    '''USE _forceCache() IN SCRIPT. '''

    caching = ''
    '''caching attribute'''

    message = ''
    '''message attribute'''

    def typeId(self): 
        '''typeId(self) -> MTypeId

Returns the TYPEID of this node. The TYPEID is a four byte
identifier that uniquely identifies this type of node to the binary
file format.'''
        pass

    def addAttribute(self, attr): 
        '''addAttribute(self, attr)
Arguments:
	[in]	attr = MObject

This method adds a new attribute to a user defined node type
during the type's initialization.'''
        pass

    def connectionMade(self, plug, otherPlug, asSrc): 
        '''connectionMade(self, plug, otherPlug, asSrc)
Arguments:
	[in]	plug = MPlug
	[in]	otherPlug = MPlug
	[in]	asSrc = bool

This method gets called when connections are made to attributes
of this node.'''
        pass

    def passThroughToMany(self, plug, plugArray): 
        '''passThroughToMany(self, plug, plugArray) -> bool
Returns: Returns:
true if plug was handled, false to invoke base class
implementation

Arguments:
	[in]	plug = MPlug
	[in]	plugArray = MPlugArray

This method is overriden by nodes that want to control the
traversal behavior of some Maya search algorithms which traverse
the history/future of shape nodes looking for directly related
nodes. In particular, the Artisan paint code uses this method when
searching for paintable nodes, and the disk cache code uses this
method when searching for upstream cacheFile nodes.'''
        pass

    def typeName(self): 
        '''typeName(self) -> MString

Returns the type name of this node. The type name identifies the
node type to the ASCII file format. It may also be used with the
MEL command "createNode" to create a new node of this type.'''
        pass

    def shouldSave(self, plug, isSaving): 
        '''shouldSave(self, plug, isSaving)
Arguments:
	[in]	plug = MPlug
	[in]	isSaving = bool

This method may be overridden by the user defined node. It
should only be required to override this on rare occasions.'''
        pass

    def internalArrayCount(self, plug, ctx): 
        '''internalArrayCount(self, plug, ctx) -> int

Arguments:
	[in]	plug = MPlug
	[in]	ctx = MDGContext

This method is overriden by nodes that have internal array
attributes which are not stored in Maya's datablock. This method is
used by Maya to determine the non-sparse count of array elements
during file io. If the internal array is stored sparsely, you
should return the maximum index of the array plus one. If the
internal array is non-sparse then return the length of the
array.'''
        pass

    def kFieldNode(self):
        '''This is an enum of Type.
Description: Custom field derived from
Value: 5'''
        pass

    def kDependNode(self):
        '''This is an enum of Type.
Description: Custom node derived from
Value: 0'''
        pass

    def kObjectSet(self):
        '''This is an enum of Type.
Description: Custom set derived from
Value: 12'''
        pass

    def kParticleAttributeMapperNode(self):
        '''This is an enum of Type.
Description: Custom particle attribute mapper derived from
Value: 15'''
        pass

    def kSpringNode(self):
        '''This is an enum of Type.
Description: Custom spring derived from
Value: 7'''
        pass

    def kFluidEmitterNode(self):
        '''This is an enum of Type.
Description: Custom fluid emitter derived from MpxFluidEmitterNode.
Value: 13'''
        pass

    def kHwShaderNode(self):
        '''This is an enum of Type.
Description: Custom shader derived from
Value: 10'''
        pass

    def kImagePlaneNode(self):
        '''This is an enum of Type.
Description: Custom image plane derived from
Value: 14'''
        pass

    def kHardwareShader(self):
        '''This is an enum of Type.
Description: Custom shader derived from
Value: 9'''
        pass

    def kManipulatorNode(self):
        '''This is an enum of Type.
Description: Custom manipulator derived from
Value: 18'''
        pass

    def kConstraintNode(self):
        '''This is an enum of Type.
Description: Custom constraint derived from
Value: 17'''
        pass

    def kSurfaceShape(self):
        '''This is an enum of Type.
Description: Custom shape derived from
Value: 4'''
        pass

    def kTransformNode(self):
        '''This is an enum of Type.
Description: Custom transform derived from
Value: 11'''
        pass

    def kEmitterNode(self):
        '''This is an enum of Type.
Description: Custom emitter derived from
Value: 6'''
        pass

    def kDeformerNode(self):
        '''This is an enum of Type.
Description: Custom deformer derived from
Value: 2'''
        pass

    def kLast(self):
        '''This is an enum of Type.
Description: Last value, used for counting.
Value: 19'''
        pass

    def kIkSolverNode(self):
        '''This is an enum of Type.
Description: Custom IK solver derived from
Value: 8'''
        pass

    def kManipContainer(self):
        '''This is an enum of Type.
Description: Custom container derived from
Value: 3'''
        pass

    def kCameraSetNode(self):
        '''This is an enum of Type.
Description: Custom director derived from
Value: 16'''
        pass

    def kLocatorNode(self):
        '''This is an enum of Type.
Description: Custom locator derived from
Value: 1'''
        pass

    class Type:
        '''Non-functional class.  Values for this enum:
        kFieldNode
        kDependNode
        kObjectSet
        kParticleAttributeMapperNode
        kSpringNode
        kFluidEmitterNode
        kHwShaderNode
        kImagePlaneNode
        kHardwareShader
        kManipulatorNode
        kConstraintNode
        kSurfaceShape
        kTransformNode
        kEmitterNode
        kDeformerNode
        kLast
        kIkSolverNode
        kManipContainer
        kCameraSetNode
        kLocatorNode
'''
        def __init__(self):
            pass

    def attributeAffects(self, whenChanges, isAffected): 
        '''attributeAffects(self, whenChanges, isAffected)
Arguments:
	[in]	whenChanges = MObject
	[in]	isAffected = MObject

This method specifies that a particular input attribute affects
a specific output attribute. This is required to make evaluation
efficient. When an input changes, only the affected outputs will be
computed. Output attributes cannot be keyable - if they are
keyable, this method will fail.'''
        pass

    def setMPSafe(self, flag): 
        '''setMPSafe(self, flag)
Arguments:
	[in]	flag = bool

USE _setMPSafe() IN SCRIPT.'''
        pass

    def isPassiveOutput(self, plug): 
        '''isPassiveOutput(self, plug) -> bool
Returns: Returns:
true indicates passive

Arguments:
	[in]	plug = MPlug

This method may be overridden by the user defined node if it
wants to provide output attributes which do not prevent value
modifications to the destination attribute. For example, output
plugs on animation curve nodes are passive. This allows the
attributes driven by the animation curves to be set to new values
by the user.'''
        pass

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

Determines whether or not this node can exist without input
connections.'''
        pass

    def getInternalValueInContext(self, plug, ctx, dataHandle): 
        '''getInternalValueInContext(self, plug, ctx, dataHandle) -> bool
Returns: Returns:


true the attribute was place on the datablock
false could not handle the specified attribute, pass
this request to the default handler

Arguments:
	[in]	plug = MPlug
	[out]	dataHandle = MDataHandle
	[in]	ctx = MDGContext

This method is overriden by nodes that store attribute data in
some internal format.'''
        pass

    def setInternalValueInContext(self, plug, dataHandle, ctx): 
        '''setInternalValueInContext(self, plug, dataHandle, ctx) -> bool
Returns: Returns:


true the attribute was set
false could not handle the specified attribute, pass
this request to the default handler

Arguments:
	[in]	plug = MPlug
	[in]	dataHandle = MDataHandle
	[in]	ctx = MDGContext

This method is overriden by nodes that store attribute data in
some internal format.'''
        pass

    def passThroughToOne(self, plug): 
        '''passThroughToOne(self, plug) -> MPlug
Returns: Returns:
The corresponding plug, or an empty plug if no corresponding
plug exists

Arguments:
	[in]	plug = MPlug

This method may be overriden by nodes that have a one-to-one
relationship between an input attribute and a corresponding output
attribute. This method is used by Maya to perform the following
capabilities:'''
        pass

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

Determines whether or not this node can exist without output
connections.'''
        pass

    def postConstructor(self): 
        '''postConstructor(self)
Post constructor.'''
        pass

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

Returns the type of node that this is. This is used to
differentiate user defined nodes that are derived off different MPx
base classes.'''
        pass

    def legalConnection(self, plug, otherPlug, asSrc, isLegal): 
        '''legalConnection(self, plug, otherPlug, asSrc, isLegal)
Arguments:
	[in]	plug = MPlug
	[in]	otherPlug = MPlug
	[in]	asSrc = bool
	[in]	isLegal = bool

This method allows you to check for legal connections being made
to attributes of this node.'''
        pass

    def thisMObject(self): 
        '''thisMObject(self) -> MObject

Returns the  MObject 
associated with this user defined node. This makes it possible to
use  MFnDependencyNode  or to
construct plugs to this node's attributes.'''
        pass

    def setExistWithoutInConnections(self, flag): 
        '''setExistWithoutInConnections(self, flag)
Arguments:
	[in]	flag = bool

This method specifies whether or not the node can exist without
input connections.'''
        pass

    def setExistWithoutOutConnections(self, flag): 
        '''setExistWithoutOutConnections(self, flag)
Arguments:
	[in]	flag = bool

This method specifies whether or not the node can exist without
output connections.'''
        pass

    def forceCache(self, context): 
        '''forceCache(self, context) -> MDataBlock
Returns: Returns:
The datablock

Arguments:
	[in]	context = MDGContext

USE _forceCache() IN SCRIPT.'''
        pass

    def connectionBroken(self, plug, otherPlug, asSrc): 
        '''connectionBroken(self, plug, otherPlug, asSrc)
Arguments:
	[in]	plug = MPlug
	[in]	otherPlug = MPlug
	[in]	asSrc = bool

This method gets called when connections are broken with
attributes of this node.'''
        pass

    def setDoNotWrite(self, flag): 
        '''setDoNotWrite(self, flag)
Arguments:
	[in]	flag = bool

Use this method to mark the "do not write" state of this proxy
node. If set, this node will not be saved when the Maya model is
written out.'''
        pass

    def copyInternalData(self, node): 
        '''copyInternalData(self, node)
Arguments:
	[in]	node = MPxNode

This method is overriden by nodes that store attribute data in
some internal format.'''
        pass

    def compute(self, plug, block): 
        '''compute(self, plug, block)
Arguments:
	[in]	plug = MPlug
	[out]	block = MDataBlock

This method should be overridden in user defined nodes.'''
        pass

    def name(self): 
        '''name(self) -> MString

Returns the name of this particular instance of this class. Each
object in the dependency graph has a name. This name will be used
by the UI and by MEL.'''
        pass

    def setDependentsDirty(self, plugBeingDirtied, affectedPlugs): 
        '''setDependentsDirty(self, plugBeingDirtied, affectedPlugs)
Arguments:
	[in]	plugBeingDirtied = MPlug
	[in]	affectedPlugs = MPlugArray

This method can be overridden in user defined nodes to specify
which plugs should be set dirty based upon an input plug
{ plugBeingDirtied}  which Maya is marking dirty. The list
of plugs for Maya to mark dirty is returned by the plug array
{ affectedPlugs} . This method handles both dynamic as well
as non-dynamic plugs and is useful in the following ways:'''
        pass

    def legalDisconnection(self, plug, otherPlug, asSrc, isLegal): 
        '''legalDisconnection(self, plug, otherPlug, asSrc, isLegal)
Arguments:
	[in]	plug = MPlug
	[in]	otherPlug = MPlug
	[in]	asSrc = bool
	[out]	isLegal = bool

This method allows you to check for legal disconnections being
made to attributes of this node.'''
        pass

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

Override this class to return true if this node is an abstract
node. An abstract node can only be used as a base class. It cannot
be created using the 'createNode' command.'''
        pass

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

Use this method to query the "do not write" state of this proxy
node. True is returned if this node will not be saved when the Maya
model is written out.'''
        pass

    def inheritAttributesFrom(self, parentClassName): 
        '''inheritAttributesFrom(self, parentClassName)
Arguments:
	[in]	parentClassName = MString

This method allows a class of plugin node to inherit all of the
attributes of a second class of plugin node.'''
        pass

class MPxObjectSet:
    '''Parent class of all user defined object sets.'''
    def __init__(self):
        pass


    editPointsOnlySet = ''
    '''References to the partition nodes this set
is a member of.'''

    verticesOnlySet = ''
    '''References to the partition nodes this set
is a member of.'''

    edgesOnlySet = ''
    '''References to the partition nodes this set
is a member of.'''

    groupNodes = ''
    '''References to nodes that operate upon this
set, such as deformers.'''

    partition = ''
    '''References to the partition nodes this set
is a member of.'''

    memberWireframeColor = ''
    '''A text string to annotate the
set.'''

    facetsOnlySet = ''
    '''References to the partition nodes this set
is a member of.'''

    usedByNodes = ''
    '''References to nodes that operate upon this
set, such as deformers.'''

    DNSetMembers = ''
    '''References to dependNode attributes which
defines set membership.'''

    isLayer = ''
    '''This attribute is obsolete and should no
longer be used.'''

    dagSetMembers = ''
    '''References to dependNode attributes which
defines set membership.'''

    annotation = ''
    '''A text string to annotate the
set.'''

    renderableOnlySet = ''
    '''References to the partition nodes this set
is a member of.'''

    def editPointsOnlySet(self): 
        '''editPointsOnlySet(self) -> MPxObjectSet.MObject 

'''
        pass

    def verticesOnlySet(self): 
        '''verticesOnlySet(self) -> MPxObjectSet.MObject 

'''
        pass

    def edgesOnlySet(self): 
        '''edgesOnlySet(self) -> MPxObjectSet.MObject 

'''
        pass

    def dagSetMembers(self): 
        '''dagSetMembers(self) -> MPxObjectSet.MObject 

'''
        pass

    def groupNodes(self): 
        '''groupNodes(self) -> MPxObjectSet.MObject 

'''
        pass

    def memberWireframeColor(self): 
        '''memberWireframeColor(self) -> MPxObjectSet.MObject 

'''
        pass

    def facetsOnlySet(self): 
        '''facetsOnlySet(self) -> MPxObjectSet.MObject 

'''
        pass

    def canBeDeleted(self, isSrcNode): 
        '''canBeDeleted(self, isSrcNode) -> bool
Returns: Returns:


true Delete this node
false Do not delete this node

Arguments:
	[in]	isSrcNode = bool

A method that is called whenever a neighboring node is deleted,
to check if this node should be deleted alongside or as a result of
the neighboring node. This method will not be called in the case
where construction history is being deleted.'''
        pass

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

Returns the type of node that this is. This is used to
differentiate user defined nodes that are derived off different MPx
base classes.'''
        pass

    def renderableOnlySet(self): 
        '''renderableOnlySet(self) -> MPxObjectSet.MObject 

'''
        pass

class MPxParticleAttributeMapperNode:
    '''User defined per particle attribute mapping nodes.'''
    def __init__(self):
        pass


    outMinValue = ''
    '''The minimum limit on the output attribute
outValuePP.'''

    computeNodeColorB = ''
    '''The B component of the
computeNodeColor.'''

    outMaxValue = ''
    '''The maximum limit on the output attribute
outValuePP.'''

    computeNodeColorG = ''
    '''The G component of the
computeNodeColor.'''

    outValuePP = ''
    '''The outputValue vector per-particle
attribute.'''

    uCoordPP = ''
    '''The U component of an array of sample
positions.'''

    computeNodeColorR = ''
    '''The R component of the
computeNodeColor.'''

    vCoordPP = ''
    '''The V component of an array of sample
positions.'''

    outColorPP = ''
    '''The outputColor vector per-particle
attribute.'''

    computeNodeColor = ''
    '''This attribute allows the propagation of any
changes to the.'''

    time = ''
    '''This attribute holds the value for time (in
seconds).'''

    computeNode = ''
    '''Input node used to compute output
values.'''

    def compute(self, plug, dataBlock): 
        '''compute(self, plug, dataBlock)
Arguments:
	[in]	plug = MPlug
	[out]	dataBlock = MDataBlock

This method should be overridden in user defined nodes.'''
        pass

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

Returns the type of node that this is. This is used to
differentiate user defined nodes that are derived off different MPx
base classes.'''
        pass

class MPxPolyTrg:
    '''User defined poly triangulation support.'''
    def __init__(self):
        pass


    def postConstructor(self): 
        '''postConstructor(self)
Post constructor.'''
        pass

    def unregisterTrgFunction(self, functName): 
        '''unregisterTrgFunction(self, functName)
Arguments:
	[in]	functName = char

'''
        pass

    def registerTrgFunction(self, functName, funct): 
        '''registerTrgFunction(self, functName, funct)
Arguments:
	[in]	functName = char
	[in]	funct = polyTrgFnct

Register a triangulation function with maya. The name provided
as a first argument is the name under which the function is
registered. This name has to be used when setting 'userTrg'
attribute on a mesh.'''
        pass

    def compute(self, plug, block): 
        '''compute(self, plug, block)
Arguments:
	[in]	plug = MPlug
	[out]	block = MDataBlock

This method should be overridden in user defined nodes. However,
fror this particaular node we don't need to to do anything in the
compute functione. Therefore, all we do is return MS:kSuccess in
the derive class.'''
        pass

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

Each new node has to implement that fuction. It returns false
since this is not an abstract class.'''
        pass

class MPxPolyTweakUVCommand:
    '''Base class used for moving polygon UV's.'''
    def __init__(self):
        pass


    def getTweakedUVs(self, mesh, uvList, uPos, vPos): 
        '''getTweakedUVs(self, mesh, uvList, uPos, vPos)
Arguments:
	[in]	mesh = MObject
	[in]	uvList = MIntArray
	[out]	uPos = MFloatArray
	[out]	vPos = MFloatArray

This computes and returns modified UVs.'''
        pass

    def newSyntax(self): 
        '''newSyntax(self) -> MSyntax

This method creates and returns an  MSyntax 
object required for the poly tweak UV proxy command. 
  Reprocessed example '''
        pass

    def parseSyntax(self, argData): 
        '''parseSyntax(self, argData)
Arguments:
	[in]	argData = MArgDatabase

This method parses the additionnal flags before the command is
executed.'''
        pass

class MPxRenderPassImpl:
    '''Render pass implementation.'''
    def __init__(self):
        pass


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

Called by Maya to get the number of channels supported by this
pass'''
        pass

    def frameBufferSemantic(self): 
        '''frameBufferSemantic(self) -> MPxRenderPassImpl.PassSemantic

Called by Maya to get the frame buffer semantic. The semantic is
an enum that provides a hint on the nature of the data stored in
the frame buffer. This hint may affect how the renderer
interpolates and filters sample values.'''
        pass

    def isCompatible(self, renderer): 
        '''isCompatible(self, renderer) -> bool
Returns: Returns:
true if the implementation is compatible

Arguments:
	[in]	renderer = MString

Called by Maya check whether this pass implementation is
compatible with the given renderer.'''
        pass

    def kFloat32(self):
        '''This is an enum of PassTypeBit.
Description: single precision floating point
Value: 512'''
        pass

    def kFloat16(self):
        '''This is an enum of PassTypeBit.
Description: half precision floating point
Value: 256'''
        pass

    def kUInt32(self):
        '''This is an enum of PassTypeBit.
Description: Unsigned 32-bit integer.
Value: 4'''
        pass

    def kInt16(self):
        '''This is an enum of PassTypeBit.
Description: Signed 16-bit integer.
Value: 32'''
        pass

    def kUInt8(self):
        '''This is an enum of PassTypeBit.
Description: Unsigned 8-bit integer.
Value: 1'''
        pass

    def kOther(self):
        '''This is an enum of PassTypeBit.
Description: undefined type
Value: 4096'''
        pass

    def kInt64(self):
        '''This is an enum of PassTypeBit.
Description: Signed 64-bit integer.
Value: 128'''
        pass

    def kBit(self):
        '''This is an enum of PassTypeBit.
Description: single bit
Value: 2048'''
        pass

    def kFloat64(self):
        '''This is an enum of PassTypeBit.
Description: double precision floating point
Value: 1024'''
        pass

    def kInt32(self):
        '''This is an enum of PassTypeBit.
Description: Signed 32-bit integer.
Value: 64'''
        pass

    def kUInt64(self):
        '''This is an enum of PassTypeBit.
Description: Unsigned 64-bit integer.
Value: 8'''
        pass

    def kUInt16(self):
        '''This is an enum of PassTypeBit.
Description: Unsigned 16-bit integer.
Value: 2'''
        pass

    def kInt8(self):
        '''This is an enum of PassTypeBit.
Description: Signed 8-bit integer.
Value: 16'''
        pass

    class PassTypeBit:
        '''Non-functional class.  Values for this enum:
        kFloat32
        kFloat16
        kUInt32
        kInt16
        kUInt8
        kOther
        kInt64
        kBit
        kFloat64
        kInt32
        kUInt64
        kUInt16
        kInt8
'''
        def __init__(self):
            pass

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

Called by Maya to determine if this pass implementation supports
per-light contributions defined by pass contribution maps.'''
        pass

    def typesSupported(self): 
        '''typesSupported(self) -> MPxRenderPassImpl.PassTypeMask

Called by Maya to determine which types are supported by this
pass'''
        pass

    def kVectorSemantic(self):
        '''This is an enum of PassSemantic.
Description: General vector data (e.g. motion vectors, surface
displacements).
Value: 2'''
        pass

    def kInvalidSemantic(self):
        '''This is an enum of PassSemantic.
Description: Invalid.
Value: 0'''
        pass

    def kDirectionVectorSemantic(self):
        '''This is an enum of PassSemantic.
Description: Vectors that represent a direction (e.g. surface normals, light
directions).
Value: 3'''
        pass

    def kOtherSemantic(self):
        '''This is an enum of PassSemantic.
Description: Undefined, unknown or custom semantic.
Value: 7'''
        pass

    def kColorSemantic(self):
        '''This is an enum of PassSemantic.
Description: RGB, RGBA, alpha, luminance, etc.
Value: 1'''
        pass

    def kLabelSemantic(self):
        '''This is an enum of PassSemantic.
Description: Labels, such as material tags or object tags.
Value: 5'''
        pass

    def kDepthSemantic(self):
        '''This is an enum of PassSemantic.
Description: Depth or range data.
Value: 4'''
        pass

    def kMaskSemantic(self):
        '''This is an enum of PassSemantic.
Description: Pixel mask (e.g. a stencil buffer).
Value: 6'''
        pass

    class PassSemantic:
        '''Non-functional class.  Values for this enum:
        kVectorSemantic
        kInvalidSemantic
        kDirectionVectorSemantic
        kOtherSemantic
        kColorSemantic
        kLabelSemantic
        kDepthSemantic
        kMaskSemantic
'''
        def __init__(self):
            pass

    def getDefaultType(self): 
        '''getDefaultType(self) -> MPxRenderPassImpl.PassTypeBit

Called by Maya to determine the default type for this pass'''
        pass

class MPxSelectionContext:
    '''Base class for interative selection tools.'''
    def __init__(self):
        pass


    def lastDragPoint(self): 
        '''lastDragPoint(self) -> MPoint

USE _lastDragPoint() IN SCRIPT.'''
        pass

    def argTypeNumericalInput(self, index): 
        '''argTypeNumericalInput(self, index) -> MSyntax.MArgType
Returns: Returns:
MSyntax::kNoArg the default return
value

Arguments:
	[in]	index = int

This method is used by the feedback line to determine what units
to display. Users should override this method to return the
appropriate argument type for the given index of the numeric input
field. Specifically, this method should be overridden to return one
of the following:'''
        pass

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

USE _isSelecting() IN SCRIPT.'''
        pass

    def processNumericalInput(self, values, flags, isAbsolute): 
        '''processNumericalInput(self, values, flags, isAbsolute) -> bool
Returns: Returns:
false the default return value.

Arguments:
	[in]	values = MDoubleArray
	[in]	flags = MIntArray
	[in]	isAbsolute = bool

This method processes the input from the numerical input field.
Users can override this method if they wish to process numerical
input. For a given entry in the numeric input field, if the user
types a dot ".", this indicates that the entry should not be
modified. The overridden version of this method should take this
into account using the ignoreEntry method with the flags that are
passed in. The overridden version of this method should also
process the numeric input as an absolute input or relative input
depending on whether the isAbsolute flag is true or not. The return
value should indicate whether or not the numerical input has been
processed.'''
        pass

    def newToolCommand(self): 
        '''newToolCommand(self) -> MPxToolCommand

CALL _newToolCommand() IN SCRIPT.'''
        pass

    def setImage(self, image, index): 
        '''setImage(self, image, index)
Arguments:
	[in]	image = MString
	[in]	index = MPxSelectionContext.ImageIndex

This method is used to set an XPM icon image that is to be used
to represent this tool context in various places including the tool
bar and can be queried from mel using the contextInfo command.'''
        pass

    def image(self, index): 
        '''image(self, index) -> MString
Returns: Returns:
String name

Arguments:
	[in]	index = MPxSelectionContext.ImageIndex

This method is used to retrieve an XPM icon image that has
previously been set for this tool context. This icon image will be
used to represent this tool context in various places including the
tool bar and can be queried from mel using the contextInfo
command.'''
        pass

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

This method is called to update the numerical feedback. The
format and values for the feedback line can be set through the
methods in  MFeedbackLine , specifically setFormat and
setValue. The return value should indicate whether or not the
numerical feedback has been provided.'''
        pass

    def addManipulator(self, manipulator): 
        '''addManipulator(self, manipulator)
Arguments:
	[in]	manipulator = MObject

This method adds a manipulator to the context, and also adds the
manipulator to the DAG. Note that the manipulator should not yet be
added to the DAG when this method is called.'''
        pass

    def helpStateHasChanged(self, event): 
        '''helpStateHasChanged(self, event)
Arguments:
	[in]	event = MEvent

This method is called whenever the help state may need to be
updated. The base method does nothing and should be overriden if
the user needs to change the help information based on events.'''
        pass

    def deleteManipulators(self): 
        '''deleteManipulators(self)
This method deletes all the manipulators that belong to the
context.'''
        pass

    def abortAction(self): 
        '''abortAction(self)
'''
        pass

    def doRelease(self, event): 
        '''doRelease(self, event)
Arguments:
	[in]	event = MEvent

This method is called when any mouse button is released. The
base method does nothing except marquee selection and should be
overriden if the user needs to do anything on a button release.'''
        pass

    def doHold(self, event): 
        '''doHold(self, event)
Arguments:
	[in]	event = MEvent

This method is called when after a mouse button is pressed but
before the mouse is dragged. The base method does nothing except
marquee selection and should be overriden if the user needs to do
anything on a button hold.'''
        pass

    def doDrag(self, event): 
        '''doDrag(self, event)
Arguments:
	[in]	event = MEvent

This method is called when a mouse drag event occurs. The base
method does nothing except marquee selection and should be
overriden if the user needs to do anything during a mouse drag.'''
        pass

    def startPoint(self): 
        '''startPoint(self) -> MPoint

USE _startPoint() IN SCRIPT.'''
        pass

    def doPress(self, event): 
        '''doPress(self, event)
Arguments:
	[in]	event = MEvent

This method is called when any mouse button is pressed. The base
method does nothing and should be overriden if the user needs to do
anything on a button press.'''
        pass

class MPxSpringNode:
    '''Base class for user defined spring law.'''
    def __init__(self):
        pass


    mDeltaTime = ''
    '''delta time attribute'''

    mEnd1Weight = ''
    '''from end weight attribute'''

    mEnd2Weight = ''
    '''to end weight attribute'''

    def applySpringLaw(self, stiffness, damping, restLength, endMass1, endMass2, endP1, endP2, endV1, endV2, forceV1, forceV2): 
        '''applySpringLaw(self, stiffness, damping, restLength, endMass1, endMass2, endP1, endP2, endV1, endV2, forceV1, forceV2)
Arguments:
	[in]	stiffness = double
	[in]	damping = double
	[in]	restLength = double
	[in]	endMass1 = double
	[in]	endMass2 = double
	[in]	endP1 = MVector
	[in]	endP2 = MVector
	[in]	endV1 = MVector
	[in]	endV2 = MVector
	[in]	forceV1 = MVector
	[in]	forceV2 = MVector

This method should be overridden in user defined nodes.'''
        pass

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

This method returns the type of the node. It should not be
overridden by the user. It will return  MPxNode::kSpringNode .'''
        pass

class MPxSurfaceShape:
    '''Parent class of all user defined shapes.'''
    def __init__(self):
        pass


    instObjGroups = ''
    '''instances object group info
attribute'''

    intermediateObject = ''
    '''intermediate object attribute'''

    useObjectColor = ''
    '''controls choice of wireframe dormant object
color'''

    nodeBoundingBoxMin = ''
    '''bounding box minimum point'''

    mControlPoints = ''
    '''Control points for the derived
shapes.'''

    nodeBoundingBoxSizeX = ''
    '''X component of boundingBoxSize.'''

    worldInverseMatrix = ''
    '''inverse world matrix attribute'''

    isTemplated = ''
    '''template attribute'''

    matrix = ''
    '''matrix attribute'''

    nodeBoundingBoxSize = ''
    '''bounding box size vector'''

    objectGroupId = ''
    '''group id attribute'''

    worldMatrix = ''
    '''world matrix attribute'''

    nodeBoundingBox = ''
    '''bounding box attribute'''

    objectGrpCompList = ''
    '''component in object groups
attribute'''

    parentInverseMatrix = ''
    '''inverse parent matrix attribute'''

    objectGroups = ''
    '''object groups attributes'''

    objectGroupColor = ''
    '''group id attribute'''

    visibility = ''
    '''visibility attribute'''

    parentMatrix = ''
    '''parent matrix attribute'''

    nodeBoundingBoxMaxZ = ''
    '''Z component of boundingBoxMax.'''

    nodeBoundingBoxSizeY = ''
    '''Y component of boundingBoxSize.'''

    nodeBoundingBoxSizeZ = ''
    '''Z component of boundingBoxSize.'''

    nodeBoundingBoxMaxY = ''
    '''Y component of boundingBoxMax.'''

    nodeBoundingBoxMinX = ''
    '''X component of boundingBoxMin.'''

    nodeBoundingBoxMinY = ''
    '''Y component of boundingBoxMin.'''

    nodeBoundingBoxMinZ = ''
    '''Z component of boundingBoxMin.'''

    boundingBoxCenterZ = ''
    '''Z component of boundingBoxCenter.'''

    nodeBoundingBoxMax = ''
    '''bounding box maximum point'''

    boundingBoxCenterX = ''
    '''X component of boundingBoxCenter.'''

    boundingBoxCenterY = ''
    '''Y component of boundingBoxCenter.'''

    center = ''
    '''object center attribute'''

    nodeBoundingBoxMaxX = ''
    '''X component of boundingBoxMax.'''

    objectColor = ''
    '''the per object dormant wireframe
color'''

    inverseMatrix = ''
    '''inverse matrix attribute'''

    mControlValueZ = ''
    '''Z value of a control point.'''

    mControlValueY = ''
    '''Y value of a control point.'''

    mControlValueX = ''
    '''X value of a control point.'''

    def setRenderable(self, flag): 
        '''setRenderable(self, flag)
Arguments:
	[in]	flag = bool

Specifies whether the shape is a renderable shape. Making a
shape renderable allows the shape to have shading group
assignments.'''
        pass

    def localShapeOutAttr(self): 
        '''localShapeOutAttr(self) -> MObject

Returns the local output attribute of the shape.'''
        pass

    def acceptsGeometryIterator(self, component, writeable, forReadOnly): 
        '''acceptsGeometryIterator(self, component, writeable, forReadOnly) -> bool
Returns: Returns:


true the shape can supply an iterator
false the shape cannot supply an iterator

Arguments:
	[in]	component = MObject
	[in]	writeable = bool
	[in]	forReadOnly = bool

If the shape can supply a component iterator then then this
method should be overridden to return true. The default is to
return false. The component argument can be used to when the shape
has multiple components and not all of them can be iterator
over.'''
        pass

    def worldShapeOutAttr(self): 
        '''worldShapeOutAttr(self) -> MObject

Returns the world space output attribute of the shape.'''
        pass

    def newControlPointComponent(self): 
        '''newControlPointComponent(self) -> MObject

The default action of this method is to return an  MFnSingleIndexedComponent 
(of type  MFn::kMeshVertComponent ) in order to support
rigid skinning binds.'''
        pass

    def geometryIteratorSetup(self, componentList, components, forReadOnly): 
        '''geometryIteratorSetup(self, componentList, components, forReadOnly) -> MPxGeometryIterator
Returns: Returns:
The component match result

Arguments:
	[in]	componentList = MObjectArray
	[in]	components = MObject
	[in]	forReadOnly = bool

This method should be overridden by the user to return a
geometry iterator compatible with the user's geometry. A geometry
iterator is used for iterating over the components of a shape, such
as the vertices of a mesh, in a generic manner.'''
        pass

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

Returns true if the shape is a renderable shape. Making a shape
renderable allows the shape to have shading group assignments.'''
        pass

    def vertexOffsetDirection(self, component, direction, mode, normalize): 
        '''vertexOffsetDirection(self, component, direction, mode, normalize) -> bool

Arguments:
	[in]	component = MObject
	[in]	direction = MVectorArray
	[in]	mode = MPxSurfaceShape.MVertexOffsetMode
	[in]	normalize = bool

This method should be overridden if the shape supports
components that can be moved in the direction of the normal or UV's
using the move vertex normal tool.'''
        pass

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

This method is used to determine whether or not the shape has
active (selected) components.'''
        pass

    def kNoPointCaching(self):
        '''This is an enum of MVertexCachingMode.
Description: No point caching.
Value: 0'''
        pass

    def kUpdatePoints(self):
        '''This is an enum of MVertexCachingMode.
Description: Update the points.
Value: 3'''
        pass

    def kSavePoints(self):
        '''This is an enum of MVertexCachingMode.
Description: Points should be saved for undo in the point cache.
Value: 1'''
        pass

    def kRestorePoints(self):
        '''This is an enum of MVertexCachingMode.
Description: Points should be restored from the point cache.
Value: 2'''
        pass

    class MVertexCachingMode:
        '''Non-functional class.  Values for this enum:
        kNoPointCaching
        kUpdatePoints
        kSavePoints
        kRestorePoints
'''
        def __init__(self):
            pass

    def matchComponent(self, item, spec, list): 
        '''matchComponent(self, item, spec, list) -> MPxSurfaceShape.MatchResult
Returns: Returns:
The component match result

Arguments:
	[in]	item = MSelectionList
	[in]	spec = MAttributeSpecArray
	[in]	list = MSelectionList

This method is used to convert the string representation of a
component into a component object and to validate that the
indices.'''
        pass

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

Returns the type of node that this is. This is used to
differentiate user defined nodes that are derived off different MPx
base classes.'''
        pass

    def match(self, mask, componentList): 
        '''match(self, mask, componentList) -> bool
Returns: Returns:


true the match was successfull
false the match failed

Arguments:
	[in]	mask = MSelectionMask
	[in]	componentList = MObjectArray

This method is used to check for matches between a selection
type (or mask) and a given component. If your shape has components
representing attributes then this method is used to match up your
components with selection masks.'''
        pass

    def closestPoint(self, toThisPoint, theClosestPoint, tolerance): 
        '''closestPoint(self, toThisPoint, theClosestPoint, tolerance)
Arguments:
	[in]	toThisPoint = MPoint
	[in]	theClosestPoint = MPoint
	[in]	tolerance = double

This method is used by Maya in functions (such as select) that
require closest point information from your surface.'''
        pass

    def createFullVertexGroup(self): 
        '''createFullVertexGroup(self) -> MObject

This method is used to create a component containing every
vertex/CV in the object.'''
        pass

    def getWorldMatrix(self, block, instanceGeom): 
        '''getWorldMatrix(self, block, instanceGeom) -> MMatrix

Arguments:
	[in]	block = MDataBlock
	[in]	instanceGeom = int

Returns  MMatrix 
which takes a point from local object space to world space.'''
        pass

    def transformUsing(self, mat, componentList, cachingMode, pointCache): 
        '''transformUsing(self, mat, componentList, cachingMode, pointCache)
Arguments:
	[in]	mat = MMatrix
	[in]	componentList = MObjectArray
	[in]	cachingMode = MPxSurfaceShape.MVertexCachingMode
	[in]	pointCache = MPointArray

Transform the given components using the specified
transformation matrix. This method should be overridden if the
shape supports components that can be transformed using maya's
move, scale, and rotate tools.'''
        pass

    def geometryData(self): 
        '''geometryData(self) -> MObject

Returns the geometry data of the shape. The geometry data must
be derived from the  
MPxGeometryData  class.'''
        pass

    def deleteComponents(self, componentList, undoInfo): 
        '''deleteComponents(self, componentList, undoInfo) -> bool
Returns: Returns:
true if this method was successful, false otherwise

Arguments:
	[in]	componentList = MObjectArray
	[in]	undoInfo = MDoubleArray

This method should be overridden if the shape is to support
deletion of components. A list of components to be deleted will be
passed in as well as an array of doubles where information about
each deleted component can be stored for undo purposes. A typical
use for this array is to store knot values or weights for control
points that are deleted.'''
        pass

    def boundingBox(self): 
        '''boundingBox(self) -> MBoundingBox

This method should be overridden to return a bounding box for
the shape. If this method is overridden, then  MPxSurfaceShape::isBounded 
should also be overridden to return true.'''
        pass

    def kObjectChanged(self):
        '''This is an enum of MChildChanged.
Description: Object geometry changed. Internal caches need to be
updated.
Value: 0'''
        pass

    def kBoundingBoxChanged(self):
        '''This is an enum of MChildChanged.
Description: Object geometry is unchanged but its bounding box has changed.
This might happen if the object was moved or an offset
changed.
Value: 1'''
        pass

    class MChildChanged:
        '''Non-functional class.  Values for this enum:
        kObjectChanged
        kBoundingBoxChanged
'''
        def __init__(self):
            pass

    def localShapeInAttr(self): 
        '''localShapeInAttr(self) -> MObject

Returns the input attribute of the shape. This method will be
called by Maya to determine if the shape has construction
history.'''
        pass

    def activeComponents(self): 
        '''activeComponents(self) -> MObjectArray

Returns a list of active (selected) components for the
shape.'''
        pass

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

This method should be overridden to return true if the user
supplies a bounding box routine. Supplying a bounding box routine
makes refresh and selection more efficient.'''
        pass

    def pointAtParm(self, atThisParm, evaluatedPoint): 
        '''pointAtParm(self, atThisParm, evaluatedPoint) -> bool
Returns: Returns:
true if a point was found, false otherwise

Arguments:
	[in]	atThisParm = MPoint
	[out]	evaluatedPoint = MPoint

This method is used by Maya in functions (such as select) that
require point at parameter values. This only makes sense for
parametric surfaces such as NURBS.'''
        pass

    def componentToPlugs(self, component, list): 
        '''componentToPlugs(self, component, list)
Arguments:
	[in]	component = MObject
	[in]	list = MSelectionList

Converts the given component into a selection list of plugs.
This method is used to associate a shapes components into the
corresponding attributes (plugs) within the shape. For example, it
gets called by the translate manipulator to determine which
attributes should be driven by the manipulator, and by the
setKeyframe command to determine where to connect animCurves for
components.'''
        pass

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

    def kMatchInvalidAttributeRange(self):
        '''This is an enum of MatchResult.
Description: An attribute index was out of range.
Value: 6'''
        pass

    def kMatchNone(self):
        '''This is an enum of MatchResult.
Description: No component was matched.
Value: 1'''
        pass

    def kMatchInvalidAttribute(self):
        '''This is an enum of MatchResult.
Description: Not used.
Value: 4'''
        pass

    def kMatchInvalidAttributeIndex(self):
        '''This is an enum of MatchResult.
Description: The attribute specification contained an index for a non-array
attribute.
Value: 5'''
        pass

    def kMatchInvalidAttributeDim(self):
        '''This is an enum of MatchResult.
Description: The attribute specification provided the wrong number of
dimensions for an attribute.
Value: 7'''
        pass

    def kMatchInvalidName(self):
        '''This is an enum of MatchResult.
Description: One of the names in the attribute specification was not
valid.
Value: 3'''
        pass

    def kMatchOk(self):
        '''This is an enum of MatchResult.
Description: The component was matched without error.
Value: 0'''
        pass

    class MatchResult:
        '''Non-functional class.  Values for this enum:
        kMatchTooMany
        kMatchInvalidAttributeRange
        kMatchNone
        kMatchInvalidAttribute
        kMatchInvalidAttributeIndex
        kMatchInvalidAttributeDim
        kMatchInvalidName
        kMatchOk
'''
        def __init__(self):
            pass

    def convertToTweakNodePlug(self, plug): 
        '''convertToTweakNodePlug(self, plug) -> bool
Returns: Returns:
true if a tweak node was found, false if the plug was
unchanged

Arguments:
	[in]	plug = MPlug

Check if a tweak node is connected to this node. If it is, then
reset the supplied plug to contain the controlPoints attribute on
the tweak node.'''
        pass

    def undeleteComponents(self, componentList, undoInfo): 
        '''undeleteComponents(self, componentList, undoInfo) -> bool
Returns: Returns:
true if this method was successful, false otherwise

Arguments:
	[in]	componentList = MObjectArray
	[in]	undoInfo = MDoubleArray

This method should be overridden if the shape is to support
undeletion of components. A list of components to be deleted will
be passed in as well as an array of doubles where information about
each deleted component is stored for undo purposes. A typical use
for this array is to store knot values or weights for control
points that are deleted.'''
        pass

    def tweakUsing(self, mat, componentList, cachingMode, pointCache, handle): 
        '''tweakUsing(self, mat, componentList, cachingMode, pointCache, handle)
Arguments:
	[in]	mat = MMatrix
	[in]	componentList = MObjectArray
	[in]	cachingMode = MPxSurfaceShape.MVertexCachingMode
	[in]	pointCache = MPointArray
	[in]	handle = MArrayDataHandle

Transform the given components using the specified
transformation matrix. This method should be overridden if the
shape supports components that can be transformed using maya's
move, scale, and rotate tools. This method is called when the shape
has history & connected to a tweak node. The most common reason
why the shape would be connected to a tweak node is if it is being
deformed. When a shape is connected to a tweak node,
transformations applied to the points are placed in the tweak node
rather than in the shape itself.'''
        pass

    def childChanged(self, state): 
        '''childChanged(self, state)
Arguments:
	[in]	state = MPxSurfaceShape.MChildChanged

This method can be used to trigger the shape to recalculate its
bounding box.'''
        pass

    def kUVNTriad(self):
        '''This is an enum of MVertexOffsetMode.
Description: Calculate u, v, and normal offsets.
Value: 3'''
        pass

    def kNormal(self):
        '''This is an enum of MVertexOffsetMode.
Description: Move in normal direction.
Value: 0'''
        pass

    def kUTangent(self):
        '''This is an enum of MVertexOffsetMode.
Description: Move in u tangent direction.
Value: 1'''
        pass

    def kVTangent(self):
        '''This is an enum of MVertexOffsetMode.
Description: Move in v tangent direction.
Value: 2'''
        pass

    class MVertexOffsetMode:
        '''Non-functional class.  Values for this enum:
        kUVNTriad
        kNormal
        kUTangent
        kVTangent
'''
        def __init__(self):
            pass

    def cachedShapeAttr(self): 
        '''cachedShapeAttr(self) -> MObject

Returns the cached shape attribute of the shape.'''
        pass

class MPxSurfaceShapeUI:
    '''drawing and selection for user defined shapes'''
    def __init__(self):
        pass


    def surfaceShape(self): 
        '''surfaceShape(self) -> MPxSurfaceShape

Returns the non-ui shape associated with current instance of
this class.'''
        pass

    def getDrawData(self, geom, data): 
        '''getDrawData(self, geom, data)
Arguments:
	[in]	geom = void
	[out]	data = MDrawData

Sets up draw data for the shape. The draw data is meant to be a
light weight class which can be used to pass geometry data through
draw requests.'''
        pass

    def draw(self, request, view): 
        '''draw(self, request, view)
Arguments:
	[in]	request = MDrawRequest
	[in]	view = M3dView

This routine must be overriden if the shape is to be drawn in
the interactive display. Maya will call this routine with requests
that have been previously added to the drawing queue.'''
        pass

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

Called by Maya to determine if this surface shape supports UV
drawing.'''
        pass

    def drawUV(self, view, info): 
        '''drawUV(self, view, info)
Arguments:
	[in]	view = M3dView
	[in]	info = MTextureEditorDrawInfo

This method is called when the surface shape is selected and the
texture view is open. Users should override this method if their
custom shape supports UVs.'''
        pass

    def selectUV(self, view, selType, xmin, ymin, xmax, ymax, singleSelect, selList): 
        '''selectUV(self, view, selType, xmin, ymin, xmax, ymax, singleSelect, selList) -> bool
Returns: Returns:
true if something was selected, false
otherwise.

Arguments:
	[in]	view = M3dView
	[in]	selType = MPxSurfaceShapeUI.UVSelectionType
	[in]	xmin = int
	[in]	ymin = int
	[in]	xmax = int
	[in]	ymax = int
	[in]	singleSelect = bool
	[in]	selList = MSelectionList

This method is called when the user performs a selection within
the texture view. The method is called only when the surface shape
is member of the active selection list.'''
        pass

    def material(self, path): 
        '''material(self, path) -> MMaterial
Returns: Returns:
The material associated with this shape

Arguments:
	[in]	path = MDagPath

Returns the material associated with this shape. The user must
supply a DAG path as a shape can have several materials if
instanced.'''
        pass

    def getDrawRequests(self, objectAndActiveOnly, info, queue): 
        '''getDrawRequests(self, objectAndActiveOnly, info, queue)
Arguments:
	[out]	info = MDrawInfo
	[in]	objectAndActiveOnly = bool
	[out]	queue = MDrawRequestQueue

This routine must be overriden if the shape is to be drawn in
the interactive display. This function places drawing requests on
maya's drawing queue and is called whenever the view is refreshed
and the shape needs to be redrawn.'''
        pass

    def kSelectMeshVerts(self):
        '''This is an enum of UVSelectionType.
Description: The UV selection type is vertices.
Value: 1'''
        pass

    def kSelectMeshFaces(self):
        '''This is an enum of UVSelectionType.
Description: The UV selection type is faces.
Value: 2'''
        pass

    def kSelectMeshEdges(self):
        '''This is an enum of UVSelectionType.
Description: The UV selection type is edges.
Value: 3'''
        pass

    def kSelectMeshUVs(self):
        '''This is an enum of UVSelectionType.
Description: The UV selection type is UVs.
Value: 0'''
        pass

    class UVSelectionType:
        '''Non-functional class.  Values for this enum:
        kSelectMeshVerts
        kSelectMeshFaces
        kSelectMeshEdges
        kSelectMeshUVs
'''
        def __init__(self):
            pass

    def surfaceShapeUI(self, path): 
        '''surfaceShapeUI(self, path) -> MPxSurfaceShapeUI
Returns: Returns:
The pointer to an MPxSurfaceShapeUI
instance.

Arguments:
	[in]	path = MDagPath

This is a static method that can be used to find the
corresponding  MPxSurfaceShapeUI 
for the specified path. If an  MPxSurfaceShapeUI 
does not exist then one is created.'''
        pass

    def select(self, selectInfo, selectionList, worldSpaceSelectPts): 
        '''select(self, selectInfo, selectionList, worldSpaceSelectPts) -> bool
Returns: Returns:


true something was selected
false nothing was selected

Arguments:
	[in]	selectInfo = MSelectInfo
	[in]	selectionList = MSelectionList
	[in]	worldSpaceSelectPts = MPointArray

This routine must be overriden if the shape is to support
interactive object and/or component selection. The implementation
of this method should call selectInfo.addSelection with information
about the selected item and its selection mask. For single click
selection, detected using the selectInfo.singleSection() method,
the hit point should also be passed as an argument to
selectInfo.addSelection.'''
        pass

class MPxToolCommand:
    '''Base class for interactive tool commands.'''
    def __init__(self):
        pass


    def doIt(self, args): 
        '''doIt(self, args) -> virtual MStatus

Arguments:
	[in]	args = MArgList

This method should perform a command by setting up internal
class data and then calling the  redoIt  method. The actual
action performed by the command should be done in the  redoIt 
method. This is a pure virtual method, and must be overridden in
derived classes.'''
        pass

    def cancel(self): 
        '''cancel(self)
This method cancels the command. The user should override this
method when the original program state needs to be restored.'''
        pass

    def doFinalize(self, command): 
        '''doFinalize(self, command)
Arguments:
	[in]	command = MArgList

USE _doFinalize() IN SCRIPT.'''
        pass

    def finalize(self): 
        '''finalize(self)
This method is used to create a string representing the command
and its arguments. Users should override this method and contruct
an  MArgList  and then pass it
to  doFinalize  for journalling.'''
        pass

class MPxTransform:
    '''Base class for user defined transforms.'''
    def __init__(self):
        pass


    rotateOrder = ''
    '''Rotate order attribute.'''

    maxRotXLimitEnable = ''
    '''Enable maximum rotate X limit
attribute.'''

    intermediateObject = ''
    '''Intermediate object attribute.'''

    renderLayerColor = ''
    '''Render layer attribute.'''

    rotatePivot = ''
    '''rotate pivot attribute'''

    useObjectColor = ''
    '''Controls choice of wireframe dormant object
color.'''

    maxTransYLimit = ''
    '''Maximum translate Y limit
attribute.'''

    nodeBoundingBoxMin = ''
    '''bounding box minimum point'''

    minRotYLimit = ''
    '''Minimum rotate Y limit attribute.'''

    isTemplated = ''
    '''Template attribute.'''

    nodeBoundingBoxSize = ''
    '''bounding box size vector'''

    transMinusRotatePivot = ''
    '''translate minus rotate pivot
attribute'''

    checkAndSetShear = ''
    '''Cached '''

    rotateX = ''
    '''rotateX attribute'''

    rotateY = ''
    '''rotateY attribute'''

    rotateZ = ''
    '''rotateZ attribute'''

    nodeBoundingBox = ''
    '''bounding box attribute'''

    identification = ''
    '''Obsolete attribute.'''

    minScaleYLimitEnable = ''
    '''Enable minimum scale Y limit
attribute.'''

    translateX = ''
    '''translateX attribute'''

    translateY = ''
    '''translateY attribute'''

    translateZ = ''
    '''translateZ attribute'''

    objectGroupColor = ''
    '''Group id attribute.'''

    applyRotationLocks = ''
    '''USE _dirtyMatrix() IN SCRIPT. '''

    parentMatrix = ''
    '''Parent matrix attribute.'''

    layerRenderable = ''
    '''Obsolete attribute.'''

    scalePivotTranslate = ''
    '''Scale pivot translate attribute.'''

    renderLayerId = ''
    '''Render layer attribute.'''

    objectGroups = ''
    '''Object groups attributes.'''

    minTransLimit = ''
    '''Minumum translation limits
attribute.'''

    rotate = ''
    '''rotate attribute'''

    minRotLimit = ''
    '''Minimum rotation limits
attribute.'''

    applyTranslationLimits = ''
    '''USE _dirtyMatrix() IN SCRIPT. '''

    applyRotationLimits = ''
    '''USE _dirtyMatrix() IN SCRIPT. '''

    maxRotZLimit = ''
    '''Maximum rotate Z limit attribute.'''

    minTransXLimit = ''
    '''Minimum translate X limit
attribute.'''

    scalePivotY = ''
    '''scale pivot Y attribute'''

    scalePivotX = ''
    '''scale pivot X attribute'''

    scalePivotZ = ''
    '''scale pivot Z attribute'''

    minRotXLimit = ''
    '''Minimum rotate X limit attribute.'''

    maxScaleZLimit = ''
    '''Maximum scale Z limit attribute.'''

    rotateAxis = ''
    '''Rotate orientation attribute.'''

    maxTransZLimitEnable = ''
    '''Enable the maximum translate Z limit
attribute.'''

    dirtyRotateOrientation = ''
    '''USE _dirtyRotateOrientation() IN SCRIPT.
'''

    maxScaleXLimitEnable = ''
    '''Enable maximum scale X limit
attribute.'''

    checkAndSetScalePivotTranslation = ''
    '''Cached '''

    maxTransZLimit = ''
    '''Maximum translate Z limit
attribute.'''

    scalePivotTranslateX = ''
    '''scale pivot translate X attribute'''

    scalePivotTranslateY = ''
    '''scale pivot translate Y attribute'''

    scalePivotTranslateZ = ''
    '''scale pivot translate Z attribute'''

    minRotZLimit = ''
    '''Minimum rotate Z limit attribute.'''

    scale = ''
    '''scale attribute'''

    matrix = ''
    '''matrix attribute'''

    minRotZLimitEnable = ''
    '''Enable minimum rotate Z limit
attribute.'''

    dirtyRotatePivot = ''
    '''USE _dirtyRotatePivot() IN SCRIPT. '''

    objectGroupId = ''
    '''Group id attribute.'''

    checkAndSetScale = ''
    '''Cached '''

    applyScaleLocksPivotTranslate = ''
    '''USE _dirtyMatrix() IN SCRIPT. '''

    worldMatrix = ''
    '''world matrix attribute'''

    minScaleLimitEnable = ''
    '''Enable minimum scale limit
attribute.'''

    applyRotatePivotLocksTranslate = ''
    '''USE _dirtyMatrix() IN SCRIPT. '''

    parentInverseMatrix = ''
    '''Inverse parent matrix attribute.'''

    maxTransLimit = ''
    '''Maximum translation limits
attribute.'''

    checkAndSetRotation = ''
    '''Cached '''

    dirtyTranslation = ''
    '''USE _dirtyTranslation() IN SCRIPT. '''

    objectColor = ''
    '''The per object dormant wireframe
color.'''

    maxRotLimit = ''
    '''Maximum rotation limits
attribute.'''

    boundingBoxCenterZ = ''
    '''Z component of the bounding box
center.'''

    nodeBoundingBoxMaxZ = ''
    '''Z component of
nodeBoundingBoxMax.'''

    boundingBoxCenterX = ''
    '''X component of the bounding box
center.'''

    boundingBoxCenterY = ''
    '''Y component of the bounding box
center.'''

    minRotXLimitEnable = ''
    '''Enable minimum rotate X limit
attribute.'''

    nodeBoundingBoxMaxX = ''
    '''X component of
nodeBoundingBoxMax.'''

    minScaleZLimitEnable = ''
    '''Enable minimum scale Z limit
attribute.'''

    applyScaleLimits = ''
    '''USE _dirtyMatrix() IN SCRIPT. '''

    maxScaleYLimitEnable = ''
    '''Enable maximum scale Y limit
attribute.'''

    checkAndSetScalePivot = ''
    '''Cached '''

    checkAndSetTranslation = ''
    '''Cached '''

    applyRotatePivotLocks = ''
    '''USE _dirtyMatrix() IN SCRIPT. '''

    instObjGroups = ''
    '''Instances object group info
attribute.'''

    maxTransLimitEnable = ''
    '''Enable the maximum translation limits
attribute.'''

    minScaleXLimit = ''
    '''Minimum scale X limit attribute.'''

    dirtyMatrix = ''
    '''USE _dirtyMatrix() IN SCRIPT. '''

    maxScaleLimit = ''
    '''Maximum scale limit attribute.'''

    ghosting = ''
    '''Ghosting attribute.'''

    dirtyShear = ''
    '''USE _dirtyShear() IN SCRIPT. '''

    minTransYLimit = ''
    '''Minimum translate Y limit
attribute.'''

    shearYZ = ''
    '''shearYZ attribute'''

    maxTransXLimit = ''
    '''Maximum translate X limit
attribute.'''

    scaleX = ''
    '''scaleX attribute'''

    scaleY = ''
    '''scaleY attribute'''

    scaleZ = ''
    '''scaleZ attribute'''

    dirtyRotatePivotTranslation = ''
    '''USE _dirtyRotatePivotTranslation() IN
SCRIPT. '''

    rotatePivotTranslateX = ''
    '''rotate pivot translate X
attribute'''

    rotatePivotTranslateY = ''
    '''rotate pivot translate Y
attribute'''

    rotatePivotTranslateZ = ''
    '''rotate pivot translate Z
attribute'''

    translate = ''
    '''translate attribute'''

    objectGrpCompList = ''
    '''Component in object groups
attribute.'''

    maxRotZLimitEnable = ''
    '''Enable maximum rotate Z limit
attribute.'''

    nodeBoundingBoxMax = ''
    '''bounding box maximum point'''

    minTransZLimitEnable = ''
    '''Enable the minimum translate Z limit
attribute.'''

    visibility = ''
    '''Visibility attribute.'''

    checkAndSetRotatePivotTranslation = ''
    '''Cached '''

    layerOverrideColor = ''
    '''Obsolete attribute.'''

    minScaleZLimit = ''
    '''Minimum scale Z limit attribute.'''

    applyRotateOrientationLocks = ''
    '''USE _dirtyMatrix() IN SCRIPT. '''

    minTransXLimitEnable = ''
    '''Enable the minimum translate X limit
attribute.'''

    center = ''
    '''object center attribute'''

    checkAndSetRotatePivot = ''
    '''Cached '''

    rotateAxisY = ''
    '''rotate orientation Y attribute'''

    rotateAxisX = ''
    '''rotate orientation X attribute'''

    rotateAxisZ = ''
    '''rotate orientation Z attribute'''

    minScaleYLimit = ''
    '''Minimum scale Y limit attribute.'''

    minTransYLimitEnable = ''
    '''Enable the minimum translate Y limit
attribute.'''

    maxScaleYLimit = ''
    '''Maximum scale Y limit attribute.'''

    scalePivot = ''
    '''scale pivot attribute'''

    baseTransformationMatrix = ''
    '''Cached '''

    dirtyScalePivot = ''
    '''USE _dirtyScalePivot() IN SCRIPT. '''

    maxTransYLimitEnable = ''
    '''Enable the maximum translate Y limit
attribute.'''

    applyScaleLocksPivot = ''
    '''USE _dirtyMatrix() IN SCRIPT. '''

    worldInverseMatrix = ''
    '''Inverse world matrix attribute.'''

    minScaleLimit = ''
    '''Minimum scale limit attribute.'''

    maxScaleLimitEnable = ''
    '''Enable aximum scale limit
attribute.'''

    applyTranslationLocks = ''
    '''USE _dirtyMatrix() IN SCRIPT. '''

    checkAndSetRotateOrientation = ''
    '''Cached '''

    maxTransXLimitEnable = ''
    '''Enable the maximum translate X limit
attribute.'''

    dirtyScalePivotTranslation = ''
    '''USE _dirtyScalePivotTranslation() IN SCRIPT.
'''

    applyShearLocks = ''
    '''USE _dirtyMatrix() IN SCRIPT. '''

    transMinusRotatePivotY = ''
    '''translateY minus rotate pivotY
attribute'''

    transMinusRotatePivotX = ''
    '''translateX minus rotate pivotX
attribute'''

    maxScaleZLimitEnable = ''
    '''Enable maximum scale Z limit
attribute.'''

    transMinusRotatePivotZ = ''
    '''translateZ minus rotate pivotZ
attribute'''

    minRotYLimitEnable = ''
    '''Enable minimum rotate Y limit
attribute.'''

    maxRotXLimit = ''
    '''Maximum rotate X limit attribute.'''

    minScaleXLimitEnable = ''
    '''Enable minimum scale X limit
attribute.'''

    applyScaleLocks = ''
    '''USE _dirtyMatrix() IN SCRIPT. '''

    maxRotYLimit = ''
    '''Maximum rotate Y limit attribute.'''

    maxRotYLimitEnable = ''
    '''Enable maximum rotate Y limit
attribute.'''

    minTransZLimit = ''
    '''Minimum translate Z limit
attribute.'''

    nodeBoundingBoxSizeX = ''
    '''X component of
nodeBoundingBoxSize.'''

    nodeBoundingBoxSizeY = ''
    '''Y component of
nodeBoundingBoxSize.'''

    nodeBoundingBoxSizeZ = ''
    '''Z component of
nodeBoundingBoxSize.'''

    nodeBoundingBoxMaxY = ''
    '''Y component of
nodeBoundingBoxMax.'''

    minRotLimitEnable = ''
    '''Enable minimum rotation limits
attribute.'''

    renderInfo = ''
    '''Obsolete attribute.'''

    renderLayerInfo = ''
    '''Render layer attribute.'''

    dirtyRotation = ''
    '''USE _dirtyRotation() IN SCRIPT. '''

    nodeBoundingBoxMinX = ''
    '''X component of
nodeBoundingBoxMin.'''

    nodeBoundingBoxMinY = ''
    '''Y component of
nodeBoundingBoxMin.'''

    nodeBoundingBoxMinZ = ''
    '''Z component of
nodeBoundingBoxMin.'''

    rotatePivotY = ''
    '''rotate pivot Y attribute'''

    rotatePivotX = ''
    '''rotate pivot X attribute'''

    rotatePivotZ = ''
    '''rotate pivot Z attribute'''

    shearXY = ''
    '''shearXY attribute'''

    shearXZ = ''
    '''shearXZ attribute'''

    renderLayerRenderable = ''
    '''Render layer attribute.'''

    maxScaleXLimit = ''
    '''Maximum scale X limit attribute.'''

    maxRotLimitEnable = ''
    '''Enable maximum rotation limits
attribute.'''

    minTransLimitEnable = ''
    '''Enable the mimimum translation limits
attribute.'''

    rotatePivotTranslate = ''
    '''rotate pivot translate attribute'''

    inverseMatrix = ''
    '''inverse matrix attribute'''

    dirtyScale = ''
    '''USE _dirtyScale() IN SCRIPT. '''

    def applyRotatePivotLocks(self, toTest, savedRP): 
        '''applyRotatePivotLocks(self, toTest, savedRP) -> MVector
Returns: Returns:
The value after the locking checks are applied.

Arguments:
	[in]	toTest = MPoint
	[in]	savedRP = MPoint

This method allows the custom transform to apply its own locking
mechanism to rotation pivots. Standard dependency graph attribute
locking happens automatically and cannot be modified by custom
nodes.'''
        pass

    def getScalePivotTranslation(self, space, context): 
        '''getScalePivotTranslation(self, space, context) -> MVector
Returns: Returns:
An MVector
containing the value of the scale pivot translation in
centimeters.

Arguments:
	[in]	space = MSpace.Space
	[in]	context = MDGContext

This method returns the scale pivot translation in internal
units (centimeters). The scale pivot translation is an offset
applied to the transform to allow adjustments to the scale pivot to
be made without changing the overall transform.'''
        pass

    def rotateTo(self, euler, space, context): 
        '''rotateTo(self, euler, space, context)
Arguments:
	[in]	euler = MEulerRotation
	[in]	space = MSpace.Space
	[in]	context = MDGContext

Sets the rotation component of the transform using an euler
rotation. If the new rotation's order of rotation is different from
that of the transform it will be reordered to match the
transform.'''
        pass

    def dirtyRotateOrientation(self, savedRO): 
        '''dirtyRotateOrientation(self, savedRO)
Arguments:
	[in]	savedRO = MEulerRotation

USE _dirtyRotateOrientation() IN SCRIPT.'''
        pass

    def getRotatePivotTranslation(self, space, context): 
        '''getRotatePivotTranslation(self, space, context) -> MVector
Returns: Returns:
An MVector
containing the value of the rotate pivot translation in
centimeters.

Arguments:
	[in]	space = MSpace.Space
	[in]	context = MDGContext

This method returns the rotate pivot translation in internal
units (centimeters). The rotate pivot translation is an offset
applied to the transform to allow adjustments to the rotate pivot
to be made without changing the overall transform.'''
        pass

    def getShear(self, space, context): 
        '''getShear(self, space, context) -> MVector
Returns: Returns:
A MVector holding
the xy, xz, yz values of shear.

Arguments:
	[in]	space = MSpace.Space
	[in]	context = MDGContext

Get the shear value for this transform.'''
        pass

    def dirtyShear(self, savedSh): 
        '''dirtyShear(self, savedSh)
Arguments:
	[in]	savedSh = MVector

USE _dirtyShear() IN SCRIPT.'''
        pass

    def translateBy(self, transOffset, space, context): 
        '''translateBy(self, transOffset, space, context)
Arguments:
	[in]	transOffset = MVector
	[in]	space = MSpace.Space
	[in]	context = MDGContext

Add to the translation component by translating relative to the
existing transform. The transform value should be in internal units
(centimeters).'''
        pass

    def dirtyScalePivotTranslation(self, savedST): 
        '''dirtyScalePivotTranslation(self, savedST)
Arguments:
	[in]	savedST = MVector

USE _dirtyScalePivotTranslation() IN SCRIPT.'''
        pass

    def checkAndSetScalePivotTranslation(self, block, plug, newPT, space): 
        '''checkAndSetScalePivotTranslation(self, block, plug, newPT, space)
Arguments:
	[in]	block = MDataBlock
	[in]	plug = MPlug
	[in]	newPT = MVector
	[in]	space = MSpace.Space

This method verifies that the passed value can be set on the
scalePivotTranslate plugs. In the base class, only the locking
conditions are enforced.'''
        pass

    def applyRotateOrientationLocks(self, toTest, savedRO): 
        '''applyRotateOrientationLocks(self, toTest, savedRO) -> MEulerRotation
Returns: Returns:
The rotate orientation value after the locking checks are
applied.

Arguments:
	[in]	toTest = MEulerRotation
	[in]	savedRO = MEulerRotation

This method allows the custom transform to apply its own locking
mechanism to rotation orientation. Standard dependency graph
attribute locking happens automatically and cannot be modified by
custom nodes.'''
        pass

    def getTranslation(self, space, context): 
        '''getTranslation(self, space, context) -> MVector
Returns: Returns:
The translation MVector in
internal units (centimeters).

Arguments:
	[in]	space = MSpace.Space
	[in]	context = MDGContext

This method returns the translation component of the transform
as a  MVector  in
internal units (centimeters).'''
        pass

    def dirtyMatrix(self): 
        '''dirtyMatrix(self)
USE _dirtyMatrix() IN SCRIPT.'''
        pass

    def enableLimit(self, type, flag): 
        '''enableLimit(self, type, flag)
Arguments:
	[in]	type = MFnTransform.LimitType
	[in]	flag = bool

Enable or disable the limit value for the specified limit
type.'''
        pass

    def createTransformationMatrix(self): 
        '''createTransformationMatrix(self) -> MPxTransformationMatrix

This method returns a new transformation matrix. The function
that calls this method is responsible for deleting the
transformation matrix.'''
        pass

    def setLimit(self, type, value): 
        '''setLimit(self, type, value)
Arguments:
	[in]	type = MFnTransform.LimitType
	[in]	value = double

Change the limit value for the specified limit type, and
automatically enable the limit to be true.'''
        pass

    def scaleTo(self, newScale, space, context): 
        '''scaleTo(self, newScale, space, context)
Arguments:
	[in]	newScale = MVector
	[in]	space = MSpace.Space
	[in]	context = MDGContext

This method will set the scale of the transform to the passed
value.'''
        pass

    def setRotatePivotTranslation(self, newPT, space, context): 
        '''setRotatePivotTranslation(self, newPT, space, context)
Arguments:
	[in]	newPT = MVector
	[in]	space = MSpace.Space
	[in]	context = MDGContext

This method sets the rotate pivot translation in internal units
(centimeters). The rotate pivot translation is normally used to
automatically compensate for changes in the rotate pivot when the
 setRotatePivot() 
method is used.'''
        pass

    def applyTranslationLocks(self, toTest, savedT): 
        '''applyTranslationLocks(self, toTest, savedT) -> MVector
Returns: Returns:
The value after the locking checks are applied.

Arguments:
	[in]	toTest = MVector
	[in]	savedT = MVector

This method allows the custom transform to apply its own locking
mechanism to translation. Standard dependency graph attribute
locking happens automatically and cannot be modified by custom
nodes.'''
        pass

    def getMatrixInverse(self, context): 
        '''getMatrixInverse(self, context) -> MMatrix
Returns: Returns:
The inverse of the transform as a MMatrix.

Arguments:
	[in]	context = MDGContext

This method returns the inverse of the 4x4 matrix that describes
this transformation.'''
        pass

    def translateTo(self, newTrans, space, context): 
        '''translateTo(self, newTrans, space, context)
Arguments:
	[in]	newTrans = MVector
	[in]	space = MSpace.Space
	[in]	context = MDGContext

Set the translation component of the transform in
centimeters.'''
        pass

    def setScalePivot(self, newSP, space, balance, context): 
        '''setScalePivot(self, newSP, space, balance, context)
Arguments:
	[in]	newSP = MPoint
	[in]	space = MSpace.Space
	[in]	balance = bool
	[in]	context = MDGContext

This method sets the position of the scale pivot. The position
of the pivot is defined as a  MPoint 
in internal units (centimeters).'''
        pass

    def getRotatePivot(self, space, context): 
        '''getRotatePivot(self, space, context) -> MPoint

Arguments:
	[in]	space = MSpace.Space
	[in]	context = MDGContext

This method returns the position of the pivot used by the rotate
component of the transform. The position is represented in internal
units (centimeters).'''
        pass

    def applyShearLocks(self, toTest, savedS): 
        '''applyShearLocks(self, toTest, savedS) -> MVector
Returns: Returns:
The shear value after the locking checks are applied.

Arguments:
	[in]	toTest = MVector
	[in]	savedS = MVector

This method allows the custom transform to apply its own locking
mechanism to shear. Standard dependency graph attribute locking
happens automatically and cannot be modified by custom nodes.'''
        pass

    def shearBy(self, shearOffset, space, context): 
        '''shearBy(self, shearOffset, space, context)
Arguments:
	[in]	shearOffset = MVector
	[in]	space = MSpace.Space
	[in]	context = MDGContext

This method will apply a relative shear to the existing
shear.'''
        pass

    def updateMatrixAttrs(self, attr, context): 
        '''updateMatrixAttrs(self, attr, context)
Arguments:
	[in]	attr = MObject
	[in]	context = MDGContext

This method ensures that a passed attribute will have its values
current.'''
        pass

    def dirtyRotatePivot(self, savedRP): 
        '''dirtyRotatePivot(self, savedRP)
Arguments:
	[in]	savedRP = MPoint

USE _dirtyRotatePivot() IN SCRIPT.'''
        pass

    def checkAndSetShear(self, block, plug, newS, space): 
        '''checkAndSetShear(self, block, plug, newS, space)
Arguments:
	[in]	block = MDataBlock
	[in]	plug = MPlug
	[in]	newS = MVector
	[in]	space = MSpace.Space

This method verifies that the passed value can be set on the
shear plugs. In the base class, only the locking conditions are
enforced.'''
        pass

    def resetTransformation(self, xform): 
        '''resetTransformation(self, xform)
Arguments:
	[in]	xform = MPxTransformationMatrix

This method will reset the transformation matrix to the one
specified by the passed transformation matrix pointer. The contents
of the passed transformation matrix are copied into this class's
transformation matrix.'''
        pass

    def dirtyRotatePivotTranslation(self, savedRT): 
        '''dirtyRotatePivotTranslation(self, savedRT)
Arguments:
	[in]	savedRT = MVector

USE _dirtyRotatePivotTranslation() IN SCRIPT.'''
        pass

    def applyScaleLocksPivotTranslate(self, toTest, savedSPT): 
        '''applyScaleLocksPivotTranslate(self, toTest, savedSPT) -> MVector
Returns: Returns:
The value after the locking checks are applied.

Arguments:
	[in]	toTest = MVector
	[in]	savedSPT = MVector

This method allows the custom transform to apply its own locking
mechanism to the scalePivotTranslate attribute. Standard dependency
graph attribute locking happens automatically and cannot be
modified by custom nodes.'''
        pass

    def isNonAffineMatricesEnabled(self): 
        '''isNonAffineMatricesEnabled(self) -> bool
Returns: Returns:
true if non-affine matrix calculations are enabled.

This method returns true is non-affine matrix calculations are
being used for transforms.'''
        pass

    def rotateBy(self, euler, space, context): 
        '''rotateBy(self, euler, space, context)
Arguments:
	[in]	euler = MEulerRotation
	[in]	space = MSpace.Space
	[in]	context = MDGContext

Adds to the rotation component of the transform by rotating
relative to the existing transform using a euler rotation. The only
valid transformation spaces for this method are  MSpace::kTransform 
and  MSpace::kPreTransform /MSpacekObject.
All other spaces are treated as being equivalent to  MSpace::kTransform .
If the supplied rotation's order of rotation is different from that
of the transform, it will be reordered to match the transform
before being added in.'''
        pass

    def getScalePivot(self, space, context): 
        '''getScalePivot(self, space, context) -> MPoint
Returns: Returns:
A MPoint given the position of the
scale pivot in centimeters.

Arguments:
	[in]	space = MSpace.Space
	[in]	context = MDGContext

This method returns the position of the pivot used by the scale
component of the transform. The position is represented in internal
units (centimeters).'''
        pass

    def checkAndSetRotatePivotTranslation(self, block, plug, newPT, space): 
        '''checkAndSetRotatePivotTranslation(self, block, plug, newPT, space)
Arguments:
	[in]	block = MDataBlock
	[in]	plug = MPlug
	[in]	newPT = MVector
	[in]	space = MSpace.Space

This method verifies that the passed value can be set on the
rotatePivotTranslate plugs. In the base class, only the locking
conditions are enforced.'''
        pass

    def postConstructor(self): 
        '''postConstructor(self)
Post constructor.'''
        pass

    def limitValue(self, type): 
        '''limitValue(self, type) -> double
Returns: Returns:
Returns the current value of the specified limit in internal
units as a double.

Arguments:
	[in]	type = MFnTransform.LimitType

Returns the current value of the specified limit in internal
units as a double.'''
        pass

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

This method returns the type of the node. This method should not
be overridden by the user. It will return  MPxNode::kTransformNode .'''
        pass

    def checkAndSetRotatePivot(self, block, plug, newRP, space, balance): 
        '''checkAndSetRotatePivot(self, block, plug, newRP, space, balance)
Arguments:
	[in]	block = MDataBlock
	[in]	plug = MPlug
	[in]	newRP = MPoint
	[in]	space = MSpace.Space
	[in]	balance = bool

This method verifies that the passed value can be set on the
rotatePivot plugs. In the base class, only the locking conditions
are enforced. This method will also update the rotatePivotTranslate
value if balance is true.'''
        pass

    def setScalePivotTranslation(self, newPT, space, context): 
        '''setScalePivotTranslation(self, newPT, space, context)
Arguments:
	[in]	newPT = MVector
	[in]	space = MSpace.Space
	[in]	context = MDGContext

This method sets the scale pivot translation in internal units
(centimeters). The scale pivot translation is normally used to
automatically compensate for changes in the scale pivot when the
 setScalePivot() 
method is used.'''
        pass

    def getRotateOrientation(self, space, context): 
        '''getRotateOrientation(self, space, context) -> MQuaternion
Returns: Returns:
A MQuaternion representing the rotate
orientation.

Arguments:
	[in]	space = MSpace.Space
	[in]	context = MDGContext

Returns the rotate orientation for the transformation matrix as
a quaternion. The rotate orientation is the value associated with
the rotateAxis attribute on this node. The rotate orientation value
is used to orient the local rotation space of the transform.'''
        pass

    def checkAndSetScale(self, block, plug, newS, space): 
        '''checkAndSetScale(self, block, plug, newS, space)
Arguments:
	[in]	block = MDataBlock
	[in]	plug = MPlug
	[in]	newS = MVector
	[in]	space = MSpace.Space

This method verifies that the passed value can be set on the
scale plugs. In the base class, limits as well as locking are
checked by this method.'''
        pass

    def transformationMatrix(self): 
        '''transformationMatrix(self) -> const MPxTransformationMatrix

This method returns a reference to the transformation matrix
used by this transform.'''
        pass

    def applyScaleLocks(self, toTest, savedS): 
        '''applyScaleLocks(self, toTest, savedS) -> MVector
Returns: Returns:
The scale value after the locking checks are applied.

Arguments:
	[in]	toTest = MVector
	[in]	savedS = MVector

This method allows the custom transform to apply its own locking
mechanism to scale. Standard dependency graph attribute locking
happens automatically and cannot be modified by custom nodes.'''
        pass

    def shearTo(self, newShear, space, context): 
        '''shearTo(self, newShear, space, context)
Arguments:
	[in]	newShear = MVector
	[in]	space = MSpace.Space
	[in]	context = MDGContext

The method sets the shear component of the transform.'''
        pass

    def setRotatePivot(self, newRP, space, balance, context): 
        '''setRotatePivot(self, newRP, space, balance, context)
Arguments:
	[in]	newRP = MPoint
	[in]	space = MSpace.Space
	[in]	balance = bool
	[in]	context = MDGContext

This method sets the position of the rotate pivot. The position
of the pivot is defined as a  MPoint 
in internal units (centimeters).'''
        pass

    def applyRotatePivotLocksTranslate(self, toTest, savedRPT): 
        '''applyRotatePivotLocksTranslate(self, toTest, savedRPT) -> MVector
Returns: Returns:
The value after the locking checks are applied.

Arguments:
	[in]	toTest = MVector
	[in]	savedRPT = MVector

This method allows the custom transform to apply its own locking
mechanism to the rotatePivotTranslate attribute. Standard
dependency graph attribute locking happens automatically and cannot
be modified by custom nodes.'''
        pass

    def applyRotationLocks(self, toTest, savedR): 
        '''applyRotationLocks(self, toTest, savedR) -> MEulerRotation
Returns: Returns:
The value after the locking checks are applied.

Arguments:
	[in]	toTest = MEulerRotation
	[in]	savedR = MEulerRotation

This method allows the custom transform to apply its own locking
mechanism to rotation. Standard dependency graph attribute locking
happens automatically and cannot be modified by custom nodes.'''
        pass

    def validateAndSetValue(self, plug, handle, context): 
        '''validateAndSetValue(self, plug, handle, context)
Arguments:
	[in]	plug = MPlug
	[in]	handle = MDataHandle
	[in]	context = MDGContext

When a plug's value is set, and the plug is on a default
transform attribute, or has been flagged by the  mustCallValidateAndSet() 
method, then this method will be called. The purpose of  validateAndSetValue() 
is to enforce limits, constraints, or plug value locking.'''
        pass

    def dirtyRotation(self, savedR): 
        '''dirtyRotation(self, savedR)
Arguments:
	[in]	savedR = MEulerRotation

USE _dirtyRotation() IN SCRIPT.'''
        pass

    def checkAndSetRotation(self, block, plug, newR, space): 
        '''checkAndSetRotation(self, block, plug, newR, space)
Arguments:
	[in]	block = MDataBlock
	[in]	plug = MPlug
	[in]	newR = MEulerRotation
	[in]	space = MSpace.Space

This method verifies that the passed value can be set on the
rotate plugs. In the base class, limits as well as locking are
checked by this method.'''
        pass

    def dirtyTranslation(self, savedT): 
        '''dirtyTranslation(self, savedT)
Arguments:
	[in]	savedT = MVector

USE _dirtyTranslation() IN SCRIPT.'''
        pass

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

Maya's base transform node type is treated differently from node
types which are derived from it. For example, the 'viewFit' command
does not include transform nodes in its calculations but does
include pointConstraint nodes which are derived from the transform
node.'''
        pass

    def boundingBox(self): 
        '''boundingBox(self) -> MBoundingBox

This method should be overridden to return a bounding box for
the transform. If this method is overridden, then  MPxTransform::isBounded 
should also be overridden to return true.'''
        pass

    def transformationMatrixPtr(self): 
        '''transformationMatrixPtr(self) -> MPxTransformationMatrix

'''
        pass

    def getScale(self, space, context): 
        '''getScale(self, space, context) -> MVector
Returns: Returns:
A MVector holding
the x, y, and z scale components

Arguments:
	[in]	space = MSpace.Space
	[in]	context = MDGContext

Returns the scale component of the transform. If the space is
invalid a <1.0, 1.0, 1.0> vector is returned.'''
        pass

    def mustCallValidateAndSet(self, obj): 
        '''mustCallValidateAndSet(self, obj)
Arguments:
	[in]	obj = MObject

This method must be called in the initialize() method for all
attributes that affect the matrix of the transform. It will ensure
that the matrix is properly calculated when the passed attribute is
changed and that the validateAndSetValue method will get called for
this attribute.'''
        pass

    def getMatrix(self, context): 
        '''getMatrix(self, context) -> MMatrix
Returns: Returns:
The transform as a MMatrix.

Arguments:
	[in]	context = MDGContext

This method returns a 4x4 matrix that is produced by applying
all of the components of the transform.'''
        pass

    def applyScaleLocksPivot(self, toTest, savedSP): 
        '''applyScaleLocksPivot(self, toTest, savedSP) -> MVector
Returns: Returns:
The scale pivot value after the locking checks are
applied.

Arguments:
	[in]	toTest = MPoint
	[in]	savedSP = MPoint

This method allows the custom transform to apply its own locking
mechanism to scale pivot. Standard dependency graph attribute
locking happens automatically and cannot be modified by custom
nodes.'''
        pass

    def copyInternalData(self, node): 
        '''copyInternalData(self, node)
Arguments:
	[in]	node = MPxNode

This function copies the internal data of the transform
node.'''
        pass

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

This method should be overridden to return true if the user
supplies a bounding box routine. Supplying a bounding box routine
makes refresh and selection more efficient.'''
        pass

    def compute(self, plug, block): 
        '''compute(self, plug, block)
Arguments:
	[in]	plug = MPlug
	[in]	block = MDataBlock

The transform's compute method. The compute method should call
any supporting methods to proper handle limits as well as the cases
where the plug's value should not change. The  MPlug::isFreeToChange() 
method is used to determine if a plug's value may be changed.'''
        pass

    def checkAndSetRotateOrientation(self, block, plug, newRO, space, balance): 
        '''checkAndSetRotateOrientation(self, block, plug, newRO, space, balance)
Arguments:
	[in]	block = MDataBlock
	[in]	plug = MPlug
	[in]	newRO = MEulerRotation
	[in]	space = MSpace.Space
	[in]	balance = bool

This method verifies that the passed value can be set on the
rotateAxis plugs. In the base class, only the locking conditions
are enforced. This method will also update the rotation value if
balance is true.'''
        pass

    def getRotationOrder(self, context): 
        '''getRotationOrder(self, context) -> MTransformationMatrix.RotationOrder
Returns: Returns:
The MTransformationMatrix::RotationOrder
enum describing the rotation order of the transform.

Arguments:
	[in]	context = MDGContext

Returns the rotation order used by the rotation component of the
transformation matrix.'''
        pass

    def dirtyScalePivot(self, savedSP): 
        '''dirtyScalePivot(self, savedSP)
Arguments:
	[in]	savedSP = MPoint

USE _dirtyScalePivot() IN SCRIPT.'''
        pass

    def checkAndSetTranslation(self, block, plug, newT, space): 
        '''checkAndSetTranslation(self, block, plug, newT, space)
Arguments:
	[in]	block = MDataBlock
	[in]	plug = MPlug
	[in]	newT = MVector
	[in]	space = MSpace.Space

This method is used to modify and set the new translate values
being passed in from the compute method or from the
validateAndSetValue. The data block should be set with the
corrected values. Corrections would come from enforcing any active
limits as well as verifying that the plug's value may be changed.
If the plug is locked or if it is the destination in a connection
that disallows value changes, then the plug will be set to its
unchanged value.'''
        pass

    def setNonAffineMatricesEnabled(self, enabled): 
        '''setNonAffineMatricesEnabled(self, enabled)
Arguments:
	[in]	enabled = bool

Normal Maya transforms consist of translate, rotate, scale, and
shear. All of these transform types produce an affine matrix. With
 MPxTransform  it is
possible to introduce non-affine matrices into places that
previously did not consider their effects.'''
        pass

    def scaleBy(self, scaleOffset, space, context): 
        '''scaleBy(self, scaleOffset, space, context)
Arguments:
	[in]	scaleOffset = MVector
	[in]	space = MSpace.Space
	[in]	context = MDGContext

This method will apply a relative scale to an existing
scale.'''
        pass

    def applyTranslationLimits(self, unlimitedT, block): 
        '''applyTranslationLimits(self, unlimitedT, block) -> MVector
Returns: Returns:
The limited translation value.

Arguments:
	[in]	unlimitedT = MVector
	[in]	block = MDataBlock

This method returns a copy of the passed translation value with
its members limited by any enabled translation limits on this
node.'''
        pass

    def applyRotationLimits(self, unlimitedR, block): 
        '''applyRotationLimits(self, unlimitedR, block) -> MEulerRotation
Returns: Returns:
A MEulerRotation with limits applied to
it.

Arguments:
	[in]	unlimitedR = MEulerRotation
	[in]	block = MDataBlock

This method returns a copy of the passed rotation value with its
members limited by any enabled rotation limits on this node.'''
        pass

    def clearLimits(self): 
        '''clearLimits(self)
This method turns off all of the limits and sets them to their
default values. Before this method is called, the base class clears
all of the limits on the standard transform attributes, so this
method only needs to be implemented for custom transform
attributes.'''
        pass

    def getEulerRotation(self, space, context): 
        '''getEulerRotation(self, space, context) -> MEulerRotation
Returns: Returns:
The rotation component of the transform as an euler
rotation.

Arguments:
	[in]	space = MSpace.Space
	[in]	context = MDGContext

Returns the rotation component of the transform as a euler
rotation. The rotation is returned in  MSpace::kTransform 
space. If an invalid space is used,  MEulerRotation::identity 
will be returned.'''
        pass

    def isLimited(self, type): 
        '''isLimited(self, type) -> bool
Returns: Returns:
Returns true if the limit is enabled, otherwise false is
returned.

Arguments:
	[in]	type = MFnTransform.LimitType

Determine if the specified limit attribute is enabled or
disabled.'''
        pass

    def setRotateOrientation(self, newRO, space, balance, context): 
        '''setRotateOrientation(self, newRO, space, balance, context)
Arguments:
	[in]	newRO = MQuaternion
	[in]	space = MSpace.Space
	[in]	balance = bool
	[in]	context = MDGContext

This method sets the rotate orientation for this transform. The
rotate orientation is used to define the local rotation space. The
rotate orientation is the value associated with the rotateAxis
attribute on this node.'''
        pass

    def checkAndSetScalePivot(self, block, plug, newSP, space, balance): 
        '''checkAndSetScalePivot(self, block, plug, newSP, space, balance)
Arguments:
	[in]	block = MDataBlock
	[in]	plug = MPlug
	[in]	newSP = MPoint
	[in]	space = MSpace.Space
	[in]	balance = bool

This method verifies that the passed value can be set on the
scalePivot plugs. In the base class, only the locking conditions
are enforced. This method will also update the scalePivotTranslate
value if balance is true.'''
        pass

    def setRotationOrder(self, ro, reorder, context): 
        '''setRotationOrder(self, ro, reorder, context)
Arguments:
	[in]	ro = MTransformationMatrix.RotationOrder
	[in]	reorder = bool
	[in]	context = MDGContext

Sets the rotation order used by the rotation component of the
transformation matrix.'''
        pass

    def dirtyScale(self, savedS): 
        '''dirtyScale(self, savedS)
Arguments:
	[in]	savedS = MVector

USE _dirtyScale() IN SCRIPT.'''
        pass

    def computeLocalTransformation(self, block, xform): 
        '''computeLocalTransformation(self, block, xform)
Arguments:
	[out]	xform = MPxTransformationMatrix
	[in]	block = MDataBlock

This method computes the transformation matrix for a passed data
block and places the output into a passed transformation
matrix.'''
        pass

    def applyScaleLimits(self, unlimitedS, block): 
        '''applyScaleLimits(self, unlimitedS, block) -> MVector
Returns: Returns:
The scale value with limits applied.

Arguments:
	[in]	unlimitedS = MVector
	[in]	block = MDataBlock

This method returns a copy of the passed scale value with its
members limited by any enabled scale limits on this node.'''
        pass

    def getRotation(self, space, context): 
        '''getRotation(self, space, context) -> MQuaternion
Returns: Returns:
The rotate component of the transform as a quaternion.

Arguments:
	[in]	space = MSpace.Space
	[in]	context = MDGContext

This method returns the rotation of the transform as a
quaternion. The rotation is returned in  MSpace::kTransform 
space. If an invalid space is used,  MQuaternion::identity  will be
returned.'''
        pass

class MPxTransformationMatrix:
    '''Base class of all user defined transformation matrices.'''
    def __init__(self):
        pass


    rotatePivotTranslationValue = ''
    '''Translation to compensate for movement of
the rotate pivot.'''

    scalePivotValue = ''
    '''Position of pivot used for
scaling.'''

    rotateOrientationValue = ''
    '''Orientation of the local rotation
space.'''

   

    baseTransformationMatrixId = ''
    '''Type id for the default '''

    translationValue = ''
    '''Translation component of
transformation.'''

    scaleValue = ''
    '''Scale component of
transformation.'''

    rotatePivotValue = ''
    '''Position of pivot used for
rotation.'''

    rotationValue = ''
    '''Rotation component of
transformation.'''

    shearValue = ''
    '''Shear component of
transformation.'''

    scalePivotTranslationValue = ''
    '''Translation to compensate for movement of
the scale pivot.'''

    identity = ''
    '''The identity transformation
matrix.'''

    decomposeMatrix = ''
    '''Scale component of
transformation.'''

    def typeId(self): 
        '''typeId(self) -> MTypeId

Returns the  MTypeId  of this
transformation matrix. The  MTypeId  is a four byte
identifier that uniquely identifies this type of transformation
matrix.'''
        pass

    def asInterpolationMatrix(self, toM, percent, rot, direction): 
        '''asInterpolationMatrix(self, toM, percent, rot, direction) -> MMatrix
Returns: Returns:
The interpolated matrix.

Arguments:
	[in]	toM = MTransformationMatrix
	[in]	percent = double
	[in]	rot = bool
	[in]	direction = int

Returns a matrix that represents the specified percentage of
this transformation matrix. The two matrices involved in the
interpolation are this transformation matrix and the passed
transformation matrix, toMatrix.'''
        pass

    def asTransformationMatrix(self): 
        '''asTransformationMatrix(self) -> MTransformationMatrix

Returns the custom transformation matrix as a standard  MTransformationMatrix .'''
        pass

    def creator(self): 
        '''creator(self) -> MPxTransformationMatrix

A method to use when registering a custom transform that uses a
default  MPxTransformationMatrix .'''
        pass

    def translateBy(self, t, space): 
        '''translateBy(self, t, space)
Arguments:
	[in]	t = MVector
	[in]	space = MSpace.Space

Add to the translate component by translating relative to the
existing transformation. The relative translate should be in
centimeters.'''
        pass

    def setRotateOrientation(self, euler, space, balance): 
        '''setRotateOrientation(self, euler, space, balance)
Arguments:
	[in]	euler = MEulerRotation
	[in]	space = MSpace.Space
	[in]	balance = bool

Sets the rotate orientation for the transformation matrix to the
passed quaternion. The rotate orientation is the rotation that
orients the local rotation space.'''
        pass

    def rotateTo(self, euler, space): 
        '''rotateTo(self, euler, space)
Arguments:
	[in]	euler = MEulerRotation
	[in]	space = MSpace.Space

Sets the rotation component of the transformation matrix using
an euler rotation.'''
        pass

    def scalePivot(self, space): 
        '''scalePivot(self, space) -> MPoint
Returns: Returns:
The scale pivot point.

Arguments:
	[in]	space = MSpace.Space

Returns the pivot used by the scale. The value is in
centimeters.'''
        pass

    def scaleTo(self, newScale, space): 
        '''scaleTo(self, newScale, space)
Arguments:
	[in]	newScale = MVector
	[in]	space = MSpace.Space

Set the scale component of the transformation matrix. If an
invalid space is passed, the scale will not be changed.'''
        pass

    def rotation(self, space): 
        '''rotation(self, space) -> MQuaternion
Returns: Returns:
The quaternion that is the rotation component of the
transformation matrix

Arguments:
	[in]	space = MSpace.Space

Returns the rotation component of the transformation matrix as a
quaternion. If an invalid space is used,  MQuaternion::identity  will be
returned.'''
        pass

    def __neq__(self, rhs): 
        '''__neq__(self, rhs) -> bool
Returns: Returns:
Boolean value: true The matrices are not identical,
false otherwise.

Arguments:
	[in]	rhs = MMatrix

Equality operator.'''
        pass

    def translateTo(self, t, space): 
        '''translateTo(self, t, space)
Arguments:
	[in]	t = MVector
	[in]	space = MSpace.Space

Sets the translate component of the transformation matrix in
centimeters.'''
        pass

    def scale(self, space): 
        '''scale(self, space) -> MVector
Returns: Returns:
Vector holding the x, y, and z scale components

Arguments:
	[in]	space = MSpace.Space

Returns the scale component of the transformation matrix. If the
space is invalid a  MVector  with all
of its components being 1.0 is returned.'''
        pass

    def shearBy(self, shearOffset, space): 
        '''shearBy(self, shearOffset, space)
Arguments:
	[in]	shearOffset = MVector
	[in]	space = MSpace.Space

Apply a new shear to the existing shear component of the
transformation matrix. The shear values are added by multiplying
the individual shear components with the offset values.'''
        pass

    def asMatrixInverse(self): 
        '''asMatrixInverse(self) -> MMatrix

Returns the inverse of the four by four matrix that describes
this transformation.'''
        pass

    def shearTo(self, newShear, space): 
        '''shearTo(self, newShear, space)
Arguments:
	[in]	newShear = MVector
	[in]	space = MSpace.Space

Sets the shear component of the transformation matrix.'''
        pass

    def rotatePivot(self, space): 
        '''rotatePivot(self, space) -> MPoint
Returns: Returns:
The rotation pivot point.

Arguments:
	[in]	space = MSpace.Space

Returns the pivot used by the rotation.'''
        pass

    def setRotatePivotTranslation(self, v, space): 
        '''setRotatePivotTranslation(self, v, space)
Arguments:
	[in]	v = MVector
	[in]	space = MSpace.Space

Set the rotate pivot translation. When the scale pivot is
changed, there is an option to automatically compensate for the
change so that the overall transformation is not altered. The
compensating factor is the rotate pivot translation.'''
        pass

    def rotatePivotTranslation(self, space): 
        '''rotatePivotTranslation(self, space) -> MVector
Returns: Returns:
The rotate pivot translation.

Arguments:
	[in]	space = MSpace.Space

Returns the rotate pivot translation, which is used to
compensate for changes of the rotate pivot.'''
        pass

    def unSquishMatrix(self): 
        '''unSquishMatrix(self) -> MMatrix

Remove any shearing and any non-proportional scaling. If the
scaling is non-proportional, then the maximum scale of the three
scale axes will be used on all of the scale axes. The method
creates a new 4x4  MMatrix  and
leaves this transformation matrix unchanged.'''
        pass

    def rotateBy(self, euler, space): 
        '''rotateBy(self, euler, space)
Arguments:
	[in]	euler = MEulerRotation
	[in]	space = MSpace.Space

Rotates relative to the current rotation value of the
transformation matrix. By default, the only valid transformation
spaces for this method are  MSpace::kTransform 
and  MSpace::kPreTransform .
All other spaces are treated as being equivalent to  MSpace::kTransform .'''
        pass

    def asScaleMatrix(self): 
        '''asScaleMatrix(self) -> MMatrix

Returns scale matrix. The scale matrix takes points from object
space to the space immediately following scale and shear
transformations.'''
        pass

    def asMatrix(self, percent): 
        '''asMatrix(self, percent) -> MMatrix

Arguments:
	[in]	percent = double

Returns a matrix that represents the specified percentage of
this transformation matrix. This is performed on a component
basis.'''
        pass

    def eulerRotateOrientation(self, space): 
        '''eulerRotateOrientation(self, space) -> MEulerRotation
Returns: Returns:
The rotate orientation as an euler angle.

Arguments:
	[in]	space = MSpace.Space

Returns the rotate orientation for the transformation matrix as
an euler rotation. The rotate orientation orients the local
rotation space.'''
        pass

    def setScalePivotTranslation(self, v, space): 
        '''setScalePivotTranslation(self, v, space)
Arguments:
	[in]	v = MVector
	[in]	space = MSpace.Space

Set the scale pivot translation. When the scale pivot is
changed, there is an option to automatically compensate for the
change so that the overall transformation is not altered. The
compensating factor is the scale pivot translation.'''
        pass

    def convertTransformationRotationOrder(self, xformOrder): 
        '''convertTransformationRotationOrder(self, xformOrder) -> MEulerRotation.RotationOrder
Returns: Returns:
The corresponding MEulerRotation::RotationOrder.

Arguments:
	[in]	xformOrder = MTransformationMatrix.RotationOrder

Convert from  MTransformationMatrix::RotationOrder 
to  MEulerRotation::RotationOrder . If
 MTransformationMatrix::kLast  or  MTransformationMatrix::kInvalid  is passed in,
 MEulerRotation::kXYZ  will be returned along with
a kInvalidParameter return status.'''
        pass

    def rotationOrder(self): 
        '''rotationOrder(self) -> MTransformationMatrix.RotationOrder
Returns: Returns:
The rotation order use by the rotation component of the
transformation matrix.

Returns the rotation order used by the rotation component of the
transformation matrix.'''
        pass

    def setRotatePivot(self, rotatePivot, space, balance): 
        '''setRotatePivot(self, rotatePivot, space, balance)
Arguments:
	[in]	rotatePivot = MPoint
	[in]	space = MSpace.Space
	[in]	balance = bool

Set the pivot used by the rotation.'''
        pass

    def asRotateMatrixInverse(self): 
        '''asRotateMatrixInverse(self) -> MMatrix

Returns the inverse of the rotate matrix. By default this is
described as:'''
        pass

    def scalePivotTranslation(self, space): 
        '''scalePivotTranslation(self, space) -> MVector
Returns: Returns:
The scale pivot translation.

Arguments:
	[in]	space = MSpace.Space

Returns the scale pivot translation, which is used to compensate
for changes of the scale pivot.'''
        pass

    def setScalePivot(self, scalePivot, space, balance): 
        '''setScalePivot(self, scalePivot, space, balance)
Arguments:
	[in]	scalePivot = MPoint
	[in]	space = MSpace.Space
	[in]	balance = bool

Set the pivot used by the scale.'''
        pass

    def isEquivalent(self, other, tolerance): 
        '''isEquivalent(self, other, tolerance) -> bool
Returns: Returns:
Boolean value; true The matrices are identical within
the specified tolerance, false otherwise.

Arguments:
	[in]	other = MMatrix
	[in]	tolerance = double

Determine if the  MMatrix  is
equivalent within a specified tolerance.'''
        pass

    def unSquishIt(self): 
        '''unSquishIt(self)
Remove any shearing and any non-proportional scaling from this
transform. If the scaling is non-proportional, then the maximum
scale of the three scale axes will be used on all of the scale
axes.'''
        pass

    def translation(self, space): 
        '''translation(self, space) -> MVector
Returns: Returns:
The translation vector in centimeters.

Arguments:
	[in]	space = MSpace.Space

Returns the translation component of the transformation matrix
as a  MVector  in
centimeters (the internal Maya linear unit).'''
        pass

    def copyValues(self, xform): 
        '''copyValues(self, xform)
Arguments:
	[in]	xform = MPxTransformationMatrix

This method should be overridden for any transform that uses
more then the default transform values. The values from the passed
class (which should be type checked and downcast to its appropriate
value) should be copied to this class.'''
        pass

    def __eq__(self, rhs): 
        '''__eq__(self, rhs) -> bool
Returns: Returns:
Boolean value: true The matrices are identical,
false otherwise.

Arguments:
	[in]	rhs = MMatrix

Equality operator'''
        pass

    def decomposeMatrix(self, m): 
        '''decomposeMatrix(self, m)
Arguments:
	[in]	m = MMatrix

This method converts a passed  MMatrix  into
individual transformation matrix components. The default algorithm
will solve under the assumption that the pivots and pivot
translates are all zero.'''
        pass

    def reverse(self): 
        '''reverse(self) -> MPxTransformationMatrix

Returns the negated translate, rotate, and scale without taking
the pivots into account.'''
        pass

    def asScaleMatrixInverse(self): 
        '''asScaleMatrixInverse(self) -> MMatrix

Returns inverse of the scale matrix. The scale matrix takes
points from object space to the space immediately following scale
and shear transformations.'''
        pass

    def asRotateMatrix(self): 
        '''asRotateMatrix(self) -> MMatrix

Returns the rotate section of the transformation matrix. By
default this is described as:'''
        pass

    def eulerRotation(self, space): 
        '''eulerRotation(self, space) -> MEulerRotation
Returns: Returns:
The euler angle that is the rotation component of the
transformation matrix.

Arguments:
	[in]	space = MSpace.Space

Returns the rotation component of the transformation matrix as a
euler rotation. If an invalid space is used,  MEulerRotation::identity 
will be returned.'''
        pass

    def scaleBy(self, scaleFactor, space): 
        '''scaleBy(self, scaleFactor, space)
Arguments:
	[in]	scaleFactor = MVector
	[in]	space = MSpace.Space

Apply a relative scale to the existing scale.'''
        pass

    def rotateOrientation(self, space): 
        '''rotateOrientation(self, space) -> MQuaternion
Returns: Returns:
The rotate orientation.

Arguments:
	[in]	space = MSpace.Space

Returns the rotate orientation for the transformation matrix as
a quaternion. The rotate orientation orients the local rotation
space.'''
        pass

    def shear(self, space): 
        '''shear(self, space) -> MVector
Returns: Returns:
A MVector holding
the xy, xz, yz values of shear.

Arguments:
	[in]	space = MSpace.Space

Returns the shear component of the transformation matrix.'''
        pass

    def transformBy(self, transMat): 
        '''transformBy(self, transMat) -> MPxTransformationMatrix
Returns: Returns:
This transformation matrix.

Arguments:
	[in]	transMat = MTransformationMatrix

Transforms the transformation matrix by the passed  MTransformationMatrix . The individual
components are considered with the exception of the pivot
translations.'''
        pass

    def setRotationOrder(self, rotOrder, preserve): 
        '''setRotationOrder(self, rotOrder, preserve)
Arguments:
	[in]	rotOrder = MTransformationMatrix.RotationOrder
	[in]	preserve = bool

Sets the rotation order used by the rotation component of the
transformation matrix.'''
        pass

    def convertEulerRotationOrder(self, eulerOrder): 
        '''convertEulerRotationOrder(self, eulerOrder) -> MTransformationMatrix.RotationOrder
Returns: Returns:
The corresponding MTransformationMatrix::RotationOrder.

Arguments:
	[in]	eulerOrder = MEulerRotation.RotationOrder

Convert from  MEulerRotation::RotationOrder  to
 MTransformationMatrix::RotationOrder .'''
        pass

class MPxUIControl:
    '''Base class for control creation.'''
    def __init__(self):
        pass


class MPxUITableControl:
    '''Base class for creating new spreadsheet controls.'''
    def __init__(self):
        pass


    def redrawLabels(self, labelType): 
        '''redrawLabels(self, labelType)
Arguments:
	[in]	labelType = MPxUITableControl.MLabelType

Tells the table control to redraw the label entries.'''
        pass

    def clearSelection(self): 
        '''clearSelection(self)
Clears the selection table. This will remove all highlighted
cells from the table.'''
        pass

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

Tells the base UI table control class if this control is
editable. It is possible to implement tables that simple display
information and do not allow the user to edit them.'''
        pass

    def setSelection(self, firstRow, lastRow, firstCol, lastCol): 
        '''setSelection(self, firstRow, lastRow, firstCol, lastCol)
Arguments:
	[in]	firstRow = int
	[in]	lastRow = int
	[in]	firstCol = int
	[in]	lastCol = int

Sets the selection to be the range of cells specified. This
replaces the current selection with the specified selection
range.'''
        pass

    def isSelected(self, row, col): 
        '''isSelected(self, row, col) -> bool

Arguments:
	[in]	row = int
	[in]	col = int

Returns true if the specified cell is selected.'''
        pass

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


MS::kSuccess
Successfully returned the number of rows.
MS::kFailure Internal
error.

Returns the number of columns in the table.'''
        pass

    def setNumberOfColumns(self, count): 
        '''setNumberOfColumns(self, count)
Arguments:
	[in]	count = int

Specifies the number of columns for the table.'''
        pass

    def setNumberOfRows(self, count): 
        '''setNumberOfRows(self, count)
Arguments:
	[in]	count = int

Specifies the number of rows for the table.'''
        pass

    def allowSelection(self, top, left, bottom, right): 
        '''allowSelection(self, top, left, bottom, right) -> bool
Returns: Returns:


true the table can be edited.
false the table should not be edited.

Arguments:
	[in]	top = int
	[in]	left = int
	[in]	bottom = int
	[in]	right = int

This method is called when a selection occurs. In this base
implementation it always returns true. However, this method can be
overridden to allow or disallow a selection.'''
        pass

    def labelString(self, labelType, n): 
        '''labelString(self, labelType, n) -> MString
Returns: Returns:
Text of the requested label or an empty string if 'index' is
invalid.

Arguments:
	[in]	labelType = MPxUITableControl.MLabelType
	[in]	n = int

Returns the text of the label for the given row or column.'''
        pass

    def numberOfRows(self): 
        '''numberOfRows(self) -> int
Returns: Returns:
Number of rows in the table or zero on failure.

Returns the number of rows in the table.'''
        pass

    def suspendUpdates(self, update): 
        '''suspendUpdates(self, update) -> bool
Returns: Returns:


MS::kSuccess Suspend
status updated.
MS::kFailure Internal
error.

Arguments:
	[in]	update = bool

When set to true, it prevents the UI from updating the table.
The old suspend status is returned.'''
        pass

    def removeFromSelection(self, row, column): 
        '''removeFromSelection(self, row, column)
Arguments:
	[in]	row = int
	[in]	column = int

Removes the specified cell entry from the internal selection
list.'''
        pass

    def redrawCells(self): 
        '''redrawCells(self)
Tells the UI control to redraw the cells of the table. The table
control maintains a database of cell entries and it will populate
these entries using getCell interface.'''
        pass

    def collapseOrExpandRow(self, row): 
        '''collapseOrExpandRow(self, row) -> bool
Returns: Returns:


true the action was handled.
false the action was not handled.

Arguments:
	[in]	row = int

This is called when a row should be collapsed or expanded
(depending on its current state).'''
        pass

    def addToSelection(self, row, col): 
        '''addToSelection(self, row, col)
Arguments:
	[in]	row = int
	[in]	col = int

Add the follow cell to the selection data structure. To keep
track of which entries that should be highlighted, an internal
table is maintained.'''
        pass

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

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

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

    def kAllLabels(self):
        '''This is an enum of MLabelType.
Description: 
Value: 3'''
        pass

    class MLabelType:
        '''Non-functional class.  Values for this enum:
        kRowLabel
        kNoLabel
        kColumnLabel
        kAllLabels
'''
        def __init__(self):
            pass

    def cellString(self, r, c, isValidCell): 
        '''cellString(self, r, c, isValidCell) -> MString
Returns: Returns:
Contents of the specified cell, as a string, or an empty string
if an invalid cell was specified.

Arguments:
	[in]	r = int
	[in]	c = int
	[out]	isValidCell = bool

Returns the contents of a cell.'''
        pass

