
'''
Stub class file for:
OpenMayaUI

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




class M3dView:
    '''A 3-D view.'''
    def __init__(self):
        pass


    def setMultipleDrawPassCount(self, count): 
        '''setMultipleDrawPassCount(self, count)
Arguments:
	[in]	count = unsigned

This method sets the number of multiple draw passes when
multiple draw is enabled.'''
        pass

    def isLightVisible(self, lightNumber, visible): 
        '''isLightVisible(self, lightNumber, visible)
Arguments:
	[in]	lightNumber = int
	[out]	visible = bool

Find out if a light is visible in the view'''
        pass

    def getLightCount(self, visible, count): 
        '''getLightCount(self, visible, count)
Arguments:
	[out]	count = int
	[in]	visible = bool

Get the number of lights for the view.'''
        pass

    def kDormantColors(self):
        '''This is an enum of ColorTable.
Description: Colors for dormant objects.
Value: 2'''
        pass

    def kTemplateColor(self):
        '''This is an enum of ColorTable.
Description: Colors for templated objects.
Value: 5'''
        pass

    def kBackgroundColor(self):
        '''This is an enum of ColorTable.
Description: Colors for background color.
Value: 6'''
        pass

    def kActiveColors(self):
        '''This is an enum of ColorTable.
Description: Colors for active objects.
Value: 0'''
        pass

    class ColorTable:
        '''Non-functional class.  Values for this enum:
        kDormantColors
        kTemplateColor
        kBackgroundColor
        kActiveColors
'''
        def __init__(self):
            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 kHighQualityRenderer(self):
        '''This is an enum of RendererName.
Description: Equivalent to when the renderer name is
"hwRender_OpenGL_Renderer" when queried from the "modelEditor"
command.
Value: 1'''
        pass

    def kExternalRenderer(self):
        '''This is an enum of RendererName.
Description: An externally defined renderer name has been set.
Value: 2'''
        pass

    def kDefaultQualityRenderer(self):
        '''This is an enum of RendererName.
Description: Equivalent to when the renderer name is "base_OpenGL_Renderer"
when queried from the "modelEditor" command.
Value: 0'''
        pass

    class RendererName:
        '''Non-functional class.  Values for this enum:
        kHighQualityRenderer
        kExternalRenderer
        kDefaultQualityRenderer
'''
        def __init__(self):
            pass

    def window(self): 
        '''window(self) -> M3dView.MNativeWindowHdl
Returns: Returns:
The X window

Returns the native window for this view.'''
        pass

    def beginSelect(self, buffer, size): 
        '''beginSelect(self, buffer, size)
Arguments:
	[in]	buffer = M3dView.GLuint
	[in]	size = M3dView.GLsizei

Start selecting. The buffer passed is used to record selection
hits. A selection hit consists of the following 4 items:'''
        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.'''
        pass

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

Returns the Returns the prefix used when displaying the camera
name in the heads up display when view selected in on.'''
        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 objectDisplay(self): 
        '''objectDisplay(self) -> int
Returns: Returns:
The display object mask which can be bit 'AND'ed against the
M3dView::DisplayObjects
enum.

Returns a display object mask that indicates which object types
are drawn in current view.'''
        pass

    def endProjMatrixOverride(self): 
        '''endProjMatrixOverride(self)
End projection matrix override enabled by  beginProjMatrixOverride() .'''
        pass

    def loadName(self, name): 
        '''loadName(self, name)
Arguments:
	[in]	name = M3dView.GLuint

Replace the top of the name stack with the given name. Valid
only when  beginSelect() 
has been called.'''
        pass

    def writeColorBuffer(self, image, x, y): 
        '''writeColorBuffer(self, image, x, y)
Arguments:
	[in]	image = MImage
	[in]	x = signed
	[in]	y = signed

Overwrite the RGB values for the frame buffer for a given view.
Expected input is a block of RGBA, such that each channel is one
byte in size.'''
        pass

    def kHilite(self):
        '''This is an enum of DisplayStatus.
Description: Object is hilited (has selectable components).
Value: 4'''
        pass

    def kActiveTemplate(self):
        '''This is an enum of DisplayStatus.
Description: Object is active and templated.
Value: 6'''
        pass

    def kDormant(self):
        '''This is an enum of DisplayStatus.
Description: Object is domant.
Value: 2'''
        pass

    def kInvisible(self):
        '''This is an enum of DisplayStatus.
Description: Object is invisible (not drawn).
Value: 3'''
        pass

    def kActive(self):
        '''This is an enum of DisplayStatus.
Description: Object is active (selected).
Value: 0'''
        pass

    def kActiveComponent(self):
        '''This is an enum of DisplayStatus.
Description: Object has active components.
Value: 7'''
        pass

    def kActiveAffected(self):
        '''This is an enum of DisplayStatus.
Description: Affected by active object(s).
Value: 10'''
        pass

    def kNoStatus(self):
        '''This is an enum of DisplayStatus.
Description: Object does not have a valid display status.
Value: 11'''
        pass

    def kLive(self):
        '''This is an enum of DisplayStatus.
Description: Object is live (construction surface).
Value: 1'''
        pass

    def kTemplate(self):
        '''This is an enum of DisplayStatus.
Description: Object is templated (Not renderable).
Value: 5'''
        pass

    def kLead(self):
        '''This is an enum of DisplayStatus.
Description: Last selected object.
Value: 8'''
        pass

    def kIntermediateObject(self):
        '''This is an enum of DisplayStatus.
Description: Construction object (not drawn).
Value: 9'''
        pass

    class DisplayStatus:
        '''Non-functional class.  Values for this enum:
        kHilite
        kActiveTemplate
        kDormant
        kInvisible
        kActive
        kActiveComponent
        kActiveAffected
        kNoStatus
        kLive
        kTemplate
        kLead
        kIntermediateObject
'''
        def __init__(self):
            pass

    def refresh(self, buffer, offscreen, projMatrix): 
        '''refresh(self, buffer, offscreen, projMatrix)
Arguments:
	[in]	buffer = MPxGlBuffer
	[in]	offscreen = bool
	[in]	projMatrix = MMatrix

Refresh the this view into the GL buffer buffer.'''
        pass

    def multipleDrawPassCount(self): 
        '''multipleDrawPassCount(self)
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 usingMipmappedTextures(self): 
        '''usingMipmappedTextures(self) -> bool

Returns if the view is using mipmapped texture display.'''
        pass

    def popViewport(self): 
        '''popViewport(self)
Pop the current viewport off of the viewport stack.'''
        pass

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

Returns true if the view is currently displaying objects using
the default material.'''
        pass

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

Returns the number of 3D views currently in existance.'''
        pass

    def kDisplayPlanes(self):
        '''This is an enum of DisplayObjects.
Description: Show planes.
Value: 8'''
        pass

    def kDisplayPivots(self):
        '''This is an enum of DisplayObjects.
Description: Show pivots.
Value: 8192'''
        pass

    def kDisplayGrid(self):
        '''This is an enum of DisplayObjects.
Description: Show the grid.
Value: 32768'''
        pass

    def kDisplayCameras(self):
        '''This is an enum of DisplayObjects.
Description: Show camera.
Value: 32'''
        pass

    def kDisplayManipulators(self):
        '''This is an enum of DisplayObjects.
Description: Show Manipulators.
Value: 134217728'''
        pass

    def kDisplayNParticles(self):
        '''This is an enum of DisplayObjects.
Description: Show nParticles.
Value: 268435456'''
        pass

    def kDisplayCVs(self):
        '''This is an enum of DisplayObjects.
Description: Show NURBS CVs.
Value: 65536'''
        pass

    def kDisplayDynamics(self):
        '''This is an enum of DisplayObjects.
Description: Show dynamics.
Value: 512'''
        pass

    def kDisplayMeshes(self):
        '''This is an enum of DisplayObjects.
Description: Show meshes.
Value: 4'''
        pass

    def kDisplayNCloths(self):
        '''This is an enum of DisplayObjects.
Description: Show nCloths.
Value: 16777216'''
        pass

    def kDisplayFluids(self):
        '''This is an enum of DisplayObjects.
Description: Show fluids.
Value: 1048576'''
        pass

    def kDisplayDimensions(self):
        '''This is an enum of DisplayObjects.
Description: Show dimensions.
Value: 2048'''
        pass

    def kDisplaySelectHandles(self):
        '''This is an enum of DisplayObjects.
Description: Show selection handles.
Value: 4096'''
        pass

    def kDisplayEverything(self):
        '''This is an enum of DisplayObjects.
Description: Show everything.
Value: -1'''
        pass

    def kDisplayNRigids(self):
        '''This is an enum of DisplayObjects.
Description: Show nRigids.
Value: 33554432'''
        pass

    def kDisplayImagePlane(self):
        '''This is an enum of DisplayObjects.
Description: Show image plane.
Value: 8388608'''
        pass

    def kDisplayTextures(self):
        '''This is an enum of DisplayObjects.
Description: Show textures.
Value: 16384'''
        pass

    def kDisplayDynamicConstraints(self):
        '''This is an enum of DisplayObjects.
Description: Show nDynamicConstraints.
Value: 67108864'''
        pass

    def kDisplayIkHandles(self):
        '''This is an enum of DisplayObjects.
Description: Show IK handles.
Value: 128'''
        pass

    def kDisplayHairSystems(self):
        '''This is an enum of DisplayObjects.
Description: Show hair systems.
Value: 4194304'''
        pass

    def kDisplayFollicles(self):
        '''This is an enum of DisplayObjects.
Description: Show follcles.
Value: 2097152'''
        pass

    def kDisplayLocators(self):
        '''This is an enum of DisplayObjects.
Description: Show locators.
Value: 1024'''
        pass

    def kDisplayDeformers(self):
        '''This is an enum of DisplayObjects.
Description: Show deformers.
Value: 256'''
        pass

    def kDisplayJoints(self):
        '''This is an enum of DisplayObjects.
Description: Show joints.
Value: 64'''
        pass

    def kDisplaySubdivSurfaces(self):
        '''This is an enum of DisplayObjects.
Description: Show subdivision surfaces.
Value: 524288'''
        pass

    def kDisplayHulls(self):
        '''This is an enum of DisplayObjects.
Description: Show NURBS hulls.
Value: 131072'''
        pass

    def kDisplayLights(self):
        '''This is an enum of DisplayObjects.
Description: Show lights.
Value: 16'''
        pass

    def kDisplayNurbsSurfaces(self):
        '''This is an enum of DisplayObjects.
Description: Show nurbs surfaces.
Value: 2'''
        pass

    def kDisplayNurbsCurves(self):
        '''This is an enum of DisplayObjects.
Description: Show nurbs curves.
Value: 1'''
        pass

    def kDisplayStrokes(self):
        '''This is an enum of DisplayObjects.
Description: Show strokes.
Value: 262144'''
        pass

    class DisplayObjects:
        '''Non-functional class.  Values for this enum:
        kDisplayPlanes
        kDisplayPivots
        kDisplayGrid
        kDisplayCameras
        kDisplayManipulators
        kDisplayNParticles
        kDisplayCVs
        kDisplayDynamics
        kDisplayMeshes
        kDisplayNCloths
        kDisplayFluids
        kDisplayDimensions
        kDisplaySelectHandles
        kDisplayEverything
        kDisplayNRigids
        kDisplayImagePlane
        kDisplayTextures
        kDisplayDynamicConstraints
        kDisplayIkHandles
        kDisplayHairSystems
        kDisplayFollicles
        kDisplayLocators
        kDisplayDeformers
        kDisplayJoints
        kDisplaySubdivSurfaces
        kDisplayHulls
        kDisplayLights
        kDisplayNurbsSurfaces
        kDisplayNurbsCurves
        kDisplayStrokes
'''
        def __init__(self):
            pass

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

    def popName(self): 
        '''popName(self)
'''
        pass

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

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

    def kLightAll(self):
        '''This is an enum of LightingMode.
Description: All lights ON mode.
Value: 0'''
        pass

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

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

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

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

    def pushViewport(self, x, y, width, height): 
        '''pushViewport(self, x, y, width, height)
Arguments:
	[in]	x = int
	[in]	y = int
	[in]	width = int
	[in]	height = int

Set the current viewport dimensions. Will keep track of the last
viewport dimensions on a stack. When finished with this viewport,
the current dimensions should be removed from the top of stack
using  M3dView::popViewport() .'''
        pass

    def endXorDrawing(self): 
        '''endXorDrawing(self)
Set the context for non-exclusive-or (non-XOR) screen
drawing.'''
        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 getLightingMode(self, mode): 
        '''getLightingMode(self, mode)
Arguments:
	[out]	mode = M3dView.LightingMode

Get the current lighting mode for the view.'''
        pass

    def getLightPath(self, lightNumber, lightPath): 
        '''getLightPath(self, lightNumber, lightPath)
Arguments:
	[in]	lightNumber = int
	[out]	lightPath = MDagPath

Get the path to a certain light.'''
        pass

    def pushName(self, name): 
        '''pushName(self, name)
Arguments:
	[in]	name = M3dView.GLuint

Push a new name on the name stack. Valid only when  beginSelect() 
has been called.'''
        pass

    def applicationShell(self): 
        '''applicationShell(self) -> M3dView.MNativeWindowHdl
Returns: Returns:
The window handle.

Returns the native handle for Maya's main window.'''
        pass

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

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

    def kStippleNone(self):
        '''This is an enum of LineStipplePattern.
Description: No stipple. Solid line.
Value: 0'''
        pass

    def kStippleDashed(self):
        '''This is an enum of LineStipplePattern.
Description: Dashed line stipple.
Value: 1'''
        pass

    class LineStipplePattern:
        '''Non-functional class.  Values for this enum:
        kStippleNone
        kStippleDashed
'''
        def __init__(self):
            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 widget(self): 
        '''widget(self) -> M3dView.QWidget*
Returns: Returns:
A QWidget pointer to the Qt widget containing the view's
drawing region, or NULL if the view's drawing region has not yet
been created.

Returns the view's Qt widget.'''
        pass

    def setColorMask(self, r, g, b, a): 
        '''setColorMask(self, r, g, b, a)
Arguments:
	[in]	r = bool
	[in]	g = bool
	[in]	b = bool
	[in]	a = bool

Set the current color mask.'''
        pass

    def readBufferTo2dTexture(self, x, y, width, height): 
        '''readBufferTo2dTexture(self, x, y, width, height)
Arguments:
	[in]	x = short
	[in]	y = short
	[in]	width = int
	[in]	height = int

Read the depth values from the frame buffer for a given view
into a predefined OpenGL 2d texture. It is assumed that such a
texture has been created and bound before making this call.'''
        pass

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

    def setObjectDisplay(self, displayMask): 
        '''setObjectDisplay(self, displayMask)
Arguments:
	[in]	displayMask = int

Sets a display object mask that indicates which object types are
drawn in current view. By default every thing is displayed.'''
        pass

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

Returns the current position of this view window in screen
coordinates.'''
        pass

    def rendererString(self): 
        '''rendererString(self) -> MString
Returns: Returns:
String name

Get the string name of the current renderer being used for
drawing to this view.'''
        pass

    def kLeft(self):
        '''This is an enum of TextPosition.
Description: Draw text to the left of the point.
Value: 0'''
        pass

    def kRight(self):
        '''This is an enum of TextPosition.
Description: Draw text to the right of the point.
Value: 2'''
        pass

    def kCenter(self):
        '''This is an enum of TextPosition.
Description: Draw text centered around the point.
Value: 1'''
        pass

    class TextPosition:
        '''Non-functional class.  Values for this enum:
        kLeft
        kRight
        kCenter
'''
        def __init__(self):
            pass

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

This method 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 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 templateColor(self): 
        '''templateColor(self) -> MColor
Returns: Returns:
The template color

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

    def setShowViewSelectedChildren(self, show): 
        '''setShowViewSelectedChildren(self, show)
Arguments:
	[in]	show = bool

This method changes the way that view selected works. By
default, view selected with show all of the children of the objects
in the view selected set. If false is passed to this method, then
only the obejcts in the view selected set and their shapes will be
drawn.'''
        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 clearOverlayPlane(self): 
        '''clearOverlayPlane(self)
Clear the overlay plane.'''
        pass

    def colorMask(self, r, g, b, a): 
        '''colorMask(self, r, g, b, a)
Arguments:
	[out]	r = bool
	[out]	g = bool
	[out]	b = bool
	[out]	a = bool

Get the current color mask.'''
        pass

    def kFlatShaded(self):
        '''This is an enum of DisplayStyle.
Description: Flat shaded display.
Value: 1'''
        pass

    def kWireFrame(self):
        '''This is an enum of DisplayStyle.
Description: Wire frame display.
Value: 3'''
        pass

    def kGouraudShaded(self):
        '''This is an enum of DisplayStyle.
Description: Gouraud shaded display.
Value: 2'''
        pass

    def kBoundingBox(self):
        '''This is an enum of DisplayStyle.
Description: Bounding box display.
Value: 0'''
        pass

    def kPoints(self):
        '''This is an enum of DisplayStyle.
Description: Points only display.
Value: 4'''
        pass

    class DisplayStyle:
        '''Non-functional class.  Values for this enum:
        kFlatShaded
        kWireFrame
        kGouraudShaded
        kBoundingBox
        kPoints
'''
        def __init__(self):
            pass

    def beginProjMatrixOverride(self, projectionMatrix): 
        '''beginProjMatrixOverride(self, projectionMatrix)
Arguments:
	[in]	projectionMatrix = MMatrix

Begin overriding the projection matrix used in openGL drawing.
This override is enabled until  endProjMatrixOverride() 
is called.'''
        pass

    def wireframeOnlyInShadedMode(self): 
        '''wireframeOnlyInShadedMode(self) -> bool
Returns: Returns:
true if we are in this mode.

Return whether we are in shaded mode, but that only non shaded
drawing should occur (wireframe).'''
        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 portWidth(self): 
        '''portWidth(self) -> int
Returns: Returns:
The width of this viewport

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

    def getLightIndex(self, lightNumber, lightIndex): 
        '''getLightIndex(self, lightNumber, lightIndex)
Arguments:
	[in]	lightNumber = int
	[out]	lightIndex = int

Get the internal light index for a given light number'''
        pass

    def active3dView(self): 
        '''active3dView(self) -> M3dView

Returns the active view in the form of a class ( M3dView ) that
can operate on it.'''
        pass

    def endSelect(self): 
        '''endSelect(self) -> M3dView.GLint

Finish a selection sequence. Result is stored in the buffer
passed in the beginSelect call.   Reprocessed example '''
        pass

    def viewport(self, x, y, width, height): 
        '''viewport(self, x, y, width, height)
Arguments:
	[out]	x = int
	[out]	y = int
	[out]	width = int
	[out]	height = int

Get the current viewport dimensions.'''
        pass

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

Tells if this  M3dView  is in selection mode.'''
        pass

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

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

    def modelViewMatrix(self, modelViewMatrix): 
        '''modelViewMatrix(self, modelViewMatrix)
Arguments:
	[out]	modelViewMatrix = MMatrix

Returns the modelview matrix currently being used by OpenGL in
the current view'''
        pass

    def getRendererName(self): 
        '''getRendererName(self) -> M3dView.RendererName
Returns: Returns:
The name of the current renderer.

Get the name of the current renderer being used for drawing to
this view. The current possible return values are:'''
        pass

    def display(self): 
        '''display(self) -> M3dView.MGLContext
Returns: Returns:
The OpenGL context. On 32-bit OS X this is an AGLContext. On
64-bit OS X this is an NSOpenGLContext pointer. On Windows this is
an HGLRC.

Mac OS X and Windows.'''
        pass

    def readColorBuffer(self, image, readRGBA): 
        '''readColorBuffer(self, image, readRGBA)
Arguments:
	[in]	image = MImage
	[in]	readRGBA = bool

Read the RGB values from the frame buffer for a given view. The
buffer is read in a pixel format which is BGRA by default, such
that each channel is one byte in size.'''
        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 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 textureMode(self): 
        '''textureMode(self) -> bool

Tells if this  M3dView  is in texture mode.'''
        pass

    def readDepthMap(self, x, y, width, height, bufferPtr, depthMapPrecision): 
        '''readDepthMap(self, x, y, width, height, bufferPtr, depthMapPrecision)
Arguments:
	[in]	x = short
	[in]	y = short
	[in]	width = int
	[in]	height = int
	[in]	bufferPtr = char
	[in]	depthMapPrecision = M3dView.DepthBufferFormat

Read the depth values from the frame buffer for a given view.
The buffer is read into a block of data as defined as an argument.
The data block size must be large enough to accomodate ( view width
* view height * depth map precision ) bytes of data.'''
        pass

    def projectionMatrix(self, projMat): 
        '''projectionMatrix(self, projMat)
Arguments:
	[out]	projMat = MMatrix

Returns the projection matrix currently being used by OpenGL in
the current view'''
        pass

    def kDepth_Float(self):
        '''This is an enum of DepthBufferFormat.
Description: Floating point.
Value: 1'''
        pass

    def kDepth_8(self):
        '''This is an enum of DepthBufferFormat.
Description: 8 bits.
Value: 0'''
        pass

    class DepthBufferFormat:
        '''Non-functional class.  Values for this enum:
        kDepth_Float
        kDepth_8
'''
        def __init__(self):
            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 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 beginXorDrawing(self, drawOrthographic, disableDepthTesting, lineWidth, stipplePattern, lineColor): 
        '''beginXorDrawing(self, drawOrthographic, disableDepthTesting, lineWidth, stipplePattern, lineColor)
Arguments:
	[in]	drawOrthographic = bool
	[in]	disableDepthTesting = bool
	[in]	lineWidth = float
	[in]	stipplePattern = M3dView.LineStipplePattern
	[in]	lineColor = MColor

Setup the context for exclusive-or (XOR) drawing.'''
        pass

    def getM3dViewFromModelEditor(self, name, view): 
        '''getM3dViewFromModelEditor(self, name, view)
Arguments:
	[in]	name = MString
	[out]	view = M3dView

Given the name of a model editor, get the  M3dView  used by that
editor. If this fails, then a editor with the given name could not
be located.'''
        pass

    def initNames(self): 
        '''initNames(self)
'''
        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 getM3dViewFromModelPanel(self, name, view): 
        '''getM3dViewFromModelPanel(self, name, view)
Arguments:
	[in]	name = MString
	[out]	view = M3dView

Given the name of a model panel, get the  M3dView  used by that
panel. If this fails, then a panel with the given name could not be
located.'''
        pass

    def get3dView(self, index, view): 
        '''get3dView(self, index, view)
Arguments:
	[in]	index = int
	[out]	view = M3dView

Returns the 3D view at the given index.'''
        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 showViewSelectedChildren(self): 
        '''showViewSelectedChildren(self) -> bool
Returns: Returns:
true if the children of view selected objects are drawn.

Returns turn if view selected shows all of the children of the
obejcts that are flagged for view selected.'''
        pass

class MCursor:
    '''Manipulate Cursors.'''
    def __init__(self):
        pass


    defaultCursor = ''
    '''Maya default cursor, the left
arrow.'''

    crossHairCursor = ''
    ''''+' cursor.'''

    handCursor = ''
    '''Open hand shaped cursor.'''

    doubleCrossHairCursor = ''
    ''''+' cursor with double lines.'''

    editCursor = ''
    '''Wedge-shaped arrow pointing left.'''

    pencilCursor = ''
    '''Pencil shape.'''

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


true if the objects are same.
false if the objects are different.

Arguments:
	[in]	other = MCursor

Equality operator. Allows 2 MCursors to be compared to see if
they are identical.'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool
Returns: Returns:


true if the objects are different.
false if the objects are same.

Arguments:
	[in]	other = MCursor

Inequality operator. Allows 2 MCursors to be compared to see if
they are not the same.'''
        pass

class MDeviceChannel:
    '''Input device channel.'''
    def __init__(self):
        pass


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

Returns the device state index corresponding to this device
channel.'''
        pass

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

Return the short name of the channel.'''
        pass

    def parent(self): 
        '''parent(self) -> MDeviceChannel

Return the parent of this channel.'''
        pass

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

Determine whether this channel has children.'''
        pass

    def childByIndex(self, index): 
        '''childByIndex(self, index) -> MDeviceChannel

Arguments:
	[in]	index = int

Return the specified child of this channel.'''
        pass

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

Return the number of children of this channel.'''
        pass

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

Return the long name of the channel.'''
        pass

class MDeviceState:
    '''Input device state.'''
    def __init__(self):
        pass


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

Return the value of the axis with the largest value. This is
used to dejitter absolute devices.'''
        pass

    def buttonState(self, buttonName): 
        '''buttonState(self, buttonName) -> bool
Returns: Returns:


true button pressed
false button released

Arguments:
	[in]	buttonName = MString

Returns the state of the named button.'''
        pass

    def devicePosition(self, axisName): 
        '''devicePosition(self, axisName) -> int
Returns: Returns:
The position of the device for the specified axis

Arguments:
	[in]	axisName = MString

Returns the position of the device for the specified axis.'''
        pass

    def setButtonState(self, state, buttonName): 
        '''setButtonState(self, state, buttonName)
Arguments:
	[in]	state = bool
	[in]	buttonName = MString

Set the state of the specified button.'''
        pass

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

Returns  true  if this device state is NULL;'''
        pass

    def setDevicePosition(self, position, axis): 
        '''setDevicePosition(self, position, axis)
Arguments:
	[in]	position = int
	[in]	axis = MString

Sets the position of the device for the specified axis.'''
        pass

class MDrawData:
    '''Draw data used in the draw methods of MPxSurfaceShapeUI.'''
    def __init__(self):
        pass


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

Returns the geometry associated with this draw data object. The
geometry is set using the getDrawData method of  MPxSurfaceShapeUI .'''
        pass

class MDrawInfo:
    '''Drawing state used in the draw methods of MPxSurfaceShapeUI.'''
    def __init__(self):
        pass


    def objectDisplayStatus(self, displayObj): 
        '''objectDisplayStatus(self, displayObj) -> bool

Arguments:
	[in]	displayObj = M3dView.DisplayObjects

Determines whether the specified objects are allowed to be
displayed.'''
        pass

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

Returns true if the object being drawn is inside the viewing
frustum.'''
        pass

    def projectionMatrix(self): 
        '''projectionMatrix(self) -> const MMatrix

Returns the camera*projection matrix.'''
        pass

    def displayStatus(self): 
        '''displayStatus(self) -> M3dView.DisplayStatus

Returns the status of the object to draw.'''
        pass

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

Returns true if this is called from within the select method of
 MPxSurfaceShapeUI .'''
        pass

    def inclusiveMatrix(self): 
        '''inclusiveMatrix(self) -> const MMatrix

Returns the world space inclusive matrix.'''
        pass

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

Returns true during any interactive refresh, as when user is
changing the view using view context tools such as tumble, dolly or
track. Useful for changing drawing mode to something simpler to
speed up interaction re-draw. Use inUserInteraction for determining
whether user is interacting with the scene in any way.'''
        pass

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

Returns true during any interactive refresh, as when user is
interacting with the scene in any way including camera changes,
object or component TRS changes, etc. Use userChangingViewContext
for determining whether user is changing the view using view
context tools such as tumble, dolly or track.'''
        pass

    def canDrawComponent(self, isDisplayOn, mask): 
        '''canDrawComponent(self, isDisplayOn, mask) -> bool
Returns: Returns:


true the specified component can be drawn
false the specified component cannot be drawn

Arguments:
	[in]	isDisplayOn = bool
	[in]	mask = MSelectionMask

Convenience method to test if components specified by the given
mask can be drawn.'''
        pass

    def getPrototype(self, drawHandler): 
        '''getPrototype(self, drawHandler) -> MDrawRequest
Returns: Returns:
A draw request

Arguments:
	[in]	drawHandler = MPxSurfaceShapeUI

This method creates a draw request based on the current draw
state.'''
        pass

    def multiPath(self): 
        '''multiPath(self) -> const MDagPath

Returns the path to the object to be drawn.'''
        pass

    def displayStyle(self): 
        '''displayStyle(self) -> M3dView.DisplayStyle

The display appearance.'''
        pass

    def setMultiPath(self, dagPath): 
        '''setMultiPath(self, dagPath)
Arguments:
	[in]	dagPath = MDagPath

'''
        pass

    def view(self): 
        '''view(self) -> M3dView

Returns the view that the drawing will take place.'''
        pass

class MDrawRequest:
    '''A draw reqeust used in the draw methods of MPxSurfaceShapeUI.The draw token is an integer value which you can use to specify
what is to be drawn. This is object specific and so you should
define an enum with the information you require to decide what is
being drawn in your 
MPxSurfaceShapeUI::draw method.'''
    def __init__(self):
        pass


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

'''
        pass

    def color(self, table): 
        '''color(self, table) -> int

Arguments:
	[in]	table = M3dView.ColorTable

Returns the wireframe display color.'''
        pass

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

Sets the state of the culling flag for the object.'''
        pass

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

Specifies the order in which this object will be drawn.'''
        pass

    def displayStyle(self): 
        '''displayStyle(self) -> M3dView.DisplayStyle

'''
        pass

    def setMaterial(self, material): 
        '''setMaterial(self, material)
Arguments:
	[in]	material = MMaterial

Returns the shaded material.'''
        pass

    def setComponent(self, comp): 
        '''setComponent(self, comp)
Arguments:
	[in]	comp = MObject

Set a component to be drawn.'''
        pass

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

'''
        pass

    def multiPath(self): 
        '''multiPath(self) -> const MDagPath

Returns the path to the object to be drawn. 
  Reprocessed example '''
        pass

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

Sets how the object should be drawn (wireframe, shaded,
etc.).'''
        pass

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

Sets the state of the culling flag for the object.'''
        pass

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

Returns the transparency state of the object. 
  Reprocessed example '''
        pass

    def material(self): 
        '''material(self) -> MMaterial

Returns the shaded material.   Reprocessed example '''
        pass

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

An optional component. If set draw the components that are
specified, otherwise draw all components of this type for the
object.   Reprocessed example '''
        pass

    def displayStatus(self): 
        '''displayStatus(self) -> M3dView.DisplayStatus

'''
        pass

    def setView(self, theView): 
        '''setView(self, theView)
Arguments:
	[in]	theView = M3dView

'''
        pass

    def setDrawData(self, data): 
        '''setDrawData(self, data)
Arguments:
	[in]	data = MDrawData

Set the object specific draw data.'''
        pass

    def setMultiPath(self, thePath): 
        '''setMultiPath(self, thePath)
Arguments:
	[in]	thePath = MDagPath

'''
        pass

    def setToken(self, value): 
        '''setToken(self, value)
Arguments:
	[in]	value = int

Set the user-defined draw token for this request.'''
        pass

    def setColor(self, value, table): 
        '''setColor(self, value, table)
Arguments:
	[in]	value = int
	[in]	table = M3dView.ColorTable

Sets the wireframe display color.'''
        pass

    def setDisplayStatus(self, status): 
        '''setDisplayStatus(self, status)
Arguments:
	[in]	status = M3dView.DisplayStatus

Set the state of object (active, dormant, etc.).'''
        pass

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

Returns the user-defined draw token for this request.'''
        pass

    def drawData(self): 
        '''drawData(self) -> MDrawData

Returns the object specific draw data. 
  Reprocessed example '''
        pass

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

'''
        pass

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

Sets the transparency state of the object.'''
        pass

    def view(self): 
        '''view(self) -> M3dView

'''
        pass

class MDrawRequestQueue:
    '''Drawing queue used in 
MPxSurfaceShapeUI::getDrawRequests.'''
    def __init__(self):
        pass


    def add(self, request): 
        '''add(self, request)
Arguments:
	[in]	request = MDrawRequest

Adds a draw request to the draw queue.'''
        pass

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

Returns true if the queu is empty.'''
        pass

    def remove(self): 
        '''remove(self) -> MDrawRequest

Removes a draw request from the draw queue.'''
        pass

class MDrawTraversal:
    '''A scene drawing traverser.Note that as the traversal is not dependent on a 3d modeling
viewport. There are thus no checks for per viewport visibility
properties such as per viewport dag object type overrides, and
"isolate select".Note that hierarchical culling may force evaluation of geometry on
dag objects which are not visible.'''
    def __init__(self):
        pass


    def filterNode(self, traversalItem): 
        '''filterNode(self, traversalItem) -> bool
Returns: Returns:
Will always return false for MDrawTraversal class.

Arguments:
	[in]	traversalItem = MDagPath

Method to allow filtering during traversal. The traversalItem
can be examined, and if it is not match the desired criteria, it
will not be added to the output traversal list.'''
        pass

    def itemHasStatus(self, itemNumber, test): 
        '''itemHasStatus(self, itemNumber, test) -> bool
Returns: Returns:
true, if item status matches the display status to test
against.

Arguments:
	[in]	itemNumber = int
	[in]	test = int

Test the display status for a given item in the list of found
items after traversal.'''
        pass

    def traverse(self): 
        '''traverse(self)
Perform traversal of the current scene from the root of the dag
hierarchy. A valid frustum must be set before calling this
method.'''
        pass

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

Return the number of items found after traversal.'''
        pass

    def setFrustum(self, nearBottomLeft, nearBottomRight, nearTopLeft, nearTopRight, farBottomLeft, farBottomRight, farTopLeft, farTopRight, worldXform): 
        '''setFrustum(self, nearBottomLeft, nearBottomRight, nearTopLeft, nearTopRight, farBottomLeft, farBottomRight, farTopLeft, farTopRight, worldXform)
Arguments:
	[in]	nearBottomLeft = MPoint
	[in]	nearBottomRight = MPoint
	[in]	nearTopLeft = MPoint
	[in]	nearTopRight = MPoint
	[in]	farBottomLeft = MPoint
	[in]	farBottomRight = MPoint
	[in]	farTopLeft = MPoint
	[in]	farTopRight = MPoint
	[in]	worldXform = MMatrix

Set up a frustum to cull with by specifying the 8 corner points.
Asymmetric frustum's can be set up using this method.'''
        pass

    def enum(self): 
        '''enum(self) -> anonymous

Item status enum.'''
        pass

    def itemPath(self, itemNumber, path): 
        '''itemPath(self, itemNumber, path)
Arguments:
	[in]	itemNumber = int
	[out]	path = MDagPath

Get the path for a given item in the list of found items after
traversal.'''
        pass

    def setPerspFrustum(self, fovX, aspectXY, nearDist, farDist, worldXform): 
        '''setPerspFrustum(self, fovX, aspectXY, nearDist, farDist, worldXform)
Arguments:
	[in]	fovX = double
	[in]	aspectXY = double
	[in]	nearDist = double
	[in]	farDist = double
	[in]	worldXform = MMatrix

Set up an perspective view frustum to cull with. The frustum is
symmetric about the vertical and horizontal.'''
        pass

    def enableFiltering(self, val): 
        '''enableFiltering(self, val)
Arguments:
	[in]	val = bool

Sets whether to use enable usage of the  filterNode() 
method to perform custom filtering. By default this is set to
false.'''
        pass

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

Returns whether the current frustum set is valid or not. If it
is not valid a call to the  traverse() 
function will result in returning failure.'''
        pass

    def setLeafLevelCulling(self, cullAtLeafLevel): 
        '''setLeafLevelCulling(self, cullAtLeafLevel)
Arguments:
	[in]	cullAtLeafLevel = bool

Set whether to cull at the leaf levels, or perform hierarchical
culling.'''
        pass

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

Returns whether the current cull algorithm will cull at the leaf
levels, or perform hierarchical culling. The default value is leaf
level culling.'''
        pass

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

Tells whether custom filtering has been enabled. That is, to use
the  filterNode() 
method during traversal.'''
        pass

    def setOrthoFrustum(self, left, right, bottom, top, nearpt, farpt, worldXform): 
        '''setOrthoFrustum(self, left, right, bottom, top, nearpt, farpt, worldXform)
Arguments:
	[in]	left = double
	[in]	right = double
	[in]	bottom = double
	[in]	top = double
	[in]	nearpt = double
	[in]	farpt = double
	[in]	worldXform = MMatrix

Set up an orthographic view frustum to cull with. The frustum is
symmetric about the vertical and horizontal.'''
        pass

class MEvent:
    '''System event information.Several modifiers for events are also accessible through the API.
Modifiers are actions that occur during an event. For example,
holding down the shift key while pressing a mouse button causes a
button press event to occur with a shift modifier.'''
    def __init__(self):
        pass


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

Was a modifier key released.'''
        pass

    def setModifiers(self, modType): 
        '''setModifiers(self, modType)
Arguments:
	[in]	modType = MEvent.ModifierType

set the event modifiers.'''
        pass

    def kMiddleMouse(self):
        '''This is an enum of MouseButtonType.
Description: 
Value: 128'''
        pass

    def kLeftMouse(self):
        '''This is an enum of MouseButtonType.
Description: 
Value: 64'''
        pass

    class MouseButtonType:
        '''Non-functional class.  Values for this enum:
        kMiddleMouse
        kLeftMouse
'''
        def __init__(self):
            pass

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

Determines if there are any modifiers for this event.'''
        pass

    def mouseButton(self): 
        '''mouseButton(self) -> MEvent.MouseButtonType

Get the mouse button of the last event.'''
        pass

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

Return the state of the middle mouse button.'''
        pass

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

return state of control key.'''
        pass

    def getWindowPosition(self, x_pos, y_pos): 
        '''getWindowPosition(self, x_pos, y_pos)
Arguments:
	[out]	x_pos = short
	[out]	y_pos = short

This routine is used by responders to query the position of the
pointer when the event occurred. It is given in screen
co-ordinates.'''
        pass

    def modifiers(self): 
        '''modifiers(self) -> MEvent.ModifierType

This routine is used by responders to find the state of the
modifiers during the event.'''
        pass

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

return state of shift key.'''
        pass

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

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

    class ModifierType:
        '''Non-functional class.  Values for this enum:
        shiftKey
        controlKey
'''
        def __init__(self):
            pass

    def setPosition(self, x_pos, y_pos): 
        '''setPosition(self, x_pos, y_pos)
Arguments:
	[in]	x_pos = short
	[in]	y_pos = short

set the location of the event to the specified location. The
origin is at the lower left corner of the window.'''
        pass

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

Return the state of the left mouse button.'''
        pass

    def getPosition(self, x_pos, y_pos): 
        '''getPosition(self, x_pos, y_pos)
Arguments:
	[out]	x_pos = short
	[out]	y_pos = short

Get the location of the event in view co-ordinates. The origin
is at the lower left corner of the window.'''
        pass

class MFeedbackLine:
    '''Feedback line.'''
    def __init__(self):
        pass


    def setValue(self, index, value): 
        '''setValue(self, index, value)
Arguments:
	[in]	index = short
	[in]	value = double

Set the value of a given index in the feedback line'''
        pass

    def setFormat(self, format): 
        '''setFormat(self, format)
Arguments:
	[in]	format = MString

Set the format string for the feedback line. The format begins
with a format specifier "^" followed by the format size, format
decimal character ".", decimal size, and format type. For example:
the format "^6.3f" which specifies that there is going to be one
value given, it is a float, with 3 decimal places shown.'''
        pass

    def setTitle(self, title): 
        '''setTitle(self, title)
Arguments:
	[in]	title = MString

Set the title string.'''
        pass

    def setShowFeedback(self, showFeedback): 
        '''setShowFeedback(self, showFeedback)
Arguments:
	[in]	showFeedback = bool

Set whether the feedback line is supposed to be displaying
data.'''
        pass

    def clear(self): 
        '''clear(self)
'''
        pass

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

Return whether or not the feedback line is is supposed to be
displaying data.'''
        pass

class MFnCircleSweepManip:
    '''CircleSweepManip function set.'''
    def __init__(self):
        pass


    def setEndPoint(self, endPoint): 
        '''setEndPoint(self, endPoint)
Arguments:
	[in]	endPoint = MPoint

Sets the end point of the CircleSweepManip.'''
        pass

    def endCircleIndex(self): 
        '''endCircleIndex(self) -> int
Returns: Returns:
The circle end index

Returns the index for the end of the circle of CircleSweepManip.
The data type corresponding to this index is a double.'''
        pass

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

Sets whether or not to draw as arc.'''
        pass

    def setRadius(self, radius): 
        '''setRadius(self, radius)
Arguments:
	[in]	radius = double

Sets the radius of the CircleSweepManip.'''
        pass

    def axisIndex(self): 
        '''axisIndex(self) -> int
Returns: Returns:
The axis index

Returns the index for the axis of CircleSweepManip. The data
type corresponding to this index is  MFnNumericData::k3Double .'''
        pass

    def setNormal(self, normal): 
        '''setNormal(self, normal)
Arguments:
	[in]	normal = MVector

Sets the normal of the CircleSweepManip.'''
        pass

    def setAngle(self, angle): 
        '''setAngle(self, angle)
Arguments:
	[in]	angle = MAngle

Sets the angle of the CircleSweepManip.'''
        pass

    def create(self, manipName, angleName): 
        '''create(self, manipName, angleName) -> MObject
Returns: Returns:
Newly created CircleSweepManip.

Arguments:
	[in]	manipName = MString
	[in]	angleName = MString

Creates a new CircleSweepManip. This function set's object is
set to be the new manipulator.'''
        pass

    def connectToAnglePlug(self, anglePlug): 
        '''connectToAnglePlug(self, anglePlug)
Arguments:
	[in]	anglePlug = MPlug

Connect to the angle plug. The data type corresponding to the
anglePlug is a double. (Note that  MFnUnitAttribute::kAngle  is used to
specify an angle attribute.)'''
        pass

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

'''
        pass

    def endPoint(self): 
        '''endPoint(self) -> MPoint
Returns: Returns:
The end point

Returns the end point.'''
        pass

    def startCircleIndex(self): 
        '''startCircleIndex(self) -> int
Returns: Returns:
The circle start index

Returns the index for the start of the circle of
CircleSweepManip. The data type corresponding to this index is a
double.'''
        pass

    def centerIndex(self): 
        '''centerIndex(self) -> int
Returns: Returns:
The center index

Returns the index for the center of the CircleSweepManip. The
data type corresponding to this index is  MFnNumericData::k3Double .'''
        pass

    def angleIndex(self): 
        '''angleIndex(self) -> int
Returns: Returns:
The angle index

Returns the index for the angle of CircleSweepManip. The data
type corresponding to this index is a double.'''
        pass

    def setCenterPoint(self, centerPoint): 
        '''setCenterPoint(self, centerPoint)
Arguments:
	[in]	centerPoint = MPoint

Sets the center point of the CircleSweepManip.'''
        pass

    def setStartPoint(self, startPoint): 
        '''setStartPoint(self, startPoint)
Arguments:
	[in]	startPoint = MPoint

Sets the start point of the CircleSweepManip.'''
        pass

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

'''
        pass

    def startPoint(self): 
        '''startPoint(self) -> MPoint
Returns: Returns:
The start point

Returns the start point.'''
        pass

class MFnCurveSegmentManip:
    '''CurveSegmentManip function set.'''
    def __init__(self):
        pass


    def setStartParameter(self, startParameter): 
        '''setStartParameter(self, startParameter)
Arguments:
	[in]	startParameter = double

Sets the start parameter.'''
        pass

    def endParameter(self): 
        '''endParameter(self) -> double
Returns: Returns:
End parameter

Returns the end parameter.'''
        pass

    def create(self, manipName, startParamName, endParamName): 
        '''create(self, manipName, startParamName, endParamName) -> MObject
Returns: Returns:
Newly created CurveSegmentManip.

Arguments:
	[in]	manipName = MString
	[in]	startParamName = MString
	[in]	endParamName = MString

Creates a new CurveSegmentManip. This function set's object is
set to be the new manipulator.'''
        pass

    def connectToCurvePlug(self, curvePlug): 
        '''connectToCurvePlug(self, curvePlug)
Arguments:
	[in]	curvePlug = MPlug

Connect to the curve plug. The data type corresponding to the
curvePlug is  MFnData::kNurbsCurve .'''
        pass

    def connectToStartParamPlug(self, startParamPlug): 
        '''connectToStartParamPlug(self, startParamPlug)
Arguments:
	[in]	startParamPlug = MPlug

Connect to the startParam plug. The data type corresponding to
the startParamPlug is a double.'''
        pass

    def setEndParameter(self, endParameter): 
        '''setEndParameter(self, endParameter)
Arguments:
	[in]	endParameter = double

Sets the end parameter.'''
        pass

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

'''
        pass

    def curveIndex(self): 
        '''curveIndex(self) -> int
Returns: Returns:
Curve index

Returns the index of the curve. The data type corresponding to
this index is  MFnData::kNurbsCurve .'''
        pass

    def connectToEndParamPlug(self, endParamPlug): 
        '''connectToEndParamPlug(self, endParamPlug)
Arguments:
	[in]	endParamPlug = MPlug

Connect to the endParam plug. The data type corresponding to the
endParamPlug is a double.'''
        pass

    def endParamIndex(self): 
        '''endParamIndex(self) -> int
Returns: Returns:
End parameter index

Returns the index of the end parameter of the CurveSegmentManip.
The data type corresponding this index is a double.'''
        pass

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

'''
        pass

    def startParamIndex(self): 
        '''startParamIndex(self) -> int
Returns: Returns:
Start parameter index

Returns the index of the start parameter of the
CurveSegmentManip. The data type corresponding to this index is a
double.'''
        pass

    def startParameter(self): 
        '''startParameter(self) -> double
Returns: Returns:


start parameter

Returns the start parameter.'''
        pass

class MFnDirectionManip:
    '''DirectionManip function set.'''
    def __init__(self):
        pass


    def endPointIndex(self): 
        '''endPointIndex(self) -> int
Returns: Returns:
End point index

Returns the index of the end point of the DirectionManip. The
data type corresponding to this index is  MFnNumericData::k3Double .'''
        pass

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

Sets whether or not to draw the start of the DirectionManip. The
start of the DirectionManip is indicated by a grey dot. By default
the start is not drawn.'''
        pass

    def setDirection(self, direction): 
        '''setDirection(self, direction)
Arguments:
	[in]	direction = MVector

Sets the direction of the DirectionManip.'''
        pass

    def create(self, manipName, directionName): 
        '''create(self, manipName, directionName) -> MObject
Returns: Returns:
Newly created DirectionManip.

Arguments:
	[in]	manipName = MString
	[in]	directionName = MString

Creates a new DirectionManip. This function set's object is set
to be the new manipulator.'''
        pass

    def startPointIndex(self): 
        '''startPointIndex(self) -> int
Returns: Returns:
Start point index

Returns the index of the start point of the DirectionManip. The
data type corresponding to this index is  MFnNumericData::k3Double .'''
        pass

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

'''
        pass

    def directionIndex(self): 
        '''directionIndex(self) -> int
Returns: Returns:
Direction index

Returns the index of the direction. The data type corresponding
to this index is  MFnNumericData::k3Double .'''
        pass

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

Sets whether or not to the direction should be normalized. By
default the direction is normalized.'''
        pass

    def setStartPoint(self, startPoint): 
        '''setStartPoint(self, startPoint)
Arguments:
	[in]	startPoint = MPoint

Sets the start point of the DirectionManip.'''
        pass

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

'''
        pass

    def connectToDirectionPlug(self, directionPlug): 
        '''connectToDirectionPlug(self, directionPlug)
Arguments:
	[in]	directionPlug = MPlug

Connect to the direction plug. The data type corresponding to
the directionPlug is  MFnNumericData::k3Double .'''
        pass

class MFnDiscManip:
    '''DiscManip function set.'''
    def __init__(self):
        pass


    def axisIndex(self): 
        '''axisIndex(self) -> int
Returns: Returns:
Axis index

Returns the index of the axis of the DiscManip. The data type
corresponding to this index is  MFnNumericData::k3Double .'''
        pass

    def setNormal(self, normal): 
        '''setNormal(self, normal)
Arguments:
	[in]	normal = MVector

Sets the normal of the DiscManip.'''
        pass

    def setAngle(self, angle): 
        '''setAngle(self, angle)
Arguments:
	[in]	angle = MAngle

Sets the angle of the DiscManip.'''
        pass

    def create(self, manipName, angleName): 
        '''create(self, manipName, angleName) -> MObject
Returns: Returns:
Newly created DiscManip.

Arguments:
	[in]	manipName = MString
	[in]	angleName = MString

Creates a new DiscManip. This function set's object is set to be
the new manipulator.'''
        pass

    def connectToAnglePlug(self, anglePlug): 
        '''connectToAnglePlug(self, anglePlug)
Arguments:
	[in]	anglePlug = MPlug

Connect to the angle plug. The data type corresponding to the
anglePlug is a double. (Note that  MFnUnitAttribute::kAngle  is used to
specify an angle attribute.)'''
        pass

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

'''
        pass

    def angleIndex(self): 
        '''angleIndex(self) -> int
Returns: Returns:
Angle index

Returns the index of the angle. The data type corresponding to
this index is a double.'''
        pass

    def setCenterPoint(self, centerPoint): 
        '''setCenterPoint(self, centerPoint)
Arguments:
	[in]	centerPoint = MPoint

Sets the center point of the DiscManip.'''
        pass

    def setRadius(self, radius): 
        '''setRadius(self, radius)
Arguments:
	[in]	radius = double

Sets the radius of the DiscManip.'''
        pass

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

'''
        pass

    def centerIndex(self): 
        '''centerIndex(self) -> int
Returns: Returns:
Center index

Returns the index of the center of the DiscManip. The data type
corresponding to this index is  MFnNumericData::k3Double .'''
        pass

class MFnDistanceManip:
    '''DistanceManip function set.'''
    def __init__(self):
        pass


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

Sets whether or not to draw the start of the DistanceManip. The
start of the DistanceManip is indicated by a grey dot. By default
the start is not drawn.'''
        pass

    def setScalingFactor(self, scalingFactor): 
        '''setScalingFactor(self, scalingFactor)
Arguments:
	[in]	scalingFactor = double

Sets the scaling factor. The scaling factor is used to determine
how int the DistanceManip appears when it is drawn. The default
scaling factor is 1.0.'''
        pass

    def setDirection(self, direction): 
        '''setDirection(self, direction)
Arguments:
	[in]	direction = MVector

Sets the direction of the DistanceManip.'''
        pass

    def currentPointIndex(self): 
        '''currentPointIndex(self) -> int
Returns: Returns:
Current point index

Returns the index of the current point of the DistanceManip. The
data type corresponding to this index is  MFnNumericData::k3Double .'''
        pass

    def create(self, manipName, distanceName): 
        '''create(self, manipName, distanceName) -> MObject
Returns: Returns:
Newly created DistanceManip.

Arguments:
	[in]	manipName = MString
	[in]	distanceName = MString

Creates a new DistanceManip. This function set's object is set
to be the new manipulator.'''
        pass

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

Sets whether or not to draw a line from the start to the end of
the DistanceManip. By default the line is drawn.'''
        pass

    def connectToDistancePlug(self, distancePlug): 
        '''connectToDistancePlug(self, distancePlug)
Arguments:
	[in]	distancePlug = MPlug

Connect to the distance plug. The data type corresponding to the
distancePlug is a double. (Note that  MFnUnitAttribute::kDistance  is
used to specify a distance attribute.)'''
        pass

    def startPointIndex(self): 
        '''startPointIndex(self) -> int
Returns: Returns:
Start point index

Returns the index of the start point of the DistanceManip. The
data type corresponding to this index is  MFnNumericData::k3Double .'''
        pass

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

'''
        pass

    def directionIndex(self): 
        '''directionIndex(self) -> int
Returns: Returns:
Direction index

Returns the index of the direction. The data type corresponding
to this index is  MFnNumericData::k3Double .'''
        pass

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


true the start of the DistanceManip is being drawn
false the start of the DistanceManip is not being
drawn

Returns whether or not the start of the DistanceManip is being
drawn. By default the start is not drawn.'''
        pass

    def distanceIndex(self): 
        '''distanceIndex(self) -> int
Returns: Returns:
Distance index

Returns the index of the distance. The data type corresponding
to this index is a double.'''
        pass

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


true the line of the DistanceManip is being drawn
false the line of the DistanceManip is not being
drawn

Returns whether or not a line is being drawn from the start to
the end of the DistanceManip. By default the line is drawn.'''
        pass

    def setStartPoint(self, startPoint): 
        '''setStartPoint(self, startPoint)
Arguments:
	[in]	startPoint = MPoint

Sets the start point of the DistanceManip.'''
        pass

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

'''
        pass

    def scalingFactor(self): 
        '''scalingFactor(self) -> double
Returns: Returns:
Scaling factor

Returns the scaling factor. The scaling factor is used to
determine how int the DistanceManip appears when it is drawn.'''
        pass

class MFnFreePointTriadManip:
    '''FreePointTriadManip function set.'''
    def __init__(self):
        pass


    def setDirection(self, direction): 
        '''setDirection(self, direction)
Arguments:
	[in]	direction = MVector

Sets the orientation of the FreePointTriadManip.'''
        pass

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


true the FreePointTriadManip is in keyframeAll mode
false the FreePointTriadManip is not in keyframeAll
mode

Returns whether or not the FreePointTriadManip is in keyframeAll
mode.'''
        pass

    def create(self, manipName, pointName): 
        '''create(self, manipName, pointName) -> MObject
Returns: Returns:
Newly created FreePointTriadManip.

Arguments:
	[in]	manipName = MString
	[in]	pointName = MString

Creates a new FreePointTriadManip. This function set's object is
set to be the new manipulator.'''
        pass

    def connectToPointPlug(self, pointPlug): 
        '''connectToPointPlug(self, pointPlug)
Arguments:
	[in]	pointPlug = MPlug

Connect to the point plug. The data type corresponding to the
pointPlug is  MFnNumericData::k3Double .'''
        pass

    def setGlobalTriadPlane(self, whichPlane): 
        '''setGlobalTriadPlane(self, whichPlane)
Arguments:
	[in]	whichPlane = MFnFreePointTriadManip.ManipPlane

Sets which plane to use as the global triad plane. The global
triad plane does not change until the context switches.'''
        pass

    def kYZPlane(self):
        '''This is an enum of ManipPlane.
Description: Y-Z Plane.
Value: 0'''
        pass

    def kXZPlane(self):
        '''This is an enum of ManipPlane.
Description: X-Z Plane.
Value: 1'''
        pass

    def kXYPlane(self):
        '''This is an enum of ManipPlane.
Description: X-Y Plane.
Value: 2'''
        pass

    def kViewPlane(self):
        '''This is an enum of ManipPlane.
Description: View Plane.
Value: 3'''
        pass

    class ManipPlane:
        '''Non-functional class.  Values for this enum:
        kYZPlane
        kXZPlane
        kXYPlane
        kViewPlane
'''
        def __init__(self):
            pass

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


true the axes of the FreePointTriadManip are being
drawn
false the axes of the FreePointTriadManip are not being
drawn

Returns whether or not the axes of the FreePointTriadManip are
being drawn. By default the axes are drawn.'''
        pass

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

'''
        pass

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


true the FreePointTriadManip is in snap mode
false the FreePointTriadManip is not in snap mode

Returns whether or not the FreePointTriadManip is in snap
mode.'''
        pass

    def pointIndex(self): 
        '''pointIndex(self) -> int
Returns: Returns:
Point index

Returns the index of the point of the FreePointTriadManip. The
data type corresponding to this index is  MFnNumericData::k3Double .'''
        pass

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

Set the point manipulator value to the given vector. This method
can be called in the  MPxManipContainer::connectToDependNode() 
method to set the initial position for the manipulator.'''
        pass

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

Sets whether or not to the FreePointTriadManip should be in snap
mode.'''
        pass

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

Sets whether or not drawArrowHead is on.'''
        pass

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

Sets whether or not keyframeAll is on.'''
        pass

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

'''
        pass

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

Sets whether or not to draw the axes of the FreePointTriadManip.
By default the axes are drawn.'''
        pass

class MFnManip3D:
    '''3D manipulator function set'''
    def __init__(self):
        pass


    def globalSize(self): 
        '''globalSize(self) -> float

Returns the global manipulator size.'''
        pass

    def manipScale(self): 
        '''manipScale(self) -> float
Returns: Returns:
The manipulator scale

Returns the manipulator scale.'''
        pass

    def lineSize(self): 
        '''lineSize(self) -> float

Returns the manipulator line size.'''
        pass

    def setManipScale(self, size): 
        '''setManipScale(self, size)
Arguments:
	[in]	size = float

Sets the manipulator scale.'''
        pass

    def setGlobalSize(self, size): 
        '''setGlobalSize(self, size)
Arguments:
	[in]	size = float

Sets the global manipulator size.'''
        pass

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

'''
        pass

    def setLineSize(self, size): 
        '''setLineSize(self, size)
Arguments:
	[in]	size = float

Sets the manipulator line size.'''
        pass

    def handleSize(self): 
        '''handleSize(self) -> float

Returns the manipulator handle size.'''
        pass

    def setOptimizePlayback(self, optimizePlayback): 
        '''setOptimizePlayback(self, optimizePlayback)
Arguments:
	[in]	optimizePlayback = bool

Sets whether or not to optimize the playback'''
        pass

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

'''
        pass

    def deleteManipulator(self, manip): 
        '''deleteManipulator(self, manip)
Arguments:
	[in]	manip = MObject

Delete a manipulator. This method should be used to delete
manipulators that have been created using base manipulator
 create() 
methods.'''
        pass

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


true the manipulator is visible
false the manipulator is not visible

Returns whether or not the manipulator is visible.'''
        pass

    def setHandleSize(self, size): 
        '''setHandleSize(self, size)
Arguments:
	[in]	size = float

Sets the manipulator handle size.'''
        pass

    def rotateXYZValue(self, valIndex): 
        '''rotateXYZValue(self, valIndex) -> MEulerRotation

Arguments:
	[in]	valIndex = int

Gets the rotation for the active manipulator.'''
        pass

    def setVisible(self, isVisible): 
        '''setVisible(self, isVisible)
Arguments:
	[out]	isVisible = bool

Sets whether or not the manipulator is visible.'''
        pass

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


true optimize playback is on
false optimize playback is off

Returns whether or not optimize playback is on'''
        pass

class MFnPointOnCurveManip:
    '''PointOnCurveManip function set.'''
    def __init__(self):
        pass


    def curvePoint(self): 
        '''curvePoint(self) -> MPoint
Returns: Returns:
The curve point

Returns the curve point.'''
        pass

    def parameter(self): 
        '''parameter(self) -> double
Returns: Returns:
Parameter

Returns the parameter.'''
        pass

    def create(self, manipName, paramName): 
        '''create(self, manipName, paramName) -> MObject

Arguments:
	[in]	manipName = MString
	[in]	paramName = MString

Creates a new PointOnCurveManip. This function set's object is
set to be the new manipulator.'''
        pass

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

Sets whether or not the curve is drawn.'''
        pass

    def connectToCurvePlug(self, curvePlug): 
        '''connectToCurvePlug(self, curvePlug)
Arguments:
	[in]	curvePlug = MPlug

Connect to the curve plug. The data type corresponding to the
curvePlug is  MFnData::kNurbsCurve .'''
        pass

    def connectToParamPlug(self, paramPlug): 
        '''connectToParamPlug(self, paramPlug)
Arguments:
	[in]	paramPlug = MPlug

Connect to the param plug. The data type corresponding to the
paramPlug is a double.'''
        pass

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

'''
        pass

    def curveIndex(self): 
        '''curveIndex(self) -> int
Returns: Returns:
Curve index

Returns the index of the curve. The data type corresponding to
this index is  MFnData::kNurbsCurve .'''
        pass

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


true the curve is being drawn
false the curve is not being drawn

Returns whether or not the curve is drawn.'''
        pass

    def paramIndex(self): 
        '''paramIndex(self) -> int
Returns: Returns:
Parameter index

Returns the index of the parameter of the PointOnCurveManip. The
data type corresponding to this index is a double.'''
        pass

    def setParameter(self, parameter): 
        '''setParameter(self, parameter)
Arguments:
	[in]	parameter = double

Sets the parameter.'''
        pass

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

'''
        pass

class MFnPointOnSurfaceManip:
    '''PointOnSurfaceManip function set.'''
    def __init__(self):
        pass


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

Sets whether or not the arrows should be drawn.'''
        pass

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


true the surface is being drawn
false the surface is not being drawn

Returns whether or not the surface is drawn.'''
        pass

    def setParameters(self, u, v): 
        '''setParameters(self, u, v)
Arguments:
	[in]	u = double
	[in]	v = double

Sets the u and v parameters.'''
        pass

    def create(self, manipName, paramName): 
        '''create(self, manipName, paramName) -> MObject

Arguments:
	[in]	manipName = MString
	[in]	paramName = MString

Creates a new PointOnSurfaceManip. This function set's object is
set to be the new manipulator.'''
        pass

    def paramIndex(self): 
        '''paramIndex(self) -> int
Returns: Returns:
Parameter index

Returns the index of the parameter of the PointOnSurfaceManip.
The data type corresponding to this index is  MFnNumericData::k2Double .'''
        pass

    def connectToParamPlug(self, paramPlug): 
        '''connectToParamPlug(self, paramPlug)
Arguments:
	[in]	paramPlug = MPlug

Connect to the param plug. The data type corresponding to the
paramPlug is  MFnNumericData::k2Double .'''
        pass

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

'''
        pass

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

Sets whether or not the surface is drawn.'''
        pass

    def surfaceIndex(self): 
        '''surfaceIndex(self) -> int
Returns: Returns:
Surface index

Returns the index of the surface. The data type corresponding to
this index is  MFnData::kNurbsSurface .'''
        pass

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

'''
        pass

    def getParameters(self, u, v): 
        '''getParameters(self, u, v)
Arguments:
	[out]	u = double
	[out]	v = double

Returns the parameter.'''
        pass

    def connectToSurfacePlug(self, surfacePlug): 
        '''connectToSurfacePlug(self, surfacePlug)
Arguments:
	[in]	surfacePlug = MPlug

Connect to the surface plug. The data type corresponding to the
surfacePlug is  MFnData::kNurbsSurface .'''
        pass

class MFnRotateManip:
    '''RotateManip function set.'''
    def __init__(self):
        pass


    def connectToRotationCenterPlug(self, rotationCenterPlug): 
        '''connectToRotationCenterPlug(self, rotationCenterPlug)
Arguments:
	[in]	rotationCenterPlug = MPlug

Create a 1-1 association of the rotation center on the
manipulator and the rotationCenterPlug parameter. When both the
rotation center is attached to a plug and the  displayWithNode() 
method has been called, the manipulator will display with the node
regardless of the connection made to the rotation center.'''
        pass

    def setSnapMode(self, snapEnabled): 
        '''setSnapMode(self, snapEnabled)
Arguments:
	[in]	snapEnabled = bool

Sets the snap mode. The snap modes can be either on (true) or
off (false). When snap mode is on, rotation manip values will snap
to the values within some increment apart.'''
        pass

    def create(self, manipName, rotationName): 
        '''create(self, manipName, rotationName) -> MObject
Returns: Returns:
An object corresponding to the new manipulator

Arguments:
	[in]	manipName = MString
	[in]	rotationName = MString

Creates a new RotateManip, and attaches this function set to the
new manipulator.'''
        pass

    def rotateMode(self): 
        '''rotateMode(self) -> MFnRotateManip.RotateMode

Returns the current rotation mode.'''
        pass

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

Returns the snapping increment in degrees.'''
        pass

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

'''
        pass

    def kWorldSpace(self):
        '''This is an enum of RotateMode.
Description: World Space.
Value: 1'''
        pass

    def kObjectSpace(self):
        '''This is an enum of RotateMode.
Description: Object Space (default).
Value: 0'''
        pass

    def kGimbal(self):
        '''This is an enum of RotateMode.
Description: Gimbal.
Value: 2'''
        pass

    class RotateMode:
        '''Non-functional class.  Values for this enum:
        kWorldSpace
        kObjectSpace
        kGimbal
'''
        def __init__(self):
            pass

    def setSnapIncrement(self, snapInc): 
        '''setSnapIncrement(self, snapInc)
Arguments:
	[in]	snapInc = double

Sets the snap increment. The snap increment is specified in
degrees. Manipulator values will snap to the next rotation at an
angle of snapInc from the original rotation. Note that snap rotate
does not apply to the trackball rotations (when dragging between
the rotate discs).'''
        pass

    def setInitialRotation(self, rotation): 
        '''setInitialRotation(self, rotation)
Arguments:
	[in]	rotation = MEulerRotation

Sets the initial rotation for the rotate manipulator. Setting
the initial rotation will prevent the manipulator from jumping back
to the default rotation when there is already an existing rotation
on the target plug.'''
        pass

    def setRotateMode(self, mode): 
        '''setRotateMode(self, mode)
Arguments:
	[in]	mode = MFnRotateManip.RotateMode

Sets the mode for the rotation manipulator. The manipulator mode
controls the appearance of the manipulator when is it used.'''
        pass

    def connectToRotationPlug(self, rotationPlug): 
        '''connectToRotationPlug(self, rotationPlug)
Arguments:
	[in]	rotationPlug = MPlug

Create a 1-1 connection from the rotation manipVal to the
rotationPlug parameter. Any changes to the rotation manipVal will
be immediately reflected in the connected plug. Connecting to the
"rotation" plug on a transform node will produce similar behavior
to the built-in rotate manipulator.'''
        pass

    def rotationIndex(self): 
        '''rotationIndex(self) -> int
Returns: Returns:
Rotation index

Returns the index of the rotation manipVal for the manipulator.
When plugToManip conversion functions are used to produce the
rotation manipVal, the manipulator data must be of the type
 MFnNumericData::k3Double , with X,Y, and
Z rotations given in radians. This is easily accomplished by using
the  MEulerRotation  class to manage the
rotations.'''
        pass

    def rotationCenterIndex(self): 
        '''rotationCenterIndex(self) -> int
Returns: Returns:
Rotation center index

Returns the index of the rotation center for the
manipulator.'''
        pass

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

'''
        pass

    def displayWithNode(self, node): 
        '''displayWithNode(self, node)
Arguments:
	[in]	node = MObject

Configures the manipulator to display with the node, causing the
position of the manipulator to follow the position of the node
whenever the node is moved. The node must be a DAG object.'''
        pass

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

Returns true when snap mode is on.'''
        pass

class MFnScaleManip:
    '''ScaleManip function set.'''
    def __init__(self):
        pass


    def connectToScaleCenterPlug(self, scaleCenterPlug): 
        '''connectToScaleCenterPlug(self, scaleCenterPlug)
Arguments:
	[in]	scaleCenterPlug = MPlug

Create a 1-1 association of the scale center on the manipulator
and the scaleCenterPlug parameter. When both the scale center is
attached to a plug and the  displayWithNode() 
method has been called, the manipulator will display with the node
regardless of the connection made to the scale center.'''
        pass

    def create(self, manipName, scaleName): 
        '''create(self, manipName, scaleName) -> MObject
Returns: Returns:
An object corresponding to the new manipulator

Arguments:
	[in]	manipName = MString
	[in]	scaleName = MString

Creates a new ScaleManip, and attaches this function set to the
new manipulator.'''
        pass

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

Returns the snapping increment in working units.'''
        pass

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

'''
        pass

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

Returns true when snap mode is on.'''
        pass

    def setSnapIncrement(self, snapInc): 
        '''setSnapIncrement(self, snapInc)
Arguments:
	[in]	snapInc = double

Sets the snap increment. The snap increment is specified in the
working unit, and is the distance between snap points when dragging
the scale handles.'''
        pass

    def setInitialScale(self, scale): 
        '''setInitialScale(self, scale)
Arguments:
	[in]	scale = MVector

Sets the initial scale for the scale manipulator. Setting the
initial scale will prevent the manipulator from jumping back to the
default scale when there is already an existing scale on the target
plug.'''
        pass

    def setSnapMode(self, snapEnabled): 
        '''setSnapMode(self, snapEnabled)
Arguments:
	[in]	snapEnabled = bool

Sets the snap mode. The snap modes can be either on (true) or
off (false). When snap mode is on, scale values will snap to scale
value within some interval apart. The interval is set using
 setSnapIncrement() .'''
        pass

    def scaleIndex(self): 
        '''scaleIndex(self) -> int
Returns: Returns:
Scale index

Returns the index of the scale manipVal for this
manipulator.'''
        pass

    def connectToScalePlug(self, scalePlug): 
        '''connectToScalePlug(self, scalePlug)
Arguments:
	[in]	scalePlug = MPlug

Create a 1-1 connection from the scale manipVal to the scalePlug
parameter. Any changes to the scale manipVal will be immediately
reflected in the connected plug. Connecting to the "scale" plug on
a transform node will produce similar behavior to the built-in
scale manipulator.'''
        pass

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

'''
        pass

    def displayWithNode(self, node): 
        '''displayWithNode(self, node)
Arguments:
	[in]	node = MObject

Configures the manipulator to display with the node, causing the
position of the manipulator to follow the position of the node
whenever the node is moved. The node must be a DAG object.'''
        pass

    def scaleCenterIndex(self): 
        '''scaleCenterIndex(self) -> int
Returns: Returns:
Scale center index

Returns the index of the scale center manipVal for this
manipulator.'''
        pass

class MFnStateManip:
    '''StateManip function set.'''
    def __init__(self):
        pass


    def setMaxStates(self, numStates): 
        '''setMaxStates(self, numStates)
Arguments:
	[in]	numStates = int

Sets the maximum number of states that the StateManip will have.
The default number of maximum states is 4.'''
        pass

    def create(self, manipName, stateName): 
        '''create(self, manipName, stateName) -> MObject

Arguments:
	[in]	manipName = MString
	[in]	stateName = MString

Creates a new StateManip. This function set's object is set to
be the new manipulator.'''
        pass

    def setInitialState(self, initialState): 
        '''setInitialState(self, initialState)
Arguments:
	[in]	initialState = int

Sets the initial state of the StateManip.'''
        pass

    def state(self): 
        '''state(self) -> int
Returns: Returns:
Current states

Returns the current state.'''
        pass

    def positionIndex(self): 
        '''positionIndex(self) -> int
Returns: Returns:
Position index

Returns the index of the position of the StateManip. The data
type corresponding to this index is  MFnNumericData::k3Double .'''
        pass

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

'''
        pass

    def connectToStatePlug(self, statePlug): 
        '''connectToStatePlug(self, statePlug)
Arguments:
	[in]	statePlug = MPlug

Connect to the state plug. The data type corresponding to the
statePlug is a int integer.'''
        pass

    def stateIndex(self): 
        '''stateIndex(self) -> int
Returns: Returns:
State index

Returns the index of the state. The data type corresponding to
this index is a int integer.'''
        pass

    def maxStates(self): 
        '''maxStates(self) -> int
Returns: Returns:
Maximum states

Returns the number of maximum states.'''
        pass

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

'''
        pass

class MFnToggleManip:
    '''ToggleManip function set.'''
    def __init__(self):
        pass


    def direction(self): 
        '''direction(self) -> MVector
Returns: Returns:
The direction

Returns the direction.'''
        pass

    def setToggle(self, toggle): 
        '''setToggle(self, toggle)
Arguments:
	[in]	toggle = bool

Sets the toggle of the ToggleManip.'''
        pass

    def connectToTogglePlug(self, togglePlug): 
        '''connectToTogglePlug(self, togglePlug)
Arguments:
	[in]	togglePlug = MPlug

Connect to the toggle plug. The data type corresponding to the
togglePlug is a boolean value.'''
        pass

    def setDirection(self, direction): 
        '''setDirection(self, direction)
Arguments:
	[in]	direction = MVector

Sets the direction of the ToggleManip.'''
        pass

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

'''
        pass

    def create(self, manipName, toggleName): 
        '''create(self, manipName, toggleName) -> MObject

Arguments:
	[in]	manipName = MString
	[in]	toggleName = MString

Creates a new ToggleManip. This function set's object is set to
be the new manipulator.'''
        pass

    def toggle(self): 
        '''toggle(self) -> bool
Returns: Returns:
Toggle

Returns the toggle.'''
        pass

    def lengthIndex(self): 
        '''lengthIndex(self) -> int
Returns: Returns:
Length index

Returns the index of the length of the ToggleManip. The data
type corresponding to this index is a double.'''
        pass

    def startPointIndex(self): 
        '''startPointIndex(self) -> int
Returns: Returns:
Start point index

Returns the index of the start point of the ToggleManip. The
data type corresponding to this index is  MFnNumericData::k3Double .'''
        pass

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

'''
        pass

    def toggleIndex(self): 
        '''toggleIndex(self) -> int
Returns: Returns:
Toggle index

Returns the index of the toggle of the ToggleManip. The data
type corresponding to this index is a boolean.'''
        pass

    def length(self): 
        '''length(self) -> double
Returns: Returns:
Length

Returns the length.'''
        pass

    def directionIndex(self): 
        '''directionIndex(self) -> int
Returns: Returns:
Direction index

Returns the index of the direction. The data type corresponding
to this index is  MFnNumericData::k3Double .'''
        pass

    def setStartPoint(self, startPoint): 
        '''setStartPoint(self, startPoint)
Arguments:
	[in]	startPoint = MPoint

Sets the start point of the ToggleManip.'''
        pass

    def startPoint(self): 
        '''startPoint(self) -> MPoint
Returns: Returns:
The start point

Returns the start point.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = double

Sets the length of the ToggleManip.'''
        pass

class MHWShaderSwatchGenerator:
    '''Hardware shader swatch generator utility class.'''
    def __init__(self):
        pass


    def initialize(self): 
        '''initialize(self) -> const MString

This method sets a swatch name, and registers a new swatch
generator creation function for the swatch name. The string
returned from this method can be used for node classification
purpose.   Reprocessed example '''
        pass

    def getSwatchBackgroundColor(self, r, g, b, a): 
        '''getSwatchBackgroundColor(self, r, g, b, a)
Arguments:
	[out]	r = float
	[out]	g = float
	[out]	b = float
	[out]	a = float

This method returns the default background color for the
hardware rendered swatch.'''
        pass

    def createObj(self, obj, renderObj, resolution): 
        '''createObj(self, obj, renderObj, resolution) -> MSwatchRenderBase

Arguments:
	[in]	obj = MObject
	[in]	renderObj = MObject
	[in]	resolution = int

Class constructor. Saves the Node object and image resolution as
data members for future use.'''
        pass

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

'''
        pass

class MManipData:
    '''Manipulator Data.'''
    def __init__(self):
        pass


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

Returns the manipulator data as an  MObject . The MObjects returned from this
method are created and used by  MFnData  or classes derived from
 MFnData .'''
        pass

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

Returns the manipulator data as a bool.'''
        pass

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

Returns whether or not the manipulator data is simple or
complex. Simple data is used to represent bool, short, int,
unsigned int, float, and double types. Complex data is used to
represent MObjects created by  MFnData , or classes derived from
 MFnData .'''
        pass

    def asShort(self): 
        '''asShort(self) -> short

Returns the manipulator data as a short.'''
        pass

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

Returns the manipulator data as a double.'''
        pass

    def asFloat(self): 
        '''asFloat(self) -> float

Returns the manipulator data as a float.'''
        pass

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

Returns the manipulator data as a int'''
        pass

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

Returns the manipulator data as an unsigned int.'''
        pass

class MMaterial:
    '''Hardware shading material class used in MPxSurfaceShapeUI.'''
    def __init__(self):
        pass


    def getDiffuse(self, color): 
        '''getDiffuse(self, color)
Arguments:
	[out]	color = MColor

Get the GL diffuse color.'''
        pass

    def getTextureTransformation(self, scaleU, scaleV, translateU, translateV, rotate): 
        '''getTextureTransformation(self, scaleU, scaleV, translateU, translateV, rotate)
Arguments:
	[out]	scaleU = float
	[out]	scaleV = float
	[out]	translateU = float
	[out]	translateV = float
	[out]	rotate = float

Get the current textures transformation.'''
        pass

    def getShininess(self, value): 
        '''getShininess(self, value)
Arguments:
	[out]	value = float

Get the GL shininess.'''
        pass

    def setMaterial(self, path, hasTransparency): 
        '''setMaterial(self, path, hasTransparency)
Arguments:
	[in]	path = MDagPath
	[in]	hasTransparency = bool

Set the current GL material.'''
        pass

    def getHasTransparency(self, value): 
        '''getHasTransparency(self, value)
Arguments:
	[out]	value = bool

Get flag to determine if material or texture has
transparency.'''
        pass

    def evaluateTextureTransformation(self): 
        '''evaluateTextureTransformation(self)
Perform necessary evaluation to be able to get the texture
transformation information back.'''
        pass

    def getSpecular(self, color): 
        '''getSpecular(self, color)
Arguments:
	[out]	color = MColor

Get the GL specular color.'''
        pass

    def textureImage(self, image, color, chan, mapped, dagPath, xRes, yRes): 
        '''textureImage(self, image, color, chan, mapped, dagPath, xRes, yRes)
Arguments:
	[in]	image = MImage
	[in]	color = MColor
	[in]	chan = MMaterial.MtextureChannel
	[in]	mapped = bool
	[in]	dagPath = MDagPath
	[in]	xRes = int
	[in]	yRes = int

For materials that have texture, this method will attempt to
retrieve the pixel map for a given mapped channel of that material.
If the channel is not mapped than a status of failure will be
returned.'''
        pass

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

Do we have a texture (evaluated or not).'''
        pass

    def getHwShaderNode(self): 
        '''getHwShaderNode(self) -> MPxHwShaderNode

Get the hardware shader node. If this material has a hardware
shader, a pointer to it will be returned in hwShader. If there is
no hardware shader, hwShader will be set to NULL.'''
        pass

    def getEmission(self, color): 
        '''getEmission(self, color)
Arguments:
	[out]	color = MColor

Get the GL emission color.'''
        pass

    def kRoughness(self):
        '''This is an enum of MtextureChannel.
Description: PhongE only.
Value: 7'''
        pass

    def kTransluscence(self):
        '''This is an enum of MtextureChannel.
Description: 
Value: 6'''
        pass

    def kWhiteness(self):
        '''This is an enum of MtextureChannel.
Description: PhongE only.
Value: 9'''
        pass

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

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

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

    def kDiffuse(self):
        '''This is an enum of MtextureChannel.
Description: 
Value: 5'''
        pass

    def kSpecularRollOff(self):
        '''This is an enum of MtextureChannel.
Description: Blinn only.
Value: 12'''
        pass

    def kReflectedColor(self):
        '''This is an enum of MtextureChannel.
Description: Blinn and Phong(E) only.
Value: 15'''
        pass

    def kHighlightSize(self):
        '''This is an enum of MtextureChannel.
Description: PhongE only.
Value: 8'''
        pass

    def kCosinePower(self):
        '''This is an enum of MtextureChannel.
Description: Phong only.
Value: 10'''
        pass

    def kReflectivity(self):
        '''This is an enum of MtextureChannel.
Description: Blinn and Phong(E) only.
Value: 14'''
        pass

    def kSpecularColor(self):
        '''This is an enum of MtextureChannel.
Description: Blinn and Phong(E) only.
Value: 13'''
        pass

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

    def kEccentricity(self):
        '''This is an enum of MtextureChannel.
Description: Blinn only.
Value: 11'''
        pass

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

    class MtextureChannel:
        '''Non-functional class.  Values for this enum:
        kRoughness
        kTransluscence
        kWhiteness
        kBumpMap
        kTransparency
        kColor
        kDiffuse
        kSpecularRollOff
        kReflectedColor
        kHighlightSize
        kCosinePower
        kReflectivity
        kSpecularColor
        kAmbientColor
        kEccentricity
        kIncandescence
'''
        def __init__(self):
            pass

    def evaluateMaterial(self, view, path): 
        '''evaluateMaterial(self, view, path)
Arguments:
	[in]	view = M3dView
	[in]	path = MDagPath

Evaluate a material. Must be called before evaluating or getting
any material properties.'''
        pass

    def evaluateSpecular(self): 
        '''evaluateSpecular(self)
Perform necessary evaluation to be able to get emission
back.'''
        pass

    def applyTexture(self, view, data): 
        '''applyTexture(self, view, data)
Arguments:
	[in]	view = M3dView
	[in]	data = MDrawData

For materials that have texture, this method must be used before
the OpenGL drawing to apply the texture to the current view. This
method should be called from within your  
MPxSurfaceShapeUI::draw  method.'''
        pass

    def evaluateTexture(self, data): 
        '''evaluateTexture(self, data)
Arguments:
	[in]	data = MDrawData

Do texture evaluation and set a flag to tell if the texture is
transparent.'''
        pass

    def evaluateShininess(self): 
        '''evaluateShininess(self)
Perform necessary evaluation to be able to get shininess
back.'''
        pass

    def evaluateEmission(self): 
        '''evaluateEmission(self)
Perform necessary evaluation to be able to get emission
back.'''
        pass

    def defaultMaterial(self): 
        '''defaultMaterial(self) -> MMaterial

Get the default material. There will always be a default
material in the scene and therefore the result of this function
should always succeed. The default material will correspond to the
initialShadingGroup node that is in the scene.'''
        pass

    def evaluateDiffuse(self): 
        '''evaluateDiffuse(self)
Perform necessary evaluation to be able to get diffuse back.'''
        pass

class MProgressWindow:
    '''Create and manipulate progress windows.'''
    def __init__(self):
        pass


    def startProgress(self): 
        '''startProgress(self)
Displays the progress window on the screen.'''
        pass

    def progressMax(self): 
        '''progressMax(self) -> int
Returns: Returns:
Maximum progress value. Returns -1 if query fails.

Get the maximum progress value.'''
        pass

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

Sets whether the progress window is interruptable. An
interruptable progress window can accept a signal from the user
indicating that the operation should be cancelled.'''
        pass

    def setProgressMax(self, maxValue): 
        '''setProgressMax(self, maxValue)
Arguments:
	[in]	maxValue = int

Sets the maximum value for the progress. Any progress value
greater then maxValue will be set to maxValue, with the progress
bar displayed as full.'''
        pass

    def setProgressRange(self, minValue, maxValue): 
        '''setProgressRange(self, minValue, maxValue)
Arguments:
	[in]	minValue = int
	[in]	maxValue = int

Sets the range (minValue, maxValue) of the progress indicator.
When the progress value is set through  setProgress() 
or  advanceProgress() ,
it is checked against the minimum and maximum progress values. If
the new progress value lies outside this range, it is clamped to a
value in this range.'''
        pass

    def endProgress(self): 
        '''endProgress(self)
Destroys the progress window and removes it from the screen.
This method also unreserves the progress window, making it
available for future reservation.'''
        pass

    def setTitle(self, title): 
        '''setTitle(self, title)
Arguments:
	[in]	title = MString

Sets the title of the progress window.'''
        pass

    def title(self): 
        '''title(self) -> MString
Returns: Returns:
Window title string.

Get the window title.'''
        pass

    def isCancelled(self): 
        '''isCancelled(self) -> bool
Returns: Returns:
true when user has tried to cancel progress. If the progress
window is not interruptable, this method returns false.

Determine whether the user has tried to cancel an interruptable
progress window.'''
        pass

    def advanceProgress(self, amount): 
        '''advanceProgress(self, amount)
Arguments:
	[in]	amount = int

Increases the progress value by amount. If the resulting
progress value is not between  progressMin() 
and  progressMax() 
inclusively, it is set to whichever of  progressMin() 
or  progressMax() 
is closest.'''
        pass

    def isInterruptable(self): 
        '''isInterruptable(self) -> bool
Returns: Returns:
true when the progress window is interruptable

Determine whether the progress window is interruptable.'''
        pass

    def setProgressStatus(self, progressStatus): 
        '''setProgressStatus(self, progressStatus)
Arguments:
	[in]	progressStatus = MString

Sets the progress status string. This string is shown above the
progress bar and usually is of the form "Performing operation:
 XXX " where  XXX  is a numerical indication
of the amount completed.'''
        pass

    def progress(self): 
        '''progress(self) -> int
Returns: Returns:
Progress value. Returns -1 if query fails.

Get the progress value.'''
        pass

    def progressStatus(self): 
        '''progressStatus(self) -> MString
Returns: Returns:
Progress status string.

Get the progress status string.'''
        pass

    def setProgressMin(self, minValue): 
        '''setProgressMin(self, minValue)
Arguments:
	[in]	minValue = int

Sets the minimum value for the progress. Any progress value less
then minValue will be set to minValue, with the progress bar
displayed as empty.'''
        pass

    def setProgress(self, progress): 
        '''setProgress(self, progress)
Arguments:
	[in]	progress = int

Sets the progress value. If progress is not between  progressMin() 
and  progressMax() 
inclusively, it is set to whichever of  progressMin() 
or  progressMax() 
is closest.'''
        pass

    def progressMin(self): 
        '''progressMin(self) -> int
Returns: Returns:
Minimum progress value. Returns -1 if query fails.

Get the minimum progress value.'''
        pass

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

Reserves a progress window for use through this class. This
method must be called before setting progress window parameters or
starting progress.'''
        pass

class MQtUtil:
    '''Qt Utility Methods.'''
    def __init__(self):
        pass


    def findLayout(self, layoutName, ancestor): 
        '''findLayout(self, layoutName, ancestor) -> MQtUtil.QWidget*
Returns: Returns:
Pointer to the layout's underlying QWidget. Returns NULL if the
layout is not found.

Arguments:
	[in]	layoutName = MString
	[in]	ancestor = MQtUtil.QWidget

Returns the QWidget for the named Maya layout.'''
        pass

    def toQString(self, mstr): 
        '''toQString(self, mstr) -> MQtUtil.QString
Returns: Returns:
A QString containing the same text as 'mstr'.

Arguments:
	[in]	mstr = MString

Convenience utility to convert an  MString  to a
QString.'''
        pass

    def getParent(self, uiElement): 
        '''getParent(self, uiElement) -> MQtUtil.QObject*
Returns: Returns:
A pointer to the element's parent element, or NULL is the
element has no parent or is a window.

Arguments:
	[in]	uiElement = MQtUtil.QObject

Returns a pointer to a UI element's parent element within Maya's
UI hierarchy.'''
        pass

    def findMenuItem(self, itemName): 
        '''findMenuItem(self, itemName) -> MQtUtil.QAction*
Returns: Returns:
Pointer to the menuItem's underlying QAction. Returns NULL if
the menuItem is not found.

Arguments:
	[in]	itemName = MString

Returns the QAction for the named Maya menuItem.'''
        pass

    def nativeWindow(self, control): 
        '''nativeWindow(self, control) -> MQtUtil.MNativeWindowHdl
Returns: Returns:
The native window handle of the specified control. On Linux
this will be an Xlib 'Window'. On 32-bit OS X it will be an
'HIViewRef'. On 64-bit OS X it will be an 'NSView' pointer. On
Microsoft Windows it will be an 'HWND'.

Arguments:
	[in]	control = MQtUtil.QWidget

Returns a platform-specific native window handle for the
specified control.'''
        pass

    def toMString(self, qstr): 
        '''toMString(self, qstr) -> MString
Returns: Returns:
An MString containing the same text as
'qstr'.

Arguments:
	[in]	qstr = MQtUtil.QString

Convenience utility to convert a QString to an  MString .'''
        pass

    def fullName(self, uiElement): 
        '''fullName(self, uiElement) -> MString
Returns: Returns:
String containing the full hierarchical name of the UI element,
or an empty string if the element does not exist.

Arguments:
	[in]	uiElement = MQtUtil.QObject

Returns the full, hierarchical name of a UI element. This is the
name which uniquely identifies the element within Maya and can be
passed to Maya's UI commands.'''
        pass

    def findWindow(self, windowName): 
        '''findWindow(self, windowName) -> MQtUtil.QWidget*
Returns: Returns:
Pointer to the window's underlying QWidget. Returns NULL if the
window is not found.

Arguments:
	[in]	windowName = MString

Returns the QWidget for the named Maya window.'''
        pass

    def mainWindow(self): 
        '''mainWindow(self) -> MQtUtil.QWidget*

Returns Maya's main window.'''
        pass

    def getLayoutChildren(self, layout): 
        '''getLayoutChildren(self, layout) -> MQtUtil.QList<QObject*>
Returns: Returns:
A list of QObjects for all of the Maya controls and layouts
parented beneath the specified layout.

Arguments:
	[in]	layout = MQtUtil.QWidget

Returns a list of all the Maya UI elements parented directly
beneath the specified Maya layout.'''
        pass

    def findControl(self, controlName, ancestor): 
        '''findControl(self, controlName, ancestor) -> MQtUtil.QWidget*
Returns: Returns:
Pointer to the control's underlying QWidget. Returns NULL if
the control is not found.

Arguments:
	[in]	controlName = MString
	[in]	ancestor = MQtUtil.QWidget

Returns the QWidget for the named Maya control.'''
        pass

class MSelectInfo:
    '''Selection state information used in 
MPxSurfaceShapeUI::select.'''
    def __init__(self):
        pass


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

Is there a selection ray. This method isused to find ray object
intersection.'''
        pass

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

Determines if we want to select the closest object.'''
        pass

    def selectableComponent(self, displayed, mask): 
        '''selectableComponent(self, displayed, mask) -> bool
Returns: Returns:


true the component is selectable
false the component not is selectable

Arguments:
	[in]	displayed = bool
	[in]	mask = MSelectionMask

Given the selection mask, this method determines if the
component is selectable.'''
        pass

    def getLocalRay(self, pnt, vec): 
        '''getLocalRay(self, pnt, vec)
Arguments:
	[out]	pnt = MPoint
	[out]	vec = MVector

Get the selection ray. This method isused to find ray object
intersection.'''
        pass

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

Returns the highest selection priority value.'''
        pass

    def selectPath(self): 
        '''selectPath(self) -> MDagPath

Returns a path to the item that is being selected.'''
        pass

    def addSelection(self, item, point, mask, isComponent, list, points): 
        '''addSelection(self, item, point, mask, isComponent, list, points)
Arguments:
	[in]	item = MSelectionList
	[in]	point = MPoint
	[out]	list = MSelectionList
	[out]	points = MPointArray
	[in]	mask = MSelectionMask
	[in]	isComponent = bool

Adds components or objects to the active selection list. For an
example of how this is used please refer to the method definition
apiMeshShapeUI::select() in the devkit example code
apiMeshShape.cpp.'''
        pass

    def setHighestPriority(self, value): 
        '''setHighestPriority(self, value)
Arguments:
	[in]	value = int

Sets the highest selection priority value.'''
        pass

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


true can select for hilite
false can't select for hilite

Arguments:
	[in]	mask = MSelectionMask

Give the selection mask, can this object be selected for the
hilite list.'''
        pass

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

This methods determines if we want to select a single
object.'''
        pass

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


true the object is selectable
false the object not is selectable

Arguments:
	[in]	mask = MSelectionMask

Given the selection mask, this method determines if the object
is selectable.'''
        pass

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

This means that you can only select components if the object is
hilited.'''
        pass

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

Returns the alignment matrix. This method is used to find ray
object intersection.'''
        pass

    def view(self): 
        '''view(self) -> M3dView

Returns the view that the current selection is taking place
in.'''
        pass

class MTextureEditorDrawInfo:
    '''Drawing state for drawing to the UV texture window with custom
shapes.'''
    def __init__(self):
        pass


    def kDrawVertexForSelect(self):
        '''This is an enum of DrawingFunction.
Description: Draw vertices for selection.
Value: 3'''
        pass

    def kDrawFunctionLast(self):
        '''This is an enum of DrawingFunction.
Description: Highest possible enum value.
Value: 6'''
        pass

    def kDrawWireframe(self):
        '''This is an enum of DrawingFunction.
Description: Draw wireframe only (default).
Value: 1'''
        pass

    def kDrawFacetForSelect(self):
        '''This is an enum of DrawingFunction.
Description: Draw faces for selection.
Value: 5'''
        pass

    def kDrawEdgeForSelect(self):
        '''This is an enum of DrawingFunction.
Description: Draw edges for selection.
Value: 4'''
        pass

    def kDrawEverything(self):
        '''This is an enum of DrawingFunction.
Description: Draw vertices, uvs, faces, and edges.
Value: 2'''
        pass

    def kDrawFunctionFirst(self):
        '''This is an enum of DrawingFunction.
Description: Lowest possible enum value.
Value: 1'''
        pass

    def kDrawUVForSelect(self):
        '''This is an enum of DrawingFunction.
Description: Draw uvs for selection.
Value: 6'''
        pass

    class DrawingFunction:
        '''Non-functional class.  Values for this enum:
        kDrawVertexForSelect
        kDrawFunctionLast
        kDrawWireframe
        kDrawFacetForSelect
        kDrawEdgeForSelect
        kDrawEverything
        kDrawFunctionFirst
        kDrawUVForSelect
'''
        def __init__(self):
            pass

    def setDrawingFunction(self, func): 
        '''setDrawingFunction(self, func)
Arguments:
	[in]	func = MTextureEditorDrawInfo.DrawingFunction

Sets the current drawing state. Currently the API user is unable
to set these values. All drawing state values are determined
internally and passed onto the API programmer.'''
        pass

    def drawingFunction(self): 
        '''drawingFunction(self) -> MTextureEditorDrawInfo.DrawingFunction

Indicates the current drawing state for a drawUV method
call.'''
        pass

class MToolsInfo:
    '''Tool information.'''
    def __init__(self):
        pass


    def setDirtyFlag(self, context): 
        '''setDirtyFlag(self, context)
Arguments:
	[in]	context = MPxContext

This method should be called by a tool when the value of a tool
property sheet option has changed. The dirty flag will only be set
if this is the current tool.'''
        pass

    def resetDirtyFlag(self): 
        '''resetDirtyFlag(self)
'''
        pass

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

This method returns whether or not the dirty flag is set.'''
        pass

class MUiMessage:
    '''UI messages.'''
    def __init__(self):
        pass


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

Arguments:
	[in]	panelName = MString
	[in]	func = MUiMessage.MStringIndexFunction
	[in]	clientData = void

This method registers a callback for when a particular 3d view's
specific pass is about to be drawn when multiple drawing is
enabled.'''
        pass

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

Arguments:
	[in]	panelName = MString
	[in]	func = MMessage.MStringNode
	[in]	clientData = void

This method registers a callback for cameras being changed in 3d
views. The callback is called when the camera changes for the given
panel, not when attributes on the panel's camera change.'''
        pass

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

Arguments:
	[in]	uiName = MString
	[in]	func = MMessage.MBasicFunction
	[in]	clientData = void

This method registers a callback for UI deleted messages.'''
        pass

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

Arguments:
	[in]	panelName = MString
	[in]	func = MUiMessage.MStringIndexFunction
	[in]	clientData = void

This method registers a callback for when a particular 3d view's
specified pass is finshed when multiple drawing is enabled.'''
        pass

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

Arguments:
	[in]	panelName = MString
	[in]	func = MUiMessage.MStringFunction
	[in]	clientData = void

This method registers a callback for when the 3d view is about
to display it's rendered contents to the viewport. It is called for
every refresh of the view, after the scene is drawn, but before any
2d adornments are drawn.'''
        pass

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

Arguments:
	[in]	panelName = MString
	[in]	func = MUiMessage.MStringFunction
	[in]	clientData = void

This method registers a callback for when a particular 3d view
is about to render it's contents. It is called before the scene is
drawn, but after the background has been drawn.'''
        pass

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

Arguments:
	[in]	panelName = MString
	[in]	func = MUiMessage.MStringFunction
	[in]	clientData = void

This method registers a callback for when a particular 3d view
gets destroyed. The callback is called before the destruction of
the view.'''
        pass

